Snippet:\\n instance.title = validated_data.get('title', default=instance.title)\\n instance.code = validated_data.get('code', default=instance.code)\\n instance.language = validated_data.get('language', default=instance.language)\\n instance.style = validated_data.get('style', default=instance.style)\\n instance.save()\\n return instance\",\n \"def create(self, validated_data: dict) -> Snippet:\\n return Snippet.objects.create(**validated_data)\",\n \"def load(cls, id):\\n key = cls.get_key_prefix()+\\\"#\\\"+str(id)\\n src = dal_get(key)\\n logger.debug( \\\"LOAD %s %s %s\\\", str(key), str(id), str(src))\\n if src == None:\\n raise cls.NotExist(\\\"No instance could be found with ID: \\\"+str(id))\\n result = dal_retrieve(src)\\n result = cls._from_dict(result)\\n return result\",\n \"def restore_object(self, attrs, instance=None):\\n if instance:\\n # Update existing instance\\n instance.title = attrs.get('title', instance.title)\\n instance.code = attrs.get('code', instance.code)\\n instance.value = attrs.get('value', instance.value)\\n return instance\\n\\n return Snippet(**attrs)\",\n \"def snippet_details(request, snippet_id, template_name='dpaste/snippet_details.html', is_raw=False):\\n snippet = get_object_or_404(Snippet, secret_id=snippet_id)\\n\\n # One time snippet get deleted if the view count matches our limit\\n if snippet.expire_type == Snippet.EXPIRE_ONETIME \\\\\\n and snippet.view_count >= ONETIME_LIMIT:\\n snippet.delete()\\n raise Http404()\\n\\n # Increase the view count of the snippet\\n snippet.view_count += 1\\n snippet.save()\\n\\n tree = snippet.get_root()\\n tree = tree.get_descendants(include_self=True)\\n\\n new_snippet_initial = {\\n 'content': snippet.content,\\n 'lexer': snippet.lexer,\\n }\\n\\n if request.method == \\\"POST\\\":\\n snippet_form = SnippetForm(\\n data=request.POST,\\n request=request,\\n initial=new_snippet_initial)\\n if snippet_form.is_valid():\\n new_snippet = snippet_form.save(parent=snippet)\\n url = new_snippet.get_absolute_url()\\n return HttpResponseRedirect(url)\\n else:\\n snippet_form = SnippetForm(\\n initial=new_snippet_initial,\\n request=request)\\n\\n template_context = {\\n 'snippet_form': snippet_form,\\n 'snippet': snippet,\\n 'lexers': LEXER_LIST,\\n 'lines': range(snippet.get_linecount()),\\n 'tree': tree,\\n 'wordwrap': snippet.lexer in LEXER_WORDWRAP and 'True' or 'False',\\n }\\n\\n response = render_to_response(\\n template_name,\\n template_context,\\n RequestContext(request)\\n )\\n\\n if is_raw:\\n response['Content-Type'] = 'text/plain;charset=UTF-8'\\n response['X-Content-Type-Options'] = 'nosniff'\\n return response\\n else:\\n return response\",\n \"def _load(self):\\n entity: dict = self.service.find_one({\\\"_id\\\": self._id})\\n\\n if entity is not None:\\n self.created_at = entity.get(\\\"created_at\\\")\\n self.updated_at = entity.get(\\\"updated_at\\\")\",\n \"def snippet_detail(request, snippet_id):\\n snippet = get_object_or_404(Snippet, pk=snippet_id)\\n return render_to_response('cab/snippet_detail.html',\\n { 'object': snippet,\\n 'num_ratings': snippet.rating_set.count(),\\n 'rating_score': Rating.objects.score_for_snippet(snippet.id) },\\n context_instance=RequestContext(request))\",\n \"def load_item(self, location):\\r\\n assert isinstance(location, Location)\\r\\n json_data = self.module_data.get(location)\\r\\n if json_data is None:\\r\\n module = self.modulestore.get_item(location)\\r\\n if module is not None:\\r\\n # update our own cache after going to the DB to get cache miss\\r\\n self.module_data.update(module.runtime.module_data)\\r\\n return module\\r\\n else:\\r\\n # load the module and apply the inherited metadata\\r\\n try:\\r\\n category = json_data['location']['category']\\r\\n class_ = self.load_block_type(category)\\r\\n\\r\\n\\r\\n definition = json_data.get('definition', {})\\r\\n metadata = json_data.get('metadata', {})\\r\\n for old_name, new_name in getattr(class_, 'metadata_translations', {}).items():\\r\\n if old_name in metadata:\\r\\n metadata[new_name] = metadata[old_name]\\r\\n del metadata[old_name]\\r\\n\\r\\n children = [\\r\\n location.course_key.make_usage_key_from_deprecated_string(childloc)\\r\\n for childloc in definition.get('children', [])\\r\\n ]\\r\\n data = definition.get('data', {})\\r\\n if isinstance(data, basestring):\\r\\n data = {'data': data}\\r\\n mixed_class = self.mixologist.mix(class_)\\r\\n data = self._convert_reference_fields_to_keys(mixed_class, location.course_key, data)\\r\\n metadata = self._convert_reference_fields_to_keys(mixed_class, location.course_key, metadata)\\r\\n kvs = MongoKeyValueStore(\\r\\n data,\\r\\n children,\\r\\n metadata,\\r\\n )\\r\\n\\r\\n field_data = KvsFieldData(kvs)\\r\\n scope_ids = ScopeIds(None, category, location, location)\\r\\n module = self.construct_xblock_from_class(class_, scope_ids, field_data)\\r\\n if self.cached_metadata is not None:\\r\\n # parent container pointers don't differentiate between draft and non-draft\\r\\n # so when we do the lookup, we should do so with a non-draft location\\r\\n non_draft_loc = location.replace(revision=None)\\r\\n\\r\\n # Convert the serialized fields values in self.cached_metadata\\r\\n # to python values\\r\\n metadata_to_inherit = self.cached_metadata.get(non_draft_loc.to_deprecated_string(), {})\\r\\n inherit_metadata(module, metadata_to_inherit)\\r\\n # decache any computed pending field settings\\r\\n module.save()\\r\\n return module\\r\\n except:\\r\\n log.warning(\\\"Failed to load descriptor\\\", exc_info=True)\\r\\n return ErrorDescriptor.from_json(\\r\\n json_data,\\r\\n self,\\r\\n location,\\r\\n error_msg=exc_info_to_str(sys.exc_info())\\r\\n )\",\n \"def load_from_dict(input_dict):\\n return WorkflowViewStepInformation(input_dict)\",\n \"def create(self, validated_data):\\n return Snippet.objects.create(**validated_data)\",\n \"def get(name):\\n #retrieve the snippet from the db - commnet from session of nicole darcy\\n #i added the 'cursor= ' line because it said it was unused code, copied it from def put()\\n# commenting lines below to replace with new code as per class lesson\\n # cursor=connection.cursor()\\n # row = cursor.fetchone()\\n # connection.commit()\\n with connection, connection.cursor() as cursor:\\n cursor.execute(\\\"select message from snippets where keyword=%s\\\", (name,))\\n row = cursor.fetchone()\\n if not row:\\n #No snippet was found with that name.\\n return \\\"404: Snippet not Found\\\"\\n return row[0]\\n \\n # warning for 'unreachable code' so i commented it out...\\n # logging.error(\\\"FIXME: Unimplemented - get({!r})\\\".format(name))\\n # print(\\\"this function is running\\\",get.__name__)\\n # return \\\"\\\"\",\n \"def put(name, snippet):\\n # commenting the 3 lines below in order to try and refactor the put method to use context managers\\n # logging.info(\\\"Storing snippet {!r}: {!r}\\\".format(name, snippet))\\n # cursor = connection.cursor()\\n # command = \\\"insert into snippets values (%s, %s)\\\"\\n with connection, connection.cursor() as cursor:\\n cursor.execute(\\\"store snippets where values=%s\\\", (snippet,))\\n\\n \\n try:\\n command = \\\"insert into snippets values (%s, %s)\\\"\\n cursor.execute(command, (name, snippet))\\n except psycopg2.IntegrityError as e:\\n connection.rollback()\\n command = \\\"update snippets set message=% where keyword=%s\\\"\\n cursor.execute(command, (snippet, name))\\n connection.commit()\\n logging.debug(\\\"Snippet stored successfully.\\\")\\n return name, snippet\",\n \"def snippetDetail(requeset, pk, format = None):\",\n \"def snippet_detail(request, pk):\\n try:\\n snippet = Snippet.objects.get(pk=pk)\\n except Snippet.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = SnippetSerializer(snippet)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = SnippetSerializer(snippet, data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n snippet.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def snippet_detail(request, pk):\\n try:\\n snippet = Snippet.objects.get(pk=pk)\\n except Snippet.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = SnippetSerializer(snippet)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = SnippetSerializer(snippet, data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n snippet.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def load_from_dict(input_dict):\\n return WorkflowStepInformation(input_dict)\",\n \"def on_snippets_loaded(self, snippets):\\n self.snippets = snippets\",\n \"def create(self, validated_data):\\r\\n return Snippet.objects.create(**validated_data)\",\n \"def update(self):\\n if not os.path.exists(self._db_file):\\n return\\n with open(self._db_file, 'r') as fp:\\n self.from_dict(json.load(fp), \\\"JSON\\\")\",\n \"def snippet_detail(request, pk, format=None):\\r\\n try:\\r\\n snippet = Snippet.objects.get(pk=pk)\\r\\n except Snippet.DoesNotExist:\\r\\n return Response(status=status.HTTP_404_NOT_FOUND)\\r\\n\\r\\n if request.method == 'GET':\\r\\n serializer = SnippetSerializer(snippet)\\r\\n return Response(serializer.data)\\r\\n\\r\\n elif request.method == 'PUT':\\r\\n serializer = SnippetSerializer(snippet, data=request.data)\\r\\n if serializer.is_valid():\\r\\n serializer.save()\\r\\n return Response(serializer.data)\\r\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\r\\n\\r\\n elif request.method == 'DELETE':\\r\\n snippet.delete()\\r\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def edit_snippet(request, snippet_id):\\n snippet = get_object_or_404(Snippet,\\n pk=snippet_id,\\n author__pk=request.user.id)\\n if request.method == 'POST':\\n form = forms.EditSnippetForm(request.POST, instance=snippet)\\n if form.is_valid():\\n form.save()\\n return HttpResponseRedirect(snippet.get_absolute_url())\\n else:\\n form = forms.EditSnippetForm(instance=snippet)\\n return render_to_response('cab/edit_snippet_form.html',\\n { 'form': form,\\n 'original': snippet },\\n context_instance=RequestContext(request))\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n restore_to_original_site = dictionary.get('restoreToOriginalSite')\\n site_owner_list = None\\n if dictionary.get('siteOwnerList') != None:\\n site_owner_list = list()\\n for structure in dictionary.get('siteOwnerList'):\\n site_owner_list.append(cohesity_management_sdk.models.site_owner.SiteOwner.from_dictionary(structure))\\n target_document_library_name = dictionary.get('targetDocumentLibraryName')\\n target_document_library_prefix = dictionary.get('targetDocumentLibraryPrefix')\\n target_site = cohesity_management_sdk.models.protection_source.ProtectionSource.from_dictionary(dictionary.get('targetSite')) if dictionary.get('targetSite') else None\\n\\n # Return an object of this model\\n return cls(\\n restore_to_original_site,\\n site_owner_list,\\n target_document_library_name,\\n target_document_library_prefix,\\n target_site\\n)\",\n \"def from_dict(cls, dikt) -> 'Story':\\n return util.deserialize_model(dikt, cls)\",\n \"def lazy_loader(self, entry):\\n lookup = plugin.get('api_bluray', self).lookup\\n\\n try:\\n with Session() as session:\\n title, year = split_title_year(entry['title'])\\n movie = lookup(title=title, year=year, session=session)\\n entry.update_using_map(self.field_map, movie)\\n except LookupError:\\n log_once('Bluray lookup failed for %s' % entry['title'], logger, 'WARNING')\",\n \"def snippet_detail(request, pk):\\n try:\\n snippet = Quickstart.objects.get(pk=pk)\\n except Quickstart.DoesNotExist:\\n return HttpResponse(status=404)\\n\\n if request.method == 'GET':\\n serializer = QuickstartSerializer(snippet)\\n return JsonResponse(serializer.data)\\n\\n elif request.method == 'PUT':\\n data = JSONParser().parse(request)\\n serializer = QuickstartSerializer(snippet, data=data)\\n if serializer.is_valid():\\n serializer.save()\\n return JsonResponse(serializer.data)\\n return JsonResponse(serializer.errors, status=400)\\n\\n elif request.method == 'DELETE':\\n quickstart.delete()\\n return HttpResponse(status=204)\",\n \"def __push_snippets(self, snippet):\\n if not self.__postgre_db.is_in_table(\\\"snippets\\\", \\\"snippet=\\\" + add_quotes(\\n replace_special_characters(snippet))):\\n self.__postgre_db.insert(\\\"snippets\\\", {\\\"snippet\\\": snippet})\",\n \"def save(self, *args, **kwargs):\\n if not self.id:\\n self.created = timezone.now()\\n\\n self.modified = timezone.now()\\n\\n return super(CodeSnippet, self).save(*args, **kwargs)\",\n \"def from_dict(self, source_dict: dict) -> 'NewsItemEntity':\\n if \\\"url\\\" in source_dict:\\n self.url = source_dict[\\\"url\\\"]\\n if \\\"last_check\\\" in source_dict:\\n # While saving to Datastore, a DatetimeWithNanoseconds is returned instead of a Datetime.date\\n self.last_check = source_dict[\\\"last_check\\\"]\\n if \\\"param1\\\" in source_dict:\\n self.param1 = source_dict[\\\"param1\\\"]\\n\\n return self\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n enabled = dictionary.get('enabled')\\n last_updated_timestamp_secs = dictionary.get('lastUpdatedTimestampSecs')\\n pinned_time_secs = dictionary.get('pinnedTimeSecs')\\n\\n # Return an object of this model\\n return cls(\\n enabled,\\n last_updated_timestamp_secs,\\n pinned_time_secs\\n)\",\n \"def loadFromDict(self, d):\\n self._data = d\\n self._doDefaults()\",\n \"def __getitem__(self, key):\\n log.info(\\\"querying post %s, %s:%s\\\" % (self.blog, self.date, key))\\n try:\\n post = DBSession.query(Post).filter_by(blog=self.blog, date=self.date, slug=key).one()\\n # make location aware\\n post.__parent__ = self\\n return post\\n except NoResultFound:\\n raise KeyError\",\n \"def load_from_state_dict(self, state_dict):\\n raise NotImplementedError\",\n \"def __getitem__(self, key):\\n if key not in self.keys():\\n raise ValueError(f'key {key} does not exist in saver')\\n\\n if key in self._dict:\\n return self._dict[key]\\n\\n if self._state == 'open':\\n return self._shelve[key]\\n\\n self.open('r')\\n result = self._shelve[key]\\n self.close()\\n return result\",\n \"def _load(self, load_dict):\\n if self.v_locked:\\n raise pex.ParameterLockedException(\\n \\\"Parameter `%s` is locked!\\\" % self.v_full_name\\n )\\n\\n if \\\"data\\\" in load_dict:\\n self._data = load_dict[\\\"data\\\"][\\\"data\\\"][0]\\n self._default = self._data\\n else:\\n self._logger.warning(\\n \\\"Your parameter `%s` is empty, \\\"\\n \\\"I did not find any data on disk.\\\" % self.v_full_name\\n )\\n\\n if \\\"explored_data\\\" in load_dict:\\n self._explored_range = [\\n x for x in load_dict[\\\"explored_data\\\"][\\\"data\\\"].tolist()\\n ]\\n self._explored = True\\n\\n self._locked = True\",\n \"def parse_snippet(self, ultisnip_file: Path) -> dict:\\n snippets_dictionary = {}\\n with open(ultisnip_file, \\\"r\\\") as f:\\n for line in f:\\n if line.startswith(\\\"snippet\\\"):\\n snippet = {}\\n prefix = line.split()[1].strip()\\n snippet[\\\"prefix\\\"] = prefix\\n if '\\\"' in line:\\n snippet_name = line.split('\\\"')[1].strip()\\n snippet[\\\"description\\\"] = snippet_name\\n body = []\\n line = next(f)\\n while not line.startswith(\\\"endsnippet\\\"):\\n body.append(self._replace_variables(line.strip(\\\"\\\\n\\\")))\\n line = next(f)\\n snippet[\\\"body\\\"] = body\\n snippets_dictionary[prefix] = snippet\\n return snippets_dictionary\",\n \"def upsert(cls, title, version=None):\\n if version is None:\\n # Check for existing page object\\n obj = cls.query.get(app_config_id=c.app.config._id, title=title)\\n if obj is None:\\n obj = cls(title=title, app_config_id=c.app.config._id)\\n Thread(discussion_id=obj.app_config.discussion_id,\\n ref_id=obj.index_id())\\n return obj\\n else:\\n pg = cls.upsert(title)\\n history_cls = cls.__mongometa__.history_class\\n ss = history_cls.query.find({\\n 'artifact_id': pg._id,\\n 'version': int(version)\\n }).one()\\n return ss\",\n \"def _load(self):\\n self.logger.debug(\\\"Loading from persistence\\\")\\n # load whole item from persistence\\n data = self._persistence.load(self.id(), default={})\\n if not data:\\n return\\n\\n try:\\n self.persistence_deserialize(data)\\n except NotImplementedError:\\n # allow backwards compatibility or persisted_values way\\n for persisted_var in self.persisted_values():\\n if persisted_var in data:\\n self.logger.debug(\\\"Loaded value {} for attribute {}\\\".format(\\n data[persisted_var], persisted_var))\\n # Set the loaded value to the attribute on this class\\n setattr(self, persisted_var, data[persisted_var])\\n except:\\n # log exception while loading and let it continue\\n self.logger.exception(\\n \\\"Failed to deserialize block with data: {}\\\".format(data))\",\n \"def get_by_week(user_id: str, year: int, week: int) -> Optional[Snippet]:\\n snippet = Snippet.query.filter_by(\\n user_id=user_id, year=year, week=week\\n )\\n return snippet.first()\",\n \"def _from_deprecated_son(cls, id_dict, run):\\r\\n return cls(id_dict['org'], id_dict['course'], run, id_dict['category'], id_dict['name'], id_dict['revision'])\",\n \"def _load_pretrained_dict(self, dict_name=None,\\n pretrained_file=None, min_count=0):\\n if dict_name is None:\\n for i, _ in enumerate(self.pretrained_dict_names):\\n self._load_pretrained_dict(\\n self.pretrained_dict_names[i],\\n self.pretrained_dict_files[i],\\n self.pretrained_min_count[i])\\n\\n else:\\n if pretrained_file is None or pretrained_file == \\\"\\\":\\n return\\n index = self.dict_names.index(dict_name)\\n dict_map = self.dicts[index]\\n with open(pretrained_file) as fin:\\n for line in fin:\\n data = line.strip().split(' ')\\n if len(data) == 2:\\n continue\\n if data[0] not in dict_map:\\n dict_map[data[0]] = 0\\n dict_map[data[0]] += min_count + 1\",\n \"def read_dict(self, d: dict):\\n self.transaction_id = d.get('transaction_id')\\n\\n self.study_id = d.get('study_id')\\n self.patient_id = d.get('patient_id')\\n self.name = d.get('name')\\n birth_date = d.get('birth_date')\\n self.birth_date = datetime.datetime.strptime(\\n birth_date, \\\"%d/%m/%Y\\\") if birth_date else None\\n self.study_date = d.get('study_date')\\n self.patient_consent_date = self._read_patient_consent_date(d)\\n self.institution = d.get('institution')\\n\\n self.start_date = self._str_to_datetime(d.get('start_date'))\\n self.end_date = self._str_to_datetime(d.get('end_date'))\\n self.creation_date = self._str_to_datetime(d.get('creation_date'))\\n\\n self.version = d.get(\\\"version\\\")\\n self.analysis_type = d.get(\\\"analysis_type\\\")\\n self.qa_score = d.get(\\\"qa_score\\\")\\n self.product_id = d.get('product_id')\\n\\n self.task_state = TaskState[\\n d.get('task_state')] if d.get('task_state') else None\\n self.processing_state = d.get('processing_state')\\n self.task_progress = d.get('task_progress')\\n self.task_skipped = d.get('task_skipped')\\n self.task_cancelled = d.get('task_cancelled')\\n self.archived = d.get('archived')\\n self.error = d.get('error')\\n self.status = d.get('status')\\n self.sequences = d.get('sequences')\\n self.last_message = d.get('last_message')\\n\\n self.data_uploaded = self._str_to_datetime(d.get('data_uploaded'))\\n self.billable = d.get('billable')\\n self.priority = d.get('priority')\\n self.site_id = d.get('site_id', 0)\\n\\n return self\",\n \"def from_dict(cls, d):\\n s = cls()\\n s.update_from_dict(d)\\n return s\",\n \"def _load(self, load_dict):\\n if self.v_locked:\\n raise pex.ParameterLockedException(\\n \\\"Parameter `%s` is locked!\\\" % self.v_full_name\\n )\\n\\n if \\\"data\\\" in load_dict:\\n dump = load_dict[\\\"data\\\"]\\n self._data = pickle.loads(dump)\\n else:\\n self._logger.warning(\\n \\\"Your parameter `%s` is empty, \\\"\\n \\\"I did not find any data on disk.\\\" % self.v_full_name\\n )\\n\\n try:\\n self.v_protocol = load_dict[PickleParameter.PROTOCOL]\\n except KeyError:\\n # For backwards compatibility\\n self.v_protocol = PickleParameter._get_protocol(dump)\\n\\n if \\\"explored_data\\\" in load_dict:\\n explore_table = load_dict[\\\"explored_data\\\"]\\n\\n name_col = explore_table[\\\"idx\\\"]\\n\\n explore_list = []\\n for name_id in name_col:\\n arrayname = self._build_name(name_id)\\n loaded = pickle.loads(load_dict[arrayname])\\n explore_list.append(loaded)\\n\\n self._explored_range = explore_list\\n self._explored = True\\n\\n self._default = self._data\\n self._locked = True\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('Id')\\r\\n name = dictionary.get('Name')\\r\\n last_edited = APIHelper.RFC3339DateTime.from_value(dictionary.get(\\\"LastEdited\\\")).datetime if dictionary.get(\\\"LastEdited\\\") else None\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n name,\\r\\n last_edited,\\r\\n dictionary)\",\n \"def get_snippet(self, title=None):\\n for snippet in self.snippets:\\n if snippet[\\\"title\\\"] == title:\\n return snippet\\n return None\",\n \"def _load_definition(self):\\r\\n if isinstance(self._definition, DefinitionLazyLoader):\\r\\n persisted_definition = self._definition.fetch()\\r\\n if persisted_definition is not None:\\r\\n fields = self._definition.field_converter(persisted_definition.get('fields'))\\r\\n self._fields.update(fields)\\r\\n # do we want to cache any of the edit_info?\\r\\n self._definition = None # already loaded\\r\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('Name')\\r\\n cover_page_setting = dictionary.get('CoverPageSetting')\\r\\n add_list_of_signatures_on_last_page_of_existing_pdf = dictionary.get('AddListOfSignaturesOnLastPageOfExistingPDF')\\r\\n cover_page_html = dictionary.get('CoverPageHtml')\\r\\n details_page_html = idfy_rest_client.models.details_page_html.DetailsPageHtml.from_dictionary(dictionary.get('DetailsPageHtml')) if dictionary.get('DetailsPageHtml') else None\\r\\n verified_template = idfy_rest_client.models.verified_template.VerifiedTemplate.from_dictionary(dictionary.get('VerifiedTemplate')) if dictionary.get('VerifiedTemplate') else None\\r\\n labels = idfy_rest_client.models.labels.Labels.from_dictionary(dictionary.get('Labels')) if dictionary.get('Labels') else None\\r\\n include_logo = dictionary.get('IncludeLogo')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n cover_page_setting,\\r\\n add_list_of_signatures_on_last_page_of_existing_pdf,\\r\\n cover_page_html,\\r\\n details_page_html,\\r\\n verified_template,\\r\\n labels,\\r\\n include_logo,\\r\\n dictionary)\",\n \"def get_snippet(res_type, snippet_name):\\n\\treturn get_settings_resource(res_type, snippet_name, 'snippets');\",\n \"def create_snippet(self, doc, spdx_id):\\n self.reset_snippet()\\n spdx_id = spdx_id.split('#')[-1]\\n if validations.validate_snippet_spdx_id(spdx_id):\\n doc.add_snippet(snippet.Snippet(spdx_id=spdx_id))\\n self.snippet_spdx_id_set = True\\n return True\\n else:\\n raise SPDXValueError('Snippet::SnippetSPDXID')\",\n \"def _load(self, load_dict):\\n self._data_ = load_dict\",\n \"def add_snippet(request):\\n original_id = request.GET.get('oid', None)\\n \\n if request.method == 'POST':\\n form = forms.AddSnippetForm(request.POST)\\n if form.is_valid():\\n new_snippet = form.save(commit=False)\\n new_snippet.author = request.user\\n if original_id:\\n new_snippet.original_id = original_id\\n new_snippet.save()\\n return HttpResponseRedirect(new_snippet.get_absolute_url())\\n else:\\n form = forms.AddSnippetForm()\\n return render_to_response('cab/add_snippet_form.html',\\n { 'form': form },\\n context_instance=RequestContext(request))\",\n \"def update_from_json(cls, course_key, jsondict, user):\\r\\n module_store = modulestore('direct')\\r\\n descriptor = module_store.get_course(course_key)\\r\\n\\r\\n dirty = False\\r\\n\\r\\n # In the descriptor's setter, the date is converted to JSON using Date's to_json method.\\r\\n # Calling to_json on something that is already JSON doesn't work. Since reaching directly\\r\\n # into the model is nasty, convert the JSON Date to a Python date, which is what the\\r\\n # setter expects as input.\\r\\n date = Date()\\r\\n\\r\\n if 'start_date' in jsondict:\\r\\n converted = date.from_json(jsondict['start_date'])\\r\\n else:\\r\\n converted = None\\r\\n if converted != descriptor.start:\\r\\n dirty = True\\r\\n descriptor.start = converted\\r\\n\\r\\n if 'end_date' in jsondict:\\r\\n converted = date.from_json(jsondict['end_date'])\\r\\n else:\\r\\n converted = None\\r\\n\\r\\n if converted != descriptor.end:\\r\\n dirty = True\\r\\n descriptor.end = converted\\r\\n\\r\\n if 'enrollment_start' in jsondict:\\r\\n converted = date.from_json(jsondict['enrollment_start'])\\r\\n else:\\r\\n converted = None\\r\\n\\r\\n if converted != descriptor.enrollment_start:\\r\\n dirty = True\\r\\n descriptor.enrollment_start = converted\\r\\n\\r\\n if 'enrollment_end' in jsondict:\\r\\n converted = date.from_json(jsondict['enrollment_end'])\\r\\n else:\\r\\n converted = None\\r\\n\\r\\n if converted != descriptor.enrollment_end:\\r\\n dirty = True\\r\\n descriptor.enrollment_end = converted\\r\\n\\r\\n if 'course_image_name' in jsondict and jsondict['course_image_name'] != descriptor.course_image:\\r\\n descriptor.course_image = jsondict['course_image_name']\\r\\n dirty = True\\r\\n\\r\\n if dirty:\\r\\n module_store.update_item(descriptor, user.id)\\r\\n\\r\\n # NOTE: below auto writes to the db w/o verifying that any of the fields actually changed\\r\\n # to make faster, could compare against db or could have client send over a list of which fields changed.\\r\\n for about_type in ['syllabus', 'overview', 'effort', 'short_description']:\\r\\n cls.update_about_item(course_key, about_type, jsondict[about_type], descriptor, user)\\r\\n\\r\\n recomposed_video_tag = CourseDetails.recompose_video_tag(jsondict['intro_video'])\\r\\n cls.update_about_item(course_key, 'video', recomposed_video_tag, descriptor, user)\\r\\n\\r\\n # Could just return jsondict w/o doing any db reads, but I put the reads in as a means to confirm\\r\\n # it persisted correctly\\r\\n return CourseDetails.fetch(course_key)\",\n \"def _load_dict(self, dict_name=None):\\n if dict_name is None:\\n for name in self.dict_names:\\n self._load_dict(name)\\n else:\\n dict_idx = self.dict_names.index(dict_name)\\n if not os.path.exists(self.dict_files[dict_idx]):\\n self.logger.warn(\\\"Not exists %s for %s\\\" % (\\n self.dict_files[dict_idx], dict_name))\\n else:\\n dict_map = self.dicts[dict_idx]\\n id_to_vocab_dict_map = self.id_to_vocab_dict_list[dict_idx]\\n if dict_name != self.DOC_LABEL:\\n dict_map[self.VOCAB_PADDING] = 0\\n dict_map[self.VOCAB_UNKNOWN] = 1\\n dict_map[self.VOCAB_PADDING_LEARNABLE] = 2\\n id_to_vocab_dict_map[0] = self.VOCAB_PADDING\\n id_to_vocab_dict_map[1] = self.VOCAB_UNKNOWN\\n id_to_vocab_dict_map[2] = self.VOCAB_PADDING_LEARNABLE\\n\\n for line in open(self.dict_files[dict_idx], \\\"r\\\"):\\n vocab = line.strip(\\\"\\\\n\\\").split(\\\"\\\\t\\\")\\n dict_idx = len(dict_map)\\n dict_map[vocab[0]] = dict_idx\\n id_to_vocab_dict_map[dict_idx] = vocab[0]\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n insurance_policy_type_velue = dictionary.get('insurancePolicyTypeVelue')\\r\\n fire_insurance_policy_extend_view = easybimehlanding.models.fire_insurance_policy_extend_view.FireInsurancePolicyExtendView.from_dictionary(dictionary.get('fireInsurancePolicyExtendView')) if dictionary.get('fireInsurancePolicyExtendView') else None\\r\\n fire_insurance_policy_filter = easybimehlanding.models.fire_insurance_policy_filter.FireInsurancePolicyFilter.from_dictionary(dictionary.get('fireInsurancePolicyFilter')) if dictionary.get('fireInsurancePolicyFilter') else None\\r\\n id = dictionary.get('id')\\r\\n selected_insurance_policy_has_been_changed = dictionary.get('selectedInsurancePolicyHasBeenChanged')\\r\\n is_paymented = dictionary.get('isPaymented')\\r\\n has_conflict_document = dictionary.get('hasConflictDocument')\\r\\n is_insurance_centre_admin = dictionary.get('isInsuranceCentreAdmin')\\r\\n insurance_policy_payment_documents = dictionary.get('insurancePolicyPaymentDocuments')\\r\\n payable = dictionary.get('payable')\\r\\n paymented = dictionary.get('paymented')\\r\\n conflict = dictionary.get('conflict')\\r\\n initial_price = dictionary.get('initialPrice')\\r\\n final_price = dictionary.get('finalPrice')\\r\\n insurance_company_name = dictionary.get('insuranceCompanyName')\\r\\n insurance_centre_name = dictionary.get('insuranceCentreName')\\r\\n insurance_policy_conflict = dictionary.get('insurancePolicyConflict')\\r\\n insurance_policy_condition = dictionary.get('insurancePolicyCondition')\\r\\n person = dictionary.get('person')\\r\\n insurance_policy = dictionary.get('insurancePolicy')\\r\\n shopping_card = dictionary.get('shoppingCard')\\r\\n shopping_card_postal_packet = dictionary.get('shoppingCardPostalPacket')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(insurance_policy_type_velue,\\r\\n fire_insurance_policy_extend_view,\\r\\n fire_insurance_policy_filter,\\r\\n id,\\r\\n selected_insurance_policy_has_been_changed,\\r\\n is_paymented,\\r\\n has_conflict_document,\\r\\n is_insurance_centre_admin,\\r\\n insurance_policy_payment_documents,\\r\\n payable,\\r\\n paymented,\\r\\n conflict,\\r\\n initial_price,\\r\\n final_price,\\r\\n insurance_company_name,\\r\\n insurance_centre_name,\\r\\n insurance_policy_conflict,\\r\\n insurance_policy_condition,\\r\\n person,\\r\\n insurance_policy,\\r\\n shopping_card,\\r\\n shopping_card_postal_packet)\",\n \"def upsert_page(self, document: dict) -> Optional[Dict[str, str]]:\\n existing_page = self.article_coll.find_one({\\\"page.url\\\": document[\\\"url\\\"]})\\n if (\\n existing_page\\n and document[\\\"orig\\\"][\\\"timestamp\\\"]\\n > existing_page[\\\"page\\\"][\\\"orig\\\"][\\\"timestamp\\\"]\\n ):\\n self.article_coll.update_one(\\n {\\\"page.url\\\": document[\\\"url\\\"]}, {\\\"$set\\\": {\\\"page\\\": document}}, upsert=True\\n )\\n document[\\\"status\\\"] = Status.UPDATED\\n elif not existing_page:\\n self.article_coll.insert_one({\\\"page\\\": document})\\n document[\\\"status\\\"] = Status.INSERTED\\n else:\\n document[\\\"status\\\"] = Status.IGNORED\\n return document\",\n \"def load_from_dict(input_dict):\\n view_steps = [WorkflowViewStepInformation.load_from_dict(data) \\n for data in input_dict[WorkflowInformation.KEY_VIEW_STEPS]]\\n wf_steps = [WorkflowStepInformation.load_from_dict(data)\\n for data in input_dict[WorkflowInformation.KEY_WF_STEPS]]\\n input_dict[WorkflowInformation.KEY_VIEW_STEPS] = view_steps\\n input_dict[WorkflowInformation.KEY_WF_STEPS] = wf_steps\\n return WorkflowInformation(input_dict)\",\n \"def load_dictionary(dictionary_file):\\n global dictionary\\n logging.info('loading saved abstracts from {0}'.format(dictionary_file))\\n with open(dictionary_file, 'r') as f:\\n for line in f:\\n j = json.loads(line)\\n dictionary.update(j)\",\n \"def update(self, new_content: dict):\\n self.__init__(new_content, self.__previous_hash)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n lowest_new_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestNewPrice')) if dictionary.get('LowestNewPrice') else None\\n lowest_used_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestUsedPrice')) if dictionary.get('LowestUsedPrice') else None\\n lowest_collectible_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestCollectiblePrice')) if dictionary.get('LowestCollectiblePrice') else None\\n lowest_refurbished_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestRefurbishedPrice')) if dictionary.get('LowestRefurbishedPrice') else None\\n total_new = dictionary.get('TotalNew')\\n total_used = dictionary.get('TotalUsed')\\n total_collectible = dictionary.get('TotalCollectible')\\n total_refurbished = dictionary.get('TotalRefurbished')\\n\\n # Return an object of this model\\n return cls(lowest_new_price,\\n lowest_used_price,\\n lowest_collectible_price,\\n lowest_refurbished_price,\\n total_new,\\n total_used,\\n total_collectible,\\n total_refurbished)\",\n \"def load_knowledge(net, filepath):\\n\\treloaded = loadz(filepath)\\n\\tknowledge = [(name, reloaded[name]) for name in sorted(reloaded.keys())]\\n\\tset_knowledge(net, knowledge)\",\n \"def reload(self):\\n try:\\n with open(self.__file_path, 'r') as f:\\n for key, value in json.load(f).items():\\n self.__objects[key] = eval(key.split('.')[0])(**value)\\n except FileNotFoundError:\\n pass\",\n \"def _reload(self, key=None, **kwargs):\\n data = self.query(self.key)\\n self._loadData(data)\\n return self\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n has_archival_copy = dictionary.get('hasArchivalCopy')\\n has_local_copy = dictionary.get('hasLocalCopy')\\n has_remote_copy = dictionary.get('hasRemoteCopy')\\n modified_time_usecs = dictionary.get('modifiedTimeUsecs')\\n replica_info_list = None\\n if dictionary.get('replicaInfoList') != None:\\n replica_info_list = list()\\n for structure in dictionary.get('replicaInfoList'):\\n replica_info_list.append(cohesity_management_sdk.models.replica_info.ReplicaInfo.from_dictionary(structure))\\n size_bytes = dictionary.get('sizeBytes')\\n snapshot = cohesity_management_sdk.models.snapshot_attempt.SnapshotAttempt.from_dictionary(dictionary.get('snapshot')) if dictionary.get('snapshot') else None\\n\\n # Return an object of this model\\n return cls(\\n has_archival_copy,\\n has_local_copy,\\n has_remote_copy,\\n modified_time_usecs,\\n replica_info_list,\\n size_bytes,\\n snapshot\\n)\",\n \"def reload(self):\\n try:\\n with open(self.__file_path, 'r') as f:\\n dicts = json.load(f)\\n for key, value in dicts.items():\\n obj1 = eval(value['__class__'])(**value)\\n self.__objects[key] = obj1\\n except FileNotFoundError:\\n pass\",\n \"def load_dict(self, dct):\\n pass\",\n \"async def load_from_store(self):\\n start_time = int(time.time()) - self.keep_interval\\n for lid, t, d in await self.store.get_recent_partials(start_time):\\n self.cache[lid].add(t, d, remove=False)\\n self.cache.all.add(t, d, remove=False)\\n await self.store.scrub_pplns(start_time)\",\n \"def from_dict(source_dict: Dict[str, Any]) -> 'Statement':\\n # value needs to be passed as a positional argument. It corresponds to the args field.\\n try:\\n value = source_dict[Statement._args_field]\\n except KeyError as ex:\\n raise KeyError(f\\\"Statement dictionary is missing {ex} field\\\")\\n\\n # Pass the rest at kwargs (minus args)\\n kwargs = source_dict.copy()\\n del kwargs[Statement._args_field]\\n\\n return Statement(value, **kwargs)\",\n \"def load_from_dict(self, dict_):\\n for key, value in six.iteritems(dict_):\\n setattr(self, util.as_attr(key), value)\\n self._check_against_schema()\",\n \"def load_article(paper_id):\\n s3 = boto3.client('s3')\\n key = 'json/%s.json' % paper_id\\n LOGGER.info('bucket=%s, key=%s', ARTICLE_BUCKET_NAME, key)\\n obj = s3.get_object(\\n Bucket=ARTICLE_BUCKET_NAME,\\n Key=key)\\n body = obj['Body']\\n article = json.loads(body.read())\\n body.close()\\n return article\",\n \"def _load_dictionary(dict_name: str, file: h5py.File) -> Dict:\\n d = {}\\n g = file[dict_name]\\n for k in g:\\n if \\\"finish_time\\\" in k or \\\"start_time\\\" in k:\\n # need to decode byte-string into datetime object\\n try:\\n date_time_string = g[k][()].decode('UTF-8') # convert bye string to string\\n except AttributeError:\\n # it is already a unicode string\\n date_time_string = g[k][()]\\n d[k] = datetime.strptime(date_time_string, \\\"%m/%d/%Y %I:%M:%S %p\\\")\\n else:\\n d[k] = g[k][()]\\n return d\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n day = dictionary.get('day')\\n end_time = cohesity_management_sdk.models.time.Time.from_dictionary(dictionary.get('endTime')) if dictionary.get('endTime') else None\\n start_time = cohesity_management_sdk.models.time.Time.from_dictionary(dictionary.get('startTime')) if dictionary.get('startTime') else None\\n\\n # Return an object of this model\\n return cls(\\n day,\\n end_time,\\n start_time\\n)\",\n \"def from_dict(cls, d):\\n return loadd(d, cls)\",\n \"def load_from_proposal(self, proposal):\\n assert isinstance(proposal, proposal_models.AbstractProposal)\\n LOG.debug(\\\"Importing proposal data into session\\\")\\n for field in proposal._meta.fields:\\n if field.primary_key:\\n continue\\n setattr(self, field.name, getattr(proposal, field.name))\\n self.proposal = proposal\\n self.save()\\n self.tags.add(*[t.name for t in proposal.tags.all()])\\n self.additional_speakers = proposal.additional_speakers.all()\\n self.available_timeslots = proposal.available_timeslots.all()\\n\\n # Also check if there was an update to that proposal and update the\\n # provided values if necessary.\\n pv = review_models.ProposalVersion.objects.get_latest_for(proposal)\\n if pv:\\n LOG.debug(\\\"Applying proposal version data\\\")\\n for field in proposal._meta.fields:\\n if field.primary_key:\\n continue\\n setattr(self, field.name, getattr(pv, field.name))\\n self.tags.add(*[t.name for t in pv.tags.all()])\\n self.additional_speakers = pv.additional_speakers.all()\\n self.save()\",\n \"def upsert_sample(db: DatabaseSession,\\n identifier: str,\\n collection_identifier: Optional[str],\\n collection_date: Optional[str],\\n additional_details: dict) -> Tuple[Any, str]:\\n data = {\\n \\\"identifier\\\": identifier,\\n \\\"collection_identifier\\\": collection_identifier,\\n \\\"collection_date\\\": collection_date,\\n \\\"additional_details\\\": Json(additional_details),\\n }\\n\\n # Look for existing sample(s)\\n with db.cursor() as cursor:\\n cursor.execute(\\\"\\\"\\\"\\n select sample_id as id, identifier, collection_identifier, encounter_id\\n from warehouse.sample\\n where identifier = %(identifier)s\\n or collection_identifier = %(collection_identifier)s\\n for update\\n \\\"\\\"\\\", data)\\n\\n samples = list(cursor)\\n\\n # Nothing found → create\\n if not samples:\\n LOG.info(\\\"Creating new sample\\\")\\n status = 'created'\\n sample = db.fetch_row(\\\"\\\"\\\"\\n insert into warehouse.sample (identifier, collection_identifier, collected, details)\\n values (%(identifier)s,\\n %(collection_identifier)s,\\n date_or_null(%(collection_date)s),\\n %(additional_details)s)\\n returning sample_id as id, identifier, collection_identifier, encounter_id\\n \\\"\\\"\\\", data)\\n\\n # One found → update\\n elif len(samples) == 1:\\n status = 'updated'\\n sample = samples[0]\\n\\n LOG.info(f\\\"Updating existing sample {sample.id}\\\")\\n sample = db.fetch_row(\\\"\\\"\\\"\\n update warehouse.sample\\n set identifier = %(identifier)s,\\n collection_identifier = %(collection_identifier)s,\\n collected = date_or_null(%(collection_date)s),\\n details = coalesce(details, '{}') || %(additional_details)s\\n\\n where sample_id = %(sample_id)s\\n\\n returning sample_id as id, identifier, collection_identifier, encounter_id\\n \\\"\\\"\\\",\\n { **data, \\\"sample_id\\\": sample.id })\\n\\n assert sample.id, \\\"Update affected no rows!\\\"\\n\\n # More than one found → error\\n else:\\n raise Exception(f\\\"More than one sample matching sample and/or collection barcodes: {samples}\\\")\\n\\n return sample, status\",\n \"def pysnippet(self, code, lineno=1, colno=None, extralines=3, line_numbers=True):\\n with self._lock:\\n if not code:\\n return\\n if colno is not None:\\n highlight_columns = (colno - 1, colno)\\n else:\\n highlight_columns = None\\n _lineno = max(0, lineno - extralines)\\n\\n highlighter = PythonHighlighter()\\n\\n self.snippet(\\n code,\\n (_lineno, _lineno + extralines * 2 + 1),\\n highlight_line=lineno,\\n highlight_columns=highlight_columns,\\n line_numbers=True,\\n highlighter=highlighter,\\n )\\n return self\",\n \"def load_(self):\\n path = os.path.join(os.path.dirname(self.arch_handler.dicomdir_path), self.SAVE_NAME)\\n if not os.path.isfile(path):\\n print(\\\"No history to load\\\")\\n return\\n with open(path, \\\"r\\\") as infile:\\n data = json.load(infile)\\n self.load(data['history'])\\n self._edited = False\",\n \"def update_dict(self, newdata: dict) -> 'Language':\\n return Language.make(\\n language=newdata.get('language', self.language),\\n extlangs=newdata.get('extlangs', self.extlangs),\\n script=newdata.get('script', self.script),\\n territory=newdata.get('territory', self.territory),\\n variants=newdata.get('variants', self.variants),\\n extensions=newdata.get('extensions', self.extensions),\\n private=newdata.get('private', self.private)\\n )\",\n \"def loads(cls: Type[_T], contents: Dict[str, Any]) -> _T:\\n return common_loads(cls, contents)\",\n \"def from_dict(d):\\n return eptStaleEvent(**d)\",\n \"def _load_snippet(filename) -> str:\\n fullpath = f'{dirname(__file__)}/js/{filename}'\\n file = open(fullpath, 'r')\\n script = file.read()\\n file.close()\\n return script\",\n \"def as_inator(dct):\\n keyset = {'ident', 'name', 'location', 'description', 'condition', 'added'}\\n if set(dct.keys()) == keyset:\\n try:\\n new_dct = dct.copy()\\n new_dct['added'] = load_time(new_dct['added'])\\n new_dct['condition'] = Condition(int(new_dct['condition']))\\n return new_dct\\n except ValueError:\\n return dct\\n else:\\n return dct\",\n \"def reload(self):\\n\\n if not path.isfile(self.definition_filename):\\n msg = \\\"Program %s does not exist (no definition file %s)\\\"\\n raise errors.ProgramNotFound(msg % (self.name, self.definition_filename))\\n\\n with open(self.definition_filename) as df:\\n self.raw_data = yaml.safe_load(df)\\n\\n self.mk_data()\",\n \"def from_dict(cls, dikt) -> 'PinCodeSummaryResultsObject':\\n return util.deserialize_model(dikt, cls)\",\n \"def reload(self):\\n\\n dict_of_dicts = {}\\n classes = {\\n \\\"BaseModel\\\": BaseModel,\\n \\\"User\\\": User,\\n \\\"Amenity\\\": Amenity,\\n \\\"City\\\": City,\\n \\\"Place\\\": Place,\\n \\\"Review\\\": Review,\\n \\\"State\\\": State}\\n\\n try:\\n temp_dict = {}\\n with open(self.__file_path, \\\"r\\\") as r:\\n dict_of_dicts = json.load(r)\\n for k, v in dict_of_dicts.items():\\n if v['__class__'] in classes:\\n temp_dict[k] = classes[v['__class__']](**v)\\n self.__objects = temp_dict\\n except Exception:\\n pass\",\n \"def reload(self):\\n try:\\n with open(self.__file_path, mode=\\\"r\\\", encoding='UTF-8') as f:\\n readit = json.load(f)\\n for v in readit.values():\\n from ..base_model import BaseModel\\n from ..user import User\\n from ..state import State\\n from ..city import City\\n from ..amenity import Amenity\\n from ..place import Place\\n from ..review import Review\\n\\n a = eval(\\\"{}(**v)\\\".format(v[\\\"__class__\\\"]))\\n self.new(a)\\n\\n except FileNotFoundError:\\n \\\"\\\"\\\"\\n No file has been found so pass\\n \\\"\\\"\\\"\\n pass\",\n \"def __getitem__(self, key):\\n entry_dir = self.cache_key_dir(key)\\n\\n # Try obtain the entry from the registry first\\n # It's the primary source of truth\\n try:\\n entry = self.registry[key]\\n except KeyError:\\n # Look for an entry file as the secondary source of truth\\n entry_file = entry_dir / \\\"entry.yaml\\\"\\n\\n # Nothing, raise a KeyError\\n if not entry_file.exists():\\n raise KeyError(key)\\n\\n with open(entry_file, \\\"r\\\") as f:\\n entry = yaml.safe_load(f)\\n else:\\n self.__setitem__(key, entry)\\n\\n\\n entry['size'] = 0\\n entry['dir'] = entry_dir\\n\\n return entry\",\n \"def load_dictionary(self, dictionary, value):\\n \\n file = open(dictionary, \\\"r\\\")\\n if file == None:\\n sys.exit(\\\"Opening dictionary file fialed\\\")\\n for line in file.readlines():\\n if not line.startswith(\\\";\\\") or line.startswith(\\\" \\\"):\\n self.dic[line.rstrip(\\\"\\\\n\\\")] = value\\n file.close()\",\n \"def augment_with_pretrained(dictionary, ext_emb_path, words):\\n print('Loading pretrained embeddings from %s...' % ext_emb_path)\\n assert os.path.isfile(ext_emb_path)\\n\\n # Load pretrained embeddings from file\\n pretrained = set([\\n line.rstrip().split()[0].strip()\\n for line in codecs.open(ext_emb_path, 'r', 'utf-8')\\n if len(ext_emb_path) > 0\\n ])\\n\\n # We either add every word in the pretrained file,\\n # or only words given in the `words` list to which\\n # we can assign a pretrained embedding\\n if words is None:\\n for word in pretrained:\\n if word not in dictionary:\\n dictionary[word] = 0\\n else:\\n for word in words:\\n if any(x in pretrained for x in [\\n word,\\n word.lower(),\\n re.sub('\\\\d', '0', word.lower())\\n ]) and word not in dictionary:\\n dictionary[word] = 0\\n\\n word_to_id, id_to_word = create_mapping(dictionary)\\n return dictionary, word_to_id, id_to_word\",\n \"def load(self, which):\\n\\t\\tpath = os.path.join(self.storagedir, which)\\n\\t\\tprint(\\\"Loading from\\\", path)\\n\\t\\twith open(path, \\\"rb\\\") as handle:\\n\\t\\t\\tsetattr(self, which, _pickle.load(handle))\",\n \"def lazy_load(map_obj, key, loader, pather, cfg):\\n if key not in map_obj:\\n map_obj[key] = loader(pather(cfg))\\n return map_obj[key]\",\n \"def load(self):\\n result = bolt.PickleDict.load(self)\\n if not result and self.oldPath.exists():\\n ins = None\\n try:\\n ins = self.oldPath.open('r')\\n self.data.update(compat.uncpickle(ins))\\n ins.close()\\n result = 1\\n except EOFError:\\n if ins: ins.close()\\n #--Done\\n return result\",\n \"def load_policy(self, source, templatefile, key):\\n self._logger.info(\\n f\\\"Loading policy model from {source} and templates from {templatefile} to {key}\\\"\\n )\\n model = self._load_model(source)\\n templates = pd.read_hdf(templatefile, \\\"table\\\")\\n self._policies[key] = {\\\"model\\\": model, \\\"templates\\\": templates}\",\n \"def snippet(self) -> global___Snippet:\",\n \"def load(cls, path):\\n data = cls()\\n data.set_params(pk.load(path))\\n return data\",\n \"def reload(self):\\n from models.base_model import BaseModel\\n from models.user import User\\n from models.amenity import Amenity\\n from models.city import City\\n from models.place import Place\\n from models.review import Review\\n from models.state import State\\n dict_reload = {}\\n try:\\n with open(FileStorage.__file_path) as file:\\n dict_reload = json.load(file)\\n for key, value in dict_reload.items():\\n obj = value[\\\"__class__\\\"]\\n self.__objects[key] = locals()[obj](**value)\\n except:\\n pass\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n identifikasjon_field = idfy_rest_client.models.identifikasjon.Identifikasjon.from_dictionary(dictionary.get('identifikasjonField')) if dictionary.get('identifikasjonField') else None\\r\\n navn_adresse_field = idfy_rest_client.models.navn_adresse.NavnAdresse.from_dictionary(dictionary.get('navnAdresseField')) if dictionary.get('navnAdresseField') else None\\r\\n rating_field = idfy_rest_client.models.rating.Rating.from_dictionary(dictionary.get('ratingField')) if dictionary.get('ratingField') else None\\r\\n hist_rating_field = None\\r\\n if dictionary.get('histRatingField') != None:\\r\\n hist_rating_field = list()\\r\\n for structure in dictionary.get('histRatingField'):\\r\\n hist_rating_field.append(idfy_rest_client.models.historisk_rating.HistoriskRating.from_dictionary(structure))\\r\\n grunnfakta_field = idfy_rest_client.models.grunnfakta.Grunnfakta.from_dictionary(dictionary.get('grunnfaktaField')) if dictionary.get('grunnfaktaField') else None\\r\\n juridisk_field = None\\r\\n if dictionary.get('juridiskField') != None:\\r\\n juridisk_field = list()\\r\\n for structure in dictionary.get('juridiskField'):\\r\\n juridisk_field.append(idfy_rest_client.models.juridisk.Juridisk.from_dictionary(structure))\\r\\n verv_field = None\\r\\n if dictionary.get('vervField') != None:\\r\\n verv_field = list()\\r\\n for structure in dictionary.get('vervField'):\\r\\n verv_field.append(idfy_rest_client.models.verv.Verv.from_dictionary(structure))\\r\\n aksjonar_field = None\\r\\n if dictionary.get('aksjonarField') != None:\\r\\n aksjonar_field = list()\\r\\n for structure in dictionary.get('aksjonarField'):\\r\\n aksjonar_field.append(idfy_rest_client.models.aksjonar.Aksjonar.from_dictionary(structure))\\r\\n datterselskap_field = None\\r\\n if dictionary.get('datterselskapField') != None:\\r\\n datterselskap_field = list()\\r\\n for structure in dictionary.get('datterselskapField'):\\r\\n datterselskap_field.append(idfy_rest_client.models.datterselskap.Datterselskap.from_dictionary(structure))\\r\\n okonomi_enk_field = None\\r\\n if dictionary.get('okonomiEnkField') != None:\\r\\n okonomi_enk_field = list()\\r\\n for structure in dictionary.get('okonomiEnkField'):\\r\\n okonomi_enk_field.append(idfy_rest_client.models.okonomi_enk.OkonomiEnk.from_dictionary(structure))\\r\\n nokkeltall_foretak_field = None\\r\\n if dictionary.get('nokkeltallForetakField') != None:\\r\\n nokkeltall_foretak_field = list()\\r\\n for structure in dictionary.get('nokkeltallForetakField'):\\r\\n nokkeltall_foretak_field.append(idfy_rest_client.models.nokkeltall_foretak.NokkeltallForetak.from_dictionary(structure))\\r\\n nokkeltall_bransje_field = None\\r\\n if dictionary.get('nokkeltallBransjeField') != None:\\r\\n nokkeltall_bransje_field = list()\\r\\n for structure in dictionary.get('nokkeltallBransjeField'):\\r\\n nokkeltall_bransje_field.append(idfy_rest_client.models.nokkeltall_bransje.NokkeltallBransje.from_dictionary(structure))\\r\\n nokkeltall_konsern_field = None\\r\\n if dictionary.get('nokkeltallKonsernField') != None:\\r\\n nokkeltall_konsern_field = list()\\r\\n for structure in dictionary.get('nokkeltallKonsernField'):\\r\\n nokkeltall_konsern_field.append(idfy_rest_client.models.nokkeltall_konsern.NokkeltallKonsern.from_dictionary(structure))\\r\\n beta_sammendrag_field = idfy_rest_client.models.beta_sammendrag.BetaSammendrag.from_dictionary(dictionary.get('betaSammendragField')) if dictionary.get('betaSammendragField') else None\\r\\n beta_detaljer_field = None\\r\\n if dictionary.get('betaDetaljerField') != None:\\r\\n beta_detaljer_field = list()\\r\\n for structure in dictionary.get('betaDetaljerField'):\\r\\n beta_detaljer_field.append(idfy_rest_client.models.beta_detaljer.BetaDetaljer.from_dictionary(structure))\\r\\n losore_field = None\\r\\n if dictionary.get('losoreField') != None:\\r\\n losore_field = list()\\r\\n for structure in dictionary.get('losoreField'):\\r\\n losore_field.append(idfy_rest_client.models.losore.Losore.from_dictionary(structure))\\r\\n eiendom_norge_field = idfy_rest_client.models.eiendom_norge.EiendomNorge.from_dictionary(dictionary.get('eiendomNorgeField')) if dictionary.get('eiendomNorgeField') else None\\r\\n konsern_link_field = None\\r\\n if dictionary.get('konsernLinkField') != None:\\r\\n konsern_link_field = list()\\r\\n for structure in dictionary.get('konsernLinkField'):\\r\\n konsern_link_field.append(idfy_rest_client.models.konsern_link.KonsernLink.from_dictionary(structure))\\r\\n scoring_field = idfy_rest_client.models.scoring.Scoring.from_dictionary(dictionary.get('scoringField')) if dictionary.get('scoringField') else None\\r\\n okonomi_sammendrag_foretak_field = None\\r\\n if dictionary.get('okonomiSammendragForetakField') != None:\\r\\n okonomi_sammendrag_foretak_field = list()\\r\\n for structure in dictionary.get('okonomiSammendragForetakField'):\\r\\n okonomi_sammendrag_foretak_field.append(idfy_rest_client.models.okonomi_sammendrag_foretak.OkonomiSammendragForetak.from_dictionary(structure))\\r\\n okonomi_sammendrag_konsern_field = None\\r\\n if dictionary.get('okonomiSammendragKonsernField') != None:\\r\\n okonomi_sammendrag_konsern_field = list()\\r\\n for structure in dictionary.get('okonomiSammendragKonsernField'):\\r\\n okonomi_sammendrag_konsern_field.append(idfy_rest_client.models.okonomi_sammendrag_konsern.OkonomiSammendragKonsern.from_dictionary(structure))\\r\\n okonomi_detaljer_foretak_field = None\\r\\n if dictionary.get('okonomiDetaljerForetakField') != None:\\r\\n okonomi_detaljer_foretak_field = list()\\r\\n for structure in dictionary.get('okonomiDetaljerForetakField'):\\r\\n okonomi_detaljer_foretak_field.append(idfy_rest_client.models.okonomi_detaljer_foretak.OkonomiDetaljerForetak.from_dictionary(structure))\\r\\n okonomi_detaljer_konsern_field = None\\r\\n if dictionary.get('okonomiDetaljerKonsernField') != None:\\r\\n okonomi_detaljer_konsern_field = list()\\r\\n for structure in dictionary.get('okonomiDetaljerKonsernField'):\\r\\n okonomi_detaljer_konsern_field.append(idfy_rest_client.models.okonomi_detaljer_konsern.OkonomiDetaljerKonsern.from_dictionary(structure))\\r\\n eiendeler_foretak_field = None\\r\\n if dictionary.get('eiendelerForetakField') != None:\\r\\n eiendeler_foretak_field = list()\\r\\n for structure in dictionary.get('eiendelerForetakField'):\\r\\n eiendeler_foretak_field.append(idfy_rest_client.models.eiendeler_foretak.EiendelerForetak.from_dictionary(structure))\\r\\n eiendeler_konsern_field = None\\r\\n if dictionary.get('eiendelerKonsernField') != None:\\r\\n eiendeler_konsern_field = list()\\r\\n for structure in dictionary.get('eiendelerKonsernField'):\\r\\n eiendeler_konsern_field.append(idfy_rest_client.models.eiendeler_konsern.EiendelerKonsern.from_dictionary(structure))\\r\\n gjeld_egenkapital_foretak_field = None\\r\\n if dictionary.get('gjeldEgenkapitalForetakField') != None:\\r\\n gjeld_egenkapital_foretak_field = list()\\r\\n for structure in dictionary.get('gjeldEgenkapitalForetakField'):\\r\\n gjeld_egenkapital_foretak_field.append(idfy_rest_client.models.gjeld_egenkapital_foretak.GjeldEgenkapitalForetak.from_dictionary(structure))\\r\\n gjeld_egenkapital_konsern_field = None\\r\\n if dictionary.get('gjeldEgenkapitalKonsernField') != None:\\r\\n gjeld_egenkapital_konsern_field = list()\\r\\n for structure in dictionary.get('gjeldEgenkapitalKonsernField'):\\r\\n gjeld_egenkapital_konsern_field.append(idfy_rest_client.models.gjeld_egenkapital_konsern.GjeldEgenkapitalKonsern.from_dictionary(structure))\\r\\n avdeling_data_field = idfy_rest_client.models.avdeling_data.AvdelingData.from_dictionary(dictionary.get('avdelingDataField')) if dictionary.get('avdelingDataField') else None\\r\\n rettighetshavere_field = None\\r\\n if dictionary.get('rettighetshavereField') != None:\\r\\n rettighetshavere_field = list()\\r\\n for structure in dictionary.get('rettighetshavereField'):\\r\\n rettighetshavere_field.append(idfy_rest_client.models.rettighetshavere.Rettighetshavere.from_dictionary(structure))\\r\\n eiendom_norge_liste_field = None\\r\\n if dictionary.get('eiendomNorgeListeField') != None:\\r\\n eiendom_norge_liste_field = list()\\r\\n for structure in dictionary.get('eiendomNorgeListeField'):\\r\\n eiendom_norge_liste_field.append(idfy_rest_client.models.eiendom_norge_liste.EiendomNorgeListe.from_dictionary(structure))\\r\\n fullmakt_foretak_field = None\\r\\n if dictionary.get('fullmaktForetakField') != None:\\r\\n fullmakt_foretak_field = list()\\r\\n for structure in dictionary.get('fullmaktForetakField'):\\r\\n fullmakt_foretak_field.append(idfy_rest_client.models.fullmakt_foretak.FullmaktForetak.from_dictionary(structure))\\r\\n meldinger_field = None\\r\\n if dictionary.get('meldingerField') != None:\\r\\n meldinger_field = list()\\r\\n for structure in dictionary.get('meldingerField'):\\r\\n meldinger_field.append(idfy_rest_client.models.meldinger.Meldinger.from_dictionary(structure))\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(identifikasjon_field,\\r\\n navn_adresse_field,\\r\\n rating_field,\\r\\n hist_rating_field,\\r\\n grunnfakta_field,\\r\\n juridisk_field,\\r\\n verv_field,\\r\\n aksjonar_field,\\r\\n datterselskap_field,\\r\\n okonomi_enk_field,\\r\\n nokkeltall_foretak_field,\\r\\n nokkeltall_bransje_field,\\r\\n nokkeltall_konsern_field,\\r\\n beta_sammendrag_field,\\r\\n beta_detaljer_field,\\r\\n losore_field,\\r\\n eiendom_norge_field,\\r\\n konsern_link_field,\\r\\n scoring_field,\\r\\n okonomi_sammendrag_foretak_field,\\r\\n okonomi_sammendrag_konsern_field,\\r\\n okonomi_detaljer_foretak_field,\\r\\n okonomi_detaljer_konsern_field,\\r\\n eiendeler_foretak_field,\\r\\n eiendeler_konsern_field,\\r\\n gjeld_egenkapital_foretak_field,\\r\\n gjeld_egenkapital_konsern_field,\\r\\n avdeling_data_field,\\r\\n rettighetshavere_field,\\r\\n eiendom_norge_liste_field,\\r\\n fullmakt_foretak_field,\\r\\n meldinger_field,\\r\\n dictionary)\",\n \"def from_dict(cls, dikt) -> 'Lecture':\\n return util.deserialize_model(dikt, cls)\",\n \"def load_state_dict(self, state_dict):\\n self.__dict__.update(state_dict)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5525752","0.5340668","0.52998114","0.5021224","0.49906397","0.48999608","0.47908178","0.47714812","0.47337997","0.4732373","0.47303945","0.47028187","0.4698919","0.46946174","0.4689702","0.46578616","0.46578616","0.46391878","0.4634687","0.4631234","0.4623616","0.45898682","0.45823622","0.45573068","0.45559672","0.45422727","0.45071554","0.4506151","0.45005772","0.44590873","0.44549063","0.44536707","0.4440183","0.44398206","0.44321823","0.4425283","0.44250813","0.43996862","0.4398912","0.439618","0.43937823","0.4379626","0.43696553","0.43614697","0.4359855","0.43578124","0.4354073","0.43514538","0.43481684","0.43187162","0.43153962","0.4311117","0.43094262","0.4302558","0.42883447","0.42645252","0.42623344","0.42588308","0.4233737","0.42230302","0.42145726","0.42120886","0.42002174","0.41878155","0.41834143","0.41799995","0.41799754","0.41773695","0.41771358","0.41768414","0.4170488","0.41703734","0.416071","0.41549838","0.4154288","0.41531718","0.415186","0.41496047","0.41491622","0.4145931","0.41376632","0.41368932","0.41344598","0.41334987","0.41316265","0.4128878","0.41288248","0.41258553","0.41231328","0.4118023","0.41163063","0.41076314","0.4105661","0.41015556","0.40984857","0.40956655","0.40945348","0.40923345","0.40894458","0.40872476"],"string":"[\n \"0.5525752\",\n \"0.5340668\",\n \"0.52998114\",\n \"0.5021224\",\n \"0.49906397\",\n \"0.48999608\",\n \"0.47908178\",\n \"0.47714812\",\n \"0.47337997\",\n \"0.4732373\",\n \"0.47303945\",\n \"0.47028187\",\n \"0.4698919\",\n \"0.46946174\",\n \"0.4689702\",\n \"0.46578616\",\n \"0.46578616\",\n \"0.46391878\",\n \"0.4634687\",\n \"0.4631234\",\n \"0.4623616\",\n \"0.45898682\",\n \"0.45823622\",\n \"0.45573068\",\n \"0.45559672\",\n \"0.45422727\",\n \"0.45071554\",\n \"0.4506151\",\n \"0.45005772\",\n \"0.44590873\",\n \"0.44549063\",\n \"0.44536707\",\n \"0.4440183\",\n \"0.44398206\",\n \"0.44321823\",\n \"0.4425283\",\n \"0.44250813\",\n \"0.43996862\",\n \"0.4398912\",\n \"0.439618\",\n \"0.43937823\",\n \"0.4379626\",\n \"0.43696553\",\n \"0.43614697\",\n \"0.4359855\",\n \"0.43578124\",\n \"0.4354073\",\n \"0.43514538\",\n \"0.43481684\",\n \"0.43187162\",\n \"0.43153962\",\n \"0.4311117\",\n \"0.43094262\",\n \"0.4302558\",\n \"0.42883447\",\n \"0.42645252\",\n \"0.42623344\",\n \"0.42588308\",\n \"0.4233737\",\n \"0.42230302\",\n \"0.42145726\",\n \"0.42120886\",\n \"0.42002174\",\n \"0.41878155\",\n \"0.41834143\",\n \"0.41799995\",\n \"0.41799754\",\n \"0.41773695\",\n \"0.41771358\",\n \"0.41768414\",\n \"0.4170488\",\n \"0.41703734\",\n \"0.416071\",\n \"0.41549838\",\n \"0.4154288\",\n \"0.41531718\",\n \"0.415186\",\n \"0.41496047\",\n \"0.41491622\",\n \"0.4145931\",\n \"0.41376632\",\n \"0.41368932\",\n \"0.41344598\",\n \"0.41334987\",\n \"0.41316265\",\n \"0.4128878\",\n \"0.41288248\",\n \"0.41258553\",\n \"0.41231328\",\n \"0.4118023\",\n \"0.41163063\",\n \"0.41076314\",\n \"0.4105661\",\n \"0.41015556\",\n \"0.40984857\",\n \"0.40956655\",\n \"0.40945348\",\n \"0.40923345\",\n \"0.40894458\",\n \"0.40872476\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57506377"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90581,"cells":{"query":{"kind":"string","value":"Serializes this snippet to a dictionary."},"document":{"kind":"string","value":"def to_json(self):\n json = {\n \"url\": url_for(\n \"api.get_week\",\n year=self.year,\n week=self.week,\n ),\n \"year\": self.year,\n \"week\": self.week,\n \"text\": self.text or \"\",\n \"tags\": [tag.text for tag in self.tags],\n }\n return json"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def serialize(self):\n return {\n 'title': self.title,\n 'description': self.description,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'title': self.title,\n 'description': self.description,\n 'body': self.body,\n }","def serialize(self):\n\t\treturn {\n\t\t\t'name' : self.name,\n\t\t\t'id' : self.id,\n\t\t\t'description' : self.description,\n\t\t\t'kind_of_thing' : self.kind_of_thing,\n\t\t}","def serialize(self):\r\n return {\r\n 'title': self.title,\r\n 'id': self.id,\r\n 'domain': self.domain,\r\n 'd_h1': self.d_h1,\r\n 'd_p': self.d_p,\r\n 'd_img': self.d_img,\r\n 'd_textcolor': self.d_textcolor,\r\n 'd_pagecolor': self.d_pagecolor,\r\n 'd_background': self.d_background,\r\n 'd_pwidth': self.d_pwidth,\r\n 'd_margin': self.d_margin,\r\n 'd_padding': self.d_padding,\r\n 'd_textalign': self.d_textalign,\r\n 'd_imgwidth': self.d_imgwidth,\r\n 'd_imgheight': self.d_imgheight,\r\n 'd_imgradius': self.d_imgradius,\r\n 'd_borderwidth': self.d_borderwidth,\r\n 'd_bordertype': self.d_bordertype,\r\n 'd_bordercolor': self.d_bordercolor,\r\n 'h1_image': self.h1_image,\r\n 'h1_background': self.h1_background,\r\n 'h1_bradius': self.h1_bradius,\r\n 'h1_fsize': self.h1_fsize,\r\n 'h1_customsize': self.h1_customsize,\r\n 'h1_width': self.h1_width,\r\n 'user_post': self.user_post,\r\n 'comment': self.comment,\r\n 'extra': self.extra,\r\n 'extra_int': self.extra_int \r\n }","def dumps(self) -> Dict[str, Any]:\n return {\"number\": self.number, \"title\": self.title}","def serialize(self):\n return {\n 'name': self.name,\n 'description': self.description,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'title': self.title,\n 'desc': self.desc,\n 'category_id': self.category_id,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n 'description': self.description,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n 'description': self.description,\n 'date_added': self.date_added,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'title': self.title,\n 'description': self.description,\n 'cat_id': self.cat_id,\n 'user_id': self.user_id\n }","def serialize(self):\n return {\n 'id': self.id,\n 'title': self.title,\n 'body': self.body,\n 'images': {\n 'img_path_xs': self.img_path_xs,\n 'img_path_sm': self.img_path_sm,\n 'img_path_md': self.img_path_md,\n 'img_path_lg': self.img_path_lg\n },\n 'is_active': self.is_active,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'description' : self.description,\n 'is_private' : self.is_private,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n 'description': self.description,\n 'category_id': self.category_id,\n }","def serialize(self):\r\n return {\r\n 'slug': self.slug,\r\n 'title': self.title,\r\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n 'catalog': self.catalog.serialize,\n }","def __json_encode__(self) -> Dict[str, Any]:\n return {\"figure\": self.figure, \"name\": self.name, \"metadata\": self.metadata}","def serialize(self) -> Dict:\n return dict(\n desc=self.desc,\n ret=self.ret,\n cc=self.cc,\n author=self.author,\n links=self.links,\n args=self.args,\n notes=self.notes,\n warnings=self.warnings,\n no_lint=self.no_lint,\n )","def serialize(self):\r\n return {\r\n 'id': self.id,\r\n 'name': self.name,\r\n 'picture': self.picture,\r\n 'description': self.description,\r\n 'category_slug': self.category_slug}","def serialize(self):\n return {\n \"id\": self.id,\n \"headline\": self.headline,\n \"url\": self.url,\n \"image\": self.image,\n \"shortDescription\": self.shortDescription,\n \"saved\": True,\n \"date\": self.date,\n \"savedDate\": self.savedDate\n }","def serialize(self):\n return {\n 'cat_id': self.cat_id,\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n }","def serialize(self) -> Dict:\n return dict(\n author=self.doc.author if self.doc else None,\n name=self.name,\n functions=[x.serialize() for x in self.functions],\n classes=[x.serialize() for x in self.classes],\n doc=self.doc.serialize() if self.doc else None,\n )","def serialize(self):\n return {\n 'name': self.name,\n 'description': self.description,\n 'id': self.id,\n 'price': self.price,\n 'catch_phrase': self.catch_phrase,\n }","def serialize(self) -> dict:\n output = super().serialize()\n output[\"iteration\"] = self.iteration\n return output","def serialize(self):\n return {\n 'name': self.name,\n 'description': self.description,\n 'category': self.category\n }","def to_dict(self):\n return dumpd(self)","def serialize(self):\n return {\n 'title': self.title,\n 'first_author': self.first_author,\n 'second_author': self.second_author,\n 'publisher': self.publisher,\n 'year_of_publication': self.year_of_publication\n }","def serialize(self):\r\n return {\r\n 'name': self.name,\r\n 'description': self.description,\r\n 'id': self.id,\r\n 'category': self.category_name\r\n }","def serialize(self) -> Dict:\n return dict(\n author=self.doc.author if self.doc else None,\n name=self.name,\n line=self.line,\n column=self.column,\n functions=[x.serialize() for x in self.functions],\n classes=[x.serialize() for x in self.classes],\n doc=self.doc.serialize() if self.doc else None,\n )","def serialize(self):\n\t\treturn {\n\t\t\t'id': self.id,\n\t\t\t'title': self.title,\n\t\t\t'tracknum': self.track_num,\n\t\t\t'video': self.video_id\n\t\t}","def serialize(self):\n return {\n 'word': self.word,\n 'pos': self.pos,\n 'label': self.label,\n 'dependency': self.dependency\n }","def serialize(self):\r\n return {\r\n \"book_id\": self.id,\r\n \"title\": self.title,\r\n \"author\": self.author,\r\n \"category\": self.category,\r\n }","def to_dict(self):\n return {'tag': self.tag,\n 'title': self.title,\n 'regionTitle': self.region_title,\n 'shortTitle': self.short_title,\n 'color': self.color,\n 'oppositeColor': self.opposite_color,\n 'latMin': self.lat_min,\n 'latMax': self.lat_max,\n 'lonMin': self.lon_min,\n 'lonMax': self.lon_max,\n 'directions': [d.to_dict() for d in self.directions],\n 'stops': [s.to_dict() for s in self.stops],\n 'paths': [p.to_list() for p in self.paths]}","def serialize(self):\r\n return {\r\n 'documentId': self.documentId,\r\n 'document_doman': self.document_doman\r\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'date_time' : str(self.date_time),\n 'duration' : self.duration,\n 'highlights' : self.highlights,\n 'conference_id' : self.conference_id,\n 'type_of_session_id' : self.type_of_session_id,\n 'speaker_id' : self.speaker_id,\n 'location_id' : self.location_id,\n 'documents' : self.documents \n }","def serialize(self):\r\n return {\r\n 'likes': self.likes,\r\n 'dislike': self.dislike,\r\n 'id': self.id\r\n }","def dump(self):\n return {\"data\": self.data, \"encoding\": self.encoding,\n \"type\": self.type_name}","def serialize(self) -> dict:\n return {\n 'name': self.name,\n 'vendor': self.vendor,\n 'alternative_names': self.alternative_names,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'ingredients': self.ingredients,\n 'directions': self.directions,\n 'type': self.type,\n }","def dumps(self) -> Dict[str, Any]:\n contents = super().dumps()\n contents[\"name\"] = self.name\n return contents","def serialize(self):\n return {\n 'name' : self.name,\n 'description' : self.description,\n 'id' : self.id,\n 'picture' : self.picture,\n 'catalog_id' : self.catalog_id,\n 'user_id' : self.user_id,\n 'last_edit' : self.time_str,\n }","def serialize(self):\n return {\n 'lapyname': self.lapyname,\n 'speciality': self.speciality,\n 'ram': self.ram,\n 'storage': self.storage,\n 'warrenty': self.warrenty,\n 'price': self.price,\n 'rating': self.rating,\n 'date': self.date,\n 'id': self. id\n }","def serialize(self):\n return {\n 'district': self.district,\n 'hadquartes': self.headquartes,\n 'revenue_division': self.revenue_division,\n 'mandals': self.mandals,\n 'population': self.population,\n 'area': self.area,\n 'density': self.density,\n 'id': self.id\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'description': self.description,\n 'longitude' : self.longitude,\n 'latitude' : self.latitude,\n 'created_on' : self.created_on,\n 'created_by' : self.created_by,\n 'likes' : self.likes\n }","def serialize(self):\n\t\treturn {\n\t\t\t'name' : self.name,\n\t\t\t'id' : self.id,\n\t\t}","def serialize(self) -> dict:\n output = super().serialize()\n output[\"start\"] = self.start\n output[\"stride\"] = self.stride\n output[\"part_size\"] = self.part_size\n output[\"end\"] = self.end\n output[\"axis\"] = self.axis\n return output","def serialize(self) -> dict:\n output = super().serialize()\n output[\"start\"] = self.start\n output[\"stride\"] = self.stride\n output[\"part_size\"] = self.part_size\n output[\"end\"] = self.end\n output[\"axis\"] = self.axis\n return output","def __serialize__(self):\n return {\"_custom_type\" : self.__class__.__name__,\n \"name\" : self.name,\n \"src\" : self.src,\n \"exec_loc\" : self.exec_loc,\n \"precompiled\" : self.precompiled}","def serialize(self):\n return {\n 'id' : self.id,\n #had to change to 'title' for full calendar, might change\n 'title' : self.name,\n 'host' : self.created_by,\n 'start' : self.start_on.isoformat(),\n 'end' : self.end_on.isoformat(),\n 'description' : self.description,\n 'color' : 'blue',\n }","def serialize(self):\n return {\n\n\n }","def serialize(self):\n\t\treturn { 'description': self.description, 'zone' : self.zone, 'enabled' : self.enabled, 'dayTimeOnly' : self.day_time_only, 'authorizeOnly' : self.authorize_only, 'secret' : self.secret, 'deviceType' : self.deviceType, 'specific_configuration': self.specific_configuration}","def serialize(self):\n return {\n 'special_messages': self.special_messages,\n 'description': self.description,\n 'name': self.name,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'id' = self.id,\n 'name'= self.name,\n 'address_one' = address_one,\n\t\t\t'address_two' = address_two,\n\t\t\t'zip_code' = zip_code,\n\t\t\t'phone_number' = phone_number,\n\t\t\t'description' = description,\n }","def serialize(self):\n\t\treturn {\n\t\t\t'id': self.id,\n\t\t\t'title': self.title,\n\t\t\t'year': self.year,\n\t\t\t'artist': self.artist_id,\n\t\t\t'user': self.user_id\n\t\t}","def serialize(self):\n return json.dumps(self.as_dict())","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n 'items': self.serialize_items\n }","def to_dict(self):\n return {\n 'name': self.get_name(),\n 'description': self.get_description()\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def __repr__(self):\n return json.dumps(self.__dict__)","def serialize(self):\n return {\n 'name' : self.name,\n 'id' : self.id,\n 'thumbnail_url' : self.organizer_thumbnail_url\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'description': self.description,\n 'price': self.price,\n 'course': self.course,\n 'restaurant_id': self.restaurant_id\n }","def dump():\n\t\treturn self.__dict__;","def json(self):\n return {'id': self.id, 'name': self.name, 'description': self.description}","def serialize(self) -> dict:\n return {\n \"body_value_idx\": self.body_value_idx,\n \"output_idx\": self.output_idx,\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n 'event_url' : self.event_url,\n 'event_thumbnail_url' : self.event_thumbnail_url,\n 'description' : self.description,\n 'ticket_price' : self.ticket_price,\n 'start_date' : str(self.start_date),\n 'featued' : self.featured\n }","def serialize(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n }","def serialize(self):\n return {\n \"key\": self.key,\n \"value\": self.value\n }","def as_dict(self):\n return {'tag_type': self.tag_type, 'value': self.value}","def to_dict(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n \"courseid\": self.courseid,\n \"instructorid\":self.instructorid,\n \"created_time\": self.created_time,\n \"notebook_url\": self.notebook_url\n }","def serialize(self):\n return {\n 'name': self.name,\n 'id': self.id,\n }","def asDict(self):\n return {\n 'id': self.id,\n 'name': self.name,\n 'type': self.type,\n 'favicon': self.favicon,\n 'thumbnails': self.thumbnails,\n 'access': self.access,\n 'client_details': self.client_details\n }","def serialize(self):\n return{\n 'name': self.name,\n 'id': self.id,\n }","def as_dict(self):\r\n return {\r\n 'id': self.pk,\r\n 'user_id': self.user.pk,\r\n 'uri': self.uri,\r\n 'text': self.text,\r\n 'quote': self.quote,\r\n 'ranges': [{\r\n 'start': self.range_start,\r\n 'startOffset': self.range_start_offset,\r\n 'end': self.range_end,\r\n 'endOffset': self.range_end_offset\r\n }],\r\n 'tags': self.tags.split(\",\"),\r\n 'created': str(self.created),\r\n 'updated': str(self.updated)\r\n }","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def to_dict(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n \"author\": self.author,\n \"description\": self.description\n }","def serialize(self):\n return {\n 'id': self.id,\n 'name': self.name\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def serialize(self):\n\t\treturn {\n\t\t\t\"id\": self.id,\n\t\t\t\"name\": self.name\n\t\t}","def serialize(self):\n\t\treturn {\n\t\t\t\"id\": self.id,\n\t\t\t\"name\": self.name\n\t\t}"],"string":"[\n \"def serialize(self):\\n return {\\n 'title': self.title,\\n 'description': self.description,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'title': self.title,\\n 'description': self.description,\\n 'body': self.body,\\n }\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t'name' : self.name,\\n\\t\\t\\t'id' : self.id,\\n\\t\\t\\t'description' : self.description,\\n\\t\\t\\t'kind_of_thing' : self.kind_of_thing,\\n\\t\\t}\",\n \"def serialize(self):\\r\\n return {\\r\\n 'title': self.title,\\r\\n 'id': self.id,\\r\\n 'domain': self.domain,\\r\\n 'd_h1': self.d_h1,\\r\\n 'd_p': self.d_p,\\r\\n 'd_img': self.d_img,\\r\\n 'd_textcolor': self.d_textcolor,\\r\\n 'd_pagecolor': self.d_pagecolor,\\r\\n 'd_background': self.d_background,\\r\\n 'd_pwidth': self.d_pwidth,\\r\\n 'd_margin': self.d_margin,\\r\\n 'd_padding': self.d_padding,\\r\\n 'd_textalign': self.d_textalign,\\r\\n 'd_imgwidth': self.d_imgwidth,\\r\\n 'd_imgheight': self.d_imgheight,\\r\\n 'd_imgradius': self.d_imgradius,\\r\\n 'd_borderwidth': self.d_borderwidth,\\r\\n 'd_bordertype': self.d_bordertype,\\r\\n 'd_bordercolor': self.d_bordercolor,\\r\\n 'h1_image': self.h1_image,\\r\\n 'h1_background': self.h1_background,\\r\\n 'h1_bradius': self.h1_bradius,\\r\\n 'h1_fsize': self.h1_fsize,\\r\\n 'h1_customsize': self.h1_customsize,\\r\\n 'h1_width': self.h1_width,\\r\\n 'user_post': self.user_post,\\r\\n 'comment': self.comment,\\r\\n 'extra': self.extra,\\r\\n 'extra_int': self.extra_int \\r\\n }\",\n \"def dumps(self) -> Dict[str, Any]:\\n return {\\\"number\\\": self.number, \\\"title\\\": self.title}\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'description': self.description,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'title': self.title,\\n 'desc': self.desc,\\n 'category_id': self.category_id,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n 'description': self.description,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n 'description': self.description,\\n 'date_added': self.date_added,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'title': self.title,\\n 'description': self.description,\\n 'cat_id': self.cat_id,\\n 'user_id': self.user_id\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'title': self.title,\\n 'body': self.body,\\n 'images': {\\n 'img_path_xs': self.img_path_xs,\\n 'img_path_sm': self.img_path_sm,\\n 'img_path_md': self.img_path_md,\\n 'img_path_lg': self.img_path_lg\\n },\\n 'is_active': self.is_active,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'description' : self.description,\\n 'is_private' : self.is_private,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n 'description': self.description,\\n 'category_id': self.category_id,\\n }\",\n \"def serialize(self):\\r\\n return {\\r\\n 'slug': self.slug,\\r\\n 'title': self.title,\\r\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n 'catalog': self.catalog.serialize,\\n }\",\n \"def __json_encode__(self) -> Dict[str, Any]:\\n return {\\\"figure\\\": self.figure, \\\"name\\\": self.name, \\\"metadata\\\": self.metadata}\",\n \"def serialize(self) -> Dict:\\n return dict(\\n desc=self.desc,\\n ret=self.ret,\\n cc=self.cc,\\n author=self.author,\\n links=self.links,\\n args=self.args,\\n notes=self.notes,\\n warnings=self.warnings,\\n no_lint=self.no_lint,\\n )\",\n \"def serialize(self):\\r\\n return {\\r\\n 'id': self.id,\\r\\n 'name': self.name,\\r\\n 'picture': self.picture,\\r\\n 'description': self.description,\\r\\n 'category_slug': self.category_slug}\",\n \"def serialize(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"headline\\\": self.headline,\\n \\\"url\\\": self.url,\\n \\\"image\\\": self.image,\\n \\\"shortDescription\\\": self.shortDescription,\\n \\\"saved\\\": True,\\n \\\"date\\\": self.date,\\n \\\"savedDate\\\": self.savedDate\\n }\",\n \"def serialize(self):\\n return {\\n 'cat_id': self.cat_id,\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n }\",\n \"def serialize(self) -> Dict:\\n return dict(\\n author=self.doc.author if self.doc else None,\\n name=self.name,\\n functions=[x.serialize() for x in self.functions],\\n classes=[x.serialize() for x in self.classes],\\n doc=self.doc.serialize() if self.doc else None,\\n )\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'description': self.description,\\n 'id': self.id,\\n 'price': self.price,\\n 'catch_phrase': self.catch_phrase,\\n }\",\n \"def serialize(self) -> dict:\\n output = super().serialize()\\n output[\\\"iteration\\\"] = self.iteration\\n return output\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'description': self.description,\\n 'category': self.category\\n }\",\n \"def to_dict(self):\\n return dumpd(self)\",\n \"def serialize(self):\\n return {\\n 'title': self.title,\\n 'first_author': self.first_author,\\n 'second_author': self.second_author,\\n 'publisher': self.publisher,\\n 'year_of_publication': self.year_of_publication\\n }\",\n \"def serialize(self):\\r\\n return {\\r\\n 'name': self.name,\\r\\n 'description': self.description,\\r\\n 'id': self.id,\\r\\n 'category': self.category_name\\r\\n }\",\n \"def serialize(self) -> Dict:\\n return dict(\\n author=self.doc.author if self.doc else None,\\n name=self.name,\\n line=self.line,\\n column=self.column,\\n functions=[x.serialize() for x in self.functions],\\n classes=[x.serialize() for x in self.classes],\\n doc=self.doc.serialize() if self.doc else None,\\n )\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t'id': self.id,\\n\\t\\t\\t'title': self.title,\\n\\t\\t\\t'tracknum': self.track_num,\\n\\t\\t\\t'video': self.video_id\\n\\t\\t}\",\n \"def serialize(self):\\n return {\\n 'word': self.word,\\n 'pos': self.pos,\\n 'label': self.label,\\n 'dependency': self.dependency\\n }\",\n \"def serialize(self):\\r\\n return {\\r\\n \\\"book_id\\\": self.id,\\r\\n \\\"title\\\": self.title,\\r\\n \\\"author\\\": self.author,\\r\\n \\\"category\\\": self.category,\\r\\n }\",\n \"def to_dict(self):\\n return {'tag': self.tag,\\n 'title': self.title,\\n 'regionTitle': self.region_title,\\n 'shortTitle': self.short_title,\\n 'color': self.color,\\n 'oppositeColor': self.opposite_color,\\n 'latMin': self.lat_min,\\n 'latMax': self.lat_max,\\n 'lonMin': self.lon_min,\\n 'lonMax': self.lon_max,\\n 'directions': [d.to_dict() for d in self.directions],\\n 'stops': [s.to_dict() for s in self.stops],\\n 'paths': [p.to_list() for p in self.paths]}\",\n \"def serialize(self):\\r\\n return {\\r\\n 'documentId': self.documentId,\\r\\n 'document_doman': self.document_doman\\r\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'date_time' : str(self.date_time),\\n 'duration' : self.duration,\\n 'highlights' : self.highlights,\\n 'conference_id' : self.conference_id,\\n 'type_of_session_id' : self.type_of_session_id,\\n 'speaker_id' : self.speaker_id,\\n 'location_id' : self.location_id,\\n 'documents' : self.documents \\n }\",\n \"def serialize(self):\\r\\n return {\\r\\n 'likes': self.likes,\\r\\n 'dislike': self.dislike,\\r\\n 'id': self.id\\r\\n }\",\n \"def dump(self):\\n return {\\\"data\\\": self.data, \\\"encoding\\\": self.encoding,\\n \\\"type\\\": self.type_name}\",\n \"def serialize(self) -> dict:\\n return {\\n 'name': self.name,\\n 'vendor': self.vendor,\\n 'alternative_names': self.alternative_names,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'ingredients': self.ingredients,\\n 'directions': self.directions,\\n 'type': self.type,\\n }\",\n \"def dumps(self) -> Dict[str, Any]:\\n contents = super().dumps()\\n contents[\\\"name\\\"] = self.name\\n return contents\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'description' : self.description,\\n 'id' : self.id,\\n 'picture' : self.picture,\\n 'catalog_id' : self.catalog_id,\\n 'user_id' : self.user_id,\\n 'last_edit' : self.time_str,\\n }\",\n \"def serialize(self):\\n return {\\n 'lapyname': self.lapyname,\\n 'speciality': self.speciality,\\n 'ram': self.ram,\\n 'storage': self.storage,\\n 'warrenty': self.warrenty,\\n 'price': self.price,\\n 'rating': self.rating,\\n 'date': self.date,\\n 'id': self. id\\n }\",\n \"def serialize(self):\\n return {\\n 'district': self.district,\\n 'hadquartes': self.headquartes,\\n 'revenue_division': self.revenue_division,\\n 'mandals': self.mandals,\\n 'population': self.population,\\n 'area': self.area,\\n 'density': self.density,\\n 'id': self.id\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'description': self.description,\\n 'longitude' : self.longitude,\\n 'latitude' : self.latitude,\\n 'created_on' : self.created_on,\\n 'created_by' : self.created_by,\\n 'likes' : self.likes\\n }\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t'name' : self.name,\\n\\t\\t\\t'id' : self.id,\\n\\t\\t}\",\n \"def serialize(self) -> dict:\\n output = super().serialize()\\n output[\\\"start\\\"] = self.start\\n output[\\\"stride\\\"] = self.stride\\n output[\\\"part_size\\\"] = self.part_size\\n output[\\\"end\\\"] = self.end\\n output[\\\"axis\\\"] = self.axis\\n return output\",\n \"def serialize(self) -> dict:\\n output = super().serialize()\\n output[\\\"start\\\"] = self.start\\n output[\\\"stride\\\"] = self.stride\\n output[\\\"part_size\\\"] = self.part_size\\n output[\\\"end\\\"] = self.end\\n output[\\\"axis\\\"] = self.axis\\n return output\",\n \"def __serialize__(self):\\n return {\\\"_custom_type\\\" : self.__class__.__name__,\\n \\\"name\\\" : self.name,\\n \\\"src\\\" : self.src,\\n \\\"exec_loc\\\" : self.exec_loc,\\n \\\"precompiled\\\" : self.precompiled}\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n #had to change to 'title' for full calendar, might change\\n 'title' : self.name,\\n 'host' : self.created_by,\\n 'start' : self.start_on.isoformat(),\\n 'end' : self.end_on.isoformat(),\\n 'description' : self.description,\\n 'color' : 'blue',\\n }\",\n \"def serialize(self):\\n return {\\n\\n\\n }\",\n \"def serialize(self):\\n\\t\\treturn { 'description': self.description, 'zone' : self.zone, 'enabled' : self.enabled, 'dayTimeOnly' : self.day_time_only, 'authorizeOnly' : self.authorize_only, 'secret' : self.secret, 'deviceType' : self.deviceType, 'specific_configuration': self.specific_configuration}\",\n \"def serialize(self):\\n return {\\n 'special_messages': self.special_messages,\\n 'description': self.description,\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' = self.id,\\n 'name'= self.name,\\n 'address_one' = address_one,\\n\\t\\t\\t'address_two' = address_two,\\n\\t\\t\\t'zip_code' = zip_code,\\n\\t\\t\\t'phone_number' = phone_number,\\n\\t\\t\\t'description' = description,\\n }\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t'id': self.id,\\n\\t\\t\\t'title': self.title,\\n\\t\\t\\t'year': self.year,\\n\\t\\t\\t'artist': self.artist_id,\\n\\t\\t\\t'user': self.user_id\\n\\t\\t}\",\n \"def serialize(self):\\n return json.dumps(self.as_dict())\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n 'items': self.serialize_items\\n }\",\n \"def to_dict(self):\\n return {\\n 'name': self.get_name(),\\n 'description': self.get_description()\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def __repr__(self):\\n return json.dumps(self.__dict__)\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'id' : self.id,\\n 'thumbnail_url' : self.organizer_thumbnail_url\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'description': self.description,\\n 'price': self.price,\\n 'course': self.course,\\n 'restaurant_id': self.restaurant_id\\n }\",\n \"def dump():\\n\\t\\treturn self.__dict__;\",\n \"def json(self):\\n return {'id': self.id, 'name': self.name, 'description': self.description}\",\n \"def serialize(self) -> dict:\\n return {\\n \\\"body_value_idx\\\": self.body_value_idx,\\n \\\"output_idx\\\": self.output_idx,\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n 'event_url' : self.event_url,\\n 'event_thumbnail_url' : self.event_thumbnail_url,\\n 'description' : self.description,\\n 'ticket_price' : self.ticket_price,\\n 'start_date' : str(self.start_date),\\n 'featued' : self.featured\\n }\",\n \"def serialize(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n }\",\n \"def serialize(self):\\n return {\\n \\\"key\\\": self.key,\\n \\\"value\\\": self.value\\n }\",\n \"def as_dict(self):\\n return {'tag_type': self.tag_type, 'value': self.value}\",\n \"def to_dict(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n \\\"courseid\\\": self.courseid,\\n \\\"instructorid\\\":self.instructorid,\\n \\\"created_time\\\": self.created_time,\\n \\\"notebook_url\\\": self.notebook_url\\n }\",\n \"def serialize(self):\\n return {\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def asDict(self):\\n return {\\n 'id': self.id,\\n 'name': self.name,\\n 'type': self.type,\\n 'favicon': self.favicon,\\n 'thumbnails': self.thumbnails,\\n 'access': self.access,\\n 'client_details': self.client_details\\n }\",\n \"def serialize(self):\\n return{\\n 'name': self.name,\\n 'id': self.id,\\n }\",\n \"def as_dict(self):\\r\\n return {\\r\\n 'id': self.pk,\\r\\n 'user_id': self.user.pk,\\r\\n 'uri': self.uri,\\r\\n 'text': self.text,\\r\\n 'quote': self.quote,\\r\\n 'ranges': [{\\r\\n 'start': self.range_start,\\r\\n 'startOffset': self.range_start_offset,\\r\\n 'end': self.range_end,\\r\\n 'endOffset': self.range_end_offset\\r\\n }],\\r\\n 'tags': self.tags.split(\\\",\\\"),\\r\\n 'created': str(self.created),\\r\\n 'updated': str(self.updated)\\r\\n }\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n \\\"author\\\": self.author,\\n \\\"description\\\": self.description\\n }\",\n \"def serialize(self):\\n return {\\n 'id': self.id,\\n 'name': self.name\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t\\\"id\\\": self.id,\\n\\t\\t\\t\\\"name\\\": self.name\\n\\t\\t}\",\n \"def serialize(self):\\n\\t\\treturn {\\n\\t\\t\\t\\\"id\\\": self.id,\\n\\t\\t\\t\\\"name\\\": self.name\\n\\t\\t}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6837822","0.66297317","0.6602671","0.6591415","0.65640765","0.6554913","0.65533537","0.65455","0.64985853","0.64985853","0.64985853","0.6452853","0.6409583","0.640126","0.6401137","0.6398112","0.6344605","0.6341496","0.6340976","0.6338145","0.633426","0.633095","0.6329985","0.63161635","0.63122994","0.63114136","0.6299559","0.6289121","0.6286195","0.6273936","0.627116","0.626768","0.6242878","0.623593","0.6233908","0.62282467","0.6218349","0.62132484","0.62102735","0.62057024","0.62052166","0.6203276","0.6189474","0.6189347","0.61861545","0.6181695","0.61812395","0.61772734","0.61772734","0.6173778","0.61715716","0.6154856","0.6152138","0.61505824","0.6140631","0.6128664","0.6126293","0.61211276","0.61113745","0.6110825","0.6110825","0.6110825","0.6110825","0.6110825","0.6110825","0.6110825","0.6098312","0.60962427","0.60930437","0.6092565","0.6092224","0.6088974","0.6087717","0.6087717","0.6087717","0.6087717","0.6084826","0.6084826","0.6084826","0.6083931","0.6081173","0.6075052","0.60731125","0.6068183","0.60633415","0.60603434","0.60580146","0.6057238","0.60551906","0.60551906","0.60551906","0.60551906","0.60551906","0.60551906","0.60551906","0.60551804","0.6055036","0.60507405","0.60507405","0.60441977","0.60441977"],"string":"[\n \"0.6837822\",\n \"0.66297317\",\n \"0.6602671\",\n \"0.6591415\",\n \"0.65640765\",\n \"0.6554913\",\n \"0.65533537\",\n \"0.65455\",\n \"0.64985853\",\n \"0.64985853\",\n \"0.64985853\",\n \"0.6452853\",\n \"0.6409583\",\n \"0.640126\",\n \"0.6401137\",\n \"0.6398112\",\n \"0.6344605\",\n \"0.6341496\",\n \"0.6340976\",\n \"0.6338145\",\n \"0.633426\",\n \"0.633095\",\n \"0.6329985\",\n \"0.63161635\",\n \"0.63122994\",\n \"0.63114136\",\n \"0.6299559\",\n \"0.6289121\",\n \"0.6286195\",\n \"0.6273936\",\n \"0.627116\",\n \"0.626768\",\n \"0.6242878\",\n \"0.623593\",\n \"0.6233908\",\n \"0.62282467\",\n \"0.6218349\",\n \"0.62132484\",\n \"0.62102735\",\n \"0.62057024\",\n \"0.62052166\",\n \"0.6203276\",\n \"0.6189474\",\n \"0.6189347\",\n \"0.61861545\",\n \"0.6181695\",\n \"0.61812395\",\n \"0.61772734\",\n \"0.61772734\",\n \"0.6173778\",\n \"0.61715716\",\n \"0.6154856\",\n \"0.6152138\",\n \"0.61505824\",\n \"0.6140631\",\n \"0.6128664\",\n \"0.6126293\",\n \"0.61211276\",\n \"0.61113745\",\n \"0.6110825\",\n \"0.6110825\",\n \"0.6110825\",\n \"0.6110825\",\n \"0.6110825\",\n \"0.6110825\",\n \"0.6110825\",\n \"0.6098312\",\n \"0.60962427\",\n \"0.60930437\",\n \"0.6092565\",\n \"0.6092224\",\n \"0.6088974\",\n \"0.6087717\",\n \"0.6087717\",\n \"0.6087717\",\n \"0.6087717\",\n \"0.6084826\",\n \"0.6084826\",\n \"0.6084826\",\n \"0.6083931\",\n \"0.6081173\",\n \"0.6075052\",\n \"0.60731125\",\n \"0.6068183\",\n \"0.60633415\",\n \"0.60603434\",\n \"0.60580146\",\n \"0.6057238\",\n \"0.60551906\",\n \"0.60551906\",\n \"0.60551906\",\n \"0.60551906\",\n \"0.60551906\",\n \"0.60551906\",\n \"0.60551906\",\n \"0.60551804\",\n \"0.6055036\",\n \"0.60507405\",\n \"0.60507405\",\n \"0.60441977\",\n \"0.60441977\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":90582,"cells":{"query":{"kind":"string","value":"Returns the specified snippet (or None if it does not exist)."},"document":{"kind":"string","value":"def get_by_week(user_id: str, year: int, week: int) -> Optional[Snippet]:\n snippet = Snippet.query.filter_by(\n user_id=user_id, year=year, week=week\n )\n return snippet.first()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_snippet(self, title=None):\n for snippet in self.snippets:\n if snippet[\"title\"] == title:\n return snippet\n return None","def get_snippet(res_type, snippet_name):\n\treturn get_settings_resource(res_type, snippet_name, 'snippets');","def get(name):\n # cursor = connection.cursor()\n # command = \"select message from snippets where keyword='%s'\"%name\n # cursor.execute(command)\n # connection.commit()\n # message_tuple=cursor.fetchone()\n \n with connection, connection.cursor() as cursor:\n cursor.execute(\"select message from snippets where keyword=%s\", (name,))\n row = cursor.fetchone()\n \n if len(row)>0:\n logging.debug(\"Get Snippet successfully.\")\n return row[0]\n else:\n logging.debug(\"No Snippet got\")\n return \"\"","def get(name):\n #retrieve the snippet from the db - commnet from session of nicole darcy\n #i added the 'cursor= ' line because it said it was unused code, copied it from def put()\n# commenting lines below to replace with new code as per class lesson\n # cursor=connection.cursor()\n # row = cursor.fetchone()\n # connection.commit()\n with connection, connection.cursor() as cursor:\n cursor.execute(\"select message from snippets where keyword=%s\", (name,))\n row = cursor.fetchone()\n if not row:\n #No snippet was found with that name.\n return \"404: Snippet not Found\"\n return row[0]\n \n # warning for 'unreachable code' so i commented it out...\n # logging.error(\"FIXME: Unimplemented - get({!r})\".format(name))\n # print(\"this function is running\",get.__name__)\n # return \"\"","def snippet(self) -> global___Snippet:","def _load_snippet(filename) -> str:\n fullpath = f'{dirname(__file__)}/js/{filename}'\n file = open(fullpath, 'r')\n script = file.read()\n file.close()\n return script","def get_snippet(self):\n return html_utils.strip_tags(self.html)[:120] + ' ...'","def snippet_detail(request, pk):\n try:\n snippet = Snippet.objects.get(pk=pk)\n except Snippet.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = SnippetSerializer(snippet)\n return Response(serializer.data)\n\n elif request.method == 'PUT':\n serializer = SnippetSerializer(snippet, data=request.data)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data)\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n elif request.method == 'DELETE':\n snippet.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def snippet_detail(request, pk):\n try:\n snippet = Snippet.objects.get(pk=pk)\n except Snippet.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = SnippetSerializer(snippet)\n return Response(serializer.data)\n\n elif request.method == 'PUT':\n serializer = SnippetSerializer(snippet, data=request.data)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data)\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n elif request.method == 'DELETE':\n snippet.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def snippet_detail(request, snippet_id):\n snippet = get_object_or_404(Snippet, pk=snippet_id)\n return render_to_response('cab/snippet_detail.html',\n { 'object': snippet,\n 'num_ratings': snippet.rating_set.count(),\n 'rating_score': Rating.objects.score_for_snippet(snippet.id) },\n context_instance=RequestContext(request))","def snippet_detail(request, pk, format=None):\r\n try:\r\n snippet = Snippet.objects.get(pk=pk)\r\n except Snippet.DoesNotExist:\r\n return Response(status=status.HTTP_404_NOT_FOUND)\r\n\r\n if request.method == 'GET':\r\n serializer = SnippetSerializer(snippet)\r\n return Response(serializer.data)\r\n\r\n elif request.method == 'PUT':\r\n serializer = SnippetSerializer(snippet, data=request.data)\r\n if serializer.is_valid():\r\n serializer.save()\r\n return Response(serializer.data)\r\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\r\n\r\n elif request.method == 'DELETE':\r\n snippet.delete()\r\n return Response(status=status.HTTP_204_NO_CONTENT)","def get_entry(title):\n try:\n f = default_storage.open(f\"entries/{title}.md\")\n return f.read().decode(\"utf-8\")\n except FileNotFoundError:\n return None","def get_entry(title):\n try:\n f = default_storage.open(f\"entries/{title}.md\")\n return f.read().decode(\"utf-8\")\n\n except FileNotFoundError:\n return None","def _get_description(li):\n\n sdiv = li.find(\"div\", attrs={\"class\": \"result__body\"})\n if sdiv:\n stspan = sdiv.find(\"a\", attrs={\"class\": \"result__snippet\"})\n if stspan is not None:\n # return stspan.text.encode(\"utf-8\").strip()\n return stspan.text.strip()\n else:\n return None","def visit_snippet(self, node):\n lang = node[\"language\"]\n linenos = node.get('linenos', False)\n fname = node['filename']\n highlight_args = node.get('highlight_args', {})\n if 'language' in node:\n # code-block directives\n lang = node['language']\n highlight_args['force'] = True\n if 'linenos' in node:\n linenos = node['linenos']\n\n def warner(msg):\n self.builder.warn(msg, (self.builder.current_docname, node.line))\n\n highlighted = self.highlighter.highlight_block(node.rawsource, lang,\n warn=warner,\n linenos=linenos,\n **highlight_args)\n starttag = self.starttag(node, 'div', suffix='',\n CLASS='highlight-%s snippet' % lang)\n self.body.append(starttag)\n self.body.append('<div class=\"snippet-filename\">%s</div>\\n''' % (fname,))\n self.body.append(highlighted)\n self.body.append('</div>\\n')\n raise nodes.SkipNode","def is_snippet(abbr, doc_type = 'html'):\n\treturn get_snippet(doc_type, abbr) and True or False","def snippet_details(request, snippet_id, template_name='dpaste/snippet_details.html', is_raw=False):\n snippet = get_object_or_404(Snippet, secret_id=snippet_id)\n\n # One time snippet get deleted if the view count matches our limit\n if snippet.expire_type == Snippet.EXPIRE_ONETIME \\\n and snippet.view_count >= ONETIME_LIMIT:\n snippet.delete()\n raise Http404()\n\n # Increase the view count of the snippet\n snippet.view_count += 1\n snippet.save()\n\n tree = snippet.get_root()\n tree = tree.get_descendants(include_self=True)\n\n new_snippet_initial = {\n 'content': snippet.content,\n 'lexer': snippet.lexer,\n }\n\n if request.method == \"POST\":\n snippet_form = SnippetForm(\n data=request.POST,\n request=request,\n initial=new_snippet_initial)\n if snippet_form.is_valid():\n new_snippet = snippet_form.save(parent=snippet)\n url = new_snippet.get_absolute_url()\n return HttpResponseRedirect(url)\n else:\n snippet_form = SnippetForm(\n initial=new_snippet_initial,\n request=request)\n\n template_context = {\n 'snippet_form': snippet_form,\n 'snippet': snippet,\n 'lexers': LEXER_LIST,\n 'lines': range(snippet.get_linecount()),\n 'tree': tree,\n 'wordwrap': snippet.lexer in LEXER_WORDWRAP and 'True' or 'False',\n }\n\n response = render_to_response(\n template_name,\n template_context,\n RequestContext(request)\n )\n\n if is_raw:\n response['Content-Type'] = 'text/plain;charset=UTF-8'\n response['X-Content-Type-Options'] = 'nosniff'\n return response\n else:\n return response","def get_snippet(dockey, baseurl, timeout):\n try:\n url = baseurl + \"/raw/\" + dockey\n response = requests.get(url, timeout=float(timeout))\n except requests.exceptions.Timeout:\n exit(\"Error: connection timed out\")\n\n return response.text","def examine_document(self, snippet):\n\n if self.documents_examined < len(snippet):\n snippet = snippet[self.documents_examined]\n screen = self.driver.perform_action((20, snippet))\n self.documents_examined = self.documents_examined + 1\n\n return screen\n else:\n self.driver.perform_action((00, None))\n return None","def _get_source(self, uri: str) -> Optional[_Source]:\n\n for source in self._sources:\n if uri == source.uri:\n return source\n\n return None","def get_entry(title):\n try:\n f = default_storage.open(f\"entries/{title}.md\")\n data = f.read()\n markdowner = Markdown()\n html = markdowner.convert(data)\n return html\n except FileNotFoundError:\n return None","def snippet_delete(request, snippet_id=None):\n snippet_id = snippet_id or request.POST.get('snippet_id')\n if not snippet_id:\n raise Http404('No snippet id given')\n snippet = get_object_or_404(Snippet, secret_id=snippet_id)\n snippet.delete()\n return HttpResponseRedirect(reverse('snippet_new'))","def snippet_detail(request, pk):\n try:\n snippet = Quickstart.objects.get(pk=pk)\n except Quickstart.DoesNotExist:\n return HttpResponse(status=404)\n\n if request.method == 'GET':\n serializer = QuickstartSerializer(snippet)\n return JsonResponse(serializer.data)\n\n elif request.method == 'PUT':\n data = JSONParser().parse(request)\n serializer = QuickstartSerializer(snippet, data=data)\n if serializer.is_valid():\n serializer.save()\n return JsonResponse(serializer.data)\n return JsonResponse(serializer.errors, status=400)\n\n elif request.method == 'DELETE':\n quickstart.delete()\n return HttpResponse(status=204)","def visit_snippet_literal(self, node):\n self.visit_literal_block(node)","def _get_output_snippet(path, beam, snippet_name):\n snippet = getattr(madx_snippets, snippet_name)\n ids = IDS.copy()\n\n return {out: snippet(path, \"b{:d}.{:s}\".format(beam, ids[out]))\n for out in ids.keys()}","def get_for_language(self, language):\r\n assert isinstance(language, str)\r\n\r\n language = language.strip().lower()\r\n if language in self.__languages:\r\n code = self.__languages[language]\r\n return code\r\n return None","def get_movie_snippet(doc_id, data):\n doc_id = str(doc_id)\n return doc_id, data[doc_id]['Title'][0], data[doc_id]['Text'][:300]+'......'","def extract_metadata(parser_config, snippet):\n return parser_config['implementation'](snippet)","def getItem(self) -> Optional[items.Item]:\n return None if self.__itemRef is None else self.__itemRef()","def getSourceForId(context, identifier):\n nearest = getattr(context, identifier, None)\n if IExternalSource.providedBy(nearest):\n return nearest\n return None","def snippetDetail(requeset, pk, format = None):","def get_by_slug(self, slug):\n return self.get(slug=slug)","def getSkill(self, skillName):\r\n if self.__contains__(skillName):\r\n return self.skills[skillName]\r\n return None","async def snippet(command, app):\n response = Message()\n response[\"channel\"] = command[\"channel_id\"]\n response[\"unfurl_links\"] = False\n\n response[\"text\"] = (\n \"Please use the snippet feature, or backticks, when sharing code. \\n\"\n \"To include a snippet, click the :paperclip: on the left and hover over \"\n \"`Create new...` then select `Code or text snippet`.\\n\"\n \"By wrapping the text/code with backticks (`) you get:\\n\"\n \"`text formatted like this`\\n\"\n \"By wrapping a multiple line block with three backticks (```) you can get:\\n\"\n )\n\n await app.plugins[\"slack\"].api.query(url=methods.CHAT_POST_MESSAGE, data=response)\n\n response[\"text\"] = (\n \"```\\n\"\n \"A multiline codeblock\\nwhich is great for short snippets!\\n\"\n \"```\\n\"\n \"For more information on snippets, click \"\n \"<https://get.slack.help/hc/en-us/articles/204145658-Create-a-snippet|here>.\\n\"\n \"For more information on inline code formatting with backticks click \"\n \"<https://get.slack.help/hc/en-us/articles/202288908-Format-your-messages#inline-code|here>.\"\n )\n\n await app.plugins[\"slack\"].api.query(url=methods.CHAT_POST_MESSAGE, data=response)","def get_source(self) -> Optional[str]:\n return self._source","def test_render_snippet_id(self):\n template = SnippetTemplateFactory(code='<p>{{ snippet_id }}</p>')\n eq_(template.render({'myvar': 'foo'}), '<p>0</p>')","def snippets_by_language(request, slug):\n language = get_object_or_404(Language, slug__exact=slug)\n return list_detail.object_list(request,\n queryset=Snippet.objects.get_by_language(slug),\n extra_context={ 'object': language },\n template_name='cab/language_detail.html',\n **base_generic_dict)","def get_question(self, id):\n\t\tif id < len(self.questions) and id >= 0:\n\t\t\treturn self.questions[id]\n\t\telse:\n\t\t\treturn None","def snippet(self, source, *args, **kwds):\n tables = {\"directives\" : self.directives, **self.tables, **kwds}\n return c_snippet(source, *args, **tables)","def get_product_by_slug(self, slug):\n return self.get_products({ 'review_url': slug })[0]","def get_headline(id_headline):\n try:\n item = db.get_item(id_headline)[0]\n return item\n except (ValueError, IndexError):\n return \"Not found\", 404, {\"x-error\": \"not found\"}","def get_piece(self, addr: str) -> Optional[\"Piece\"]:\n piece = self.get_pos(addr).piece\n if isinstance(piece, Piece):\n return piece\n else:\n return None","async def fetch_bitbucket_snippet(session, repo, ref, file_path, start_line, end_line):\n\n file_contents = await fetch_http(\n session,\n f'https://bitbucket.org/{quote_plus(repo)}/raw/{quote_plus(ref)}/{quote_plus(file_path)}',\n 'text',\n )\n\n return await snippet_to_embed(file_contents, file_path, start_line, end_line)","def getItemByCode(self, code):\n try:\n PATH = os.path.dirname(os.path.realpath(__file__))\n DATABASE = os.path.join(PATH, '..', 'db', 'store.db')\n conn = sqlite3.connect(DATABASE)\n c = conn.cursor()\n c.execute('SELECT * FROM ITEMS WHERE CODE=?', (code,))\n row = c.fetchone()\n while True:\n if row == None:\n return None\n else:\n return row\n except sqlite3.Error as e:\n print(\"An error occurred while retrieving Item: \", e.args[0])\n return None\n finally:\n c.close()\n conn.close()","def edit_snippet(request, snippet_id):\n snippet = get_object_or_404(Snippet,\n pk=snippet_id,\n author__pk=request.user.id)\n if request.method == 'POST':\n form = forms.EditSnippetForm(request.POST, instance=snippet)\n if form.is_valid():\n form.save()\n return HttpResponseRedirect(snippet.get_absolute_url())\n else:\n form = forms.EditSnippetForm(instance=snippet)\n return render_to_response('cab/edit_snippet_form.html',\n { 'form': form,\n 'original': snippet },\n context_instance=RequestContext(request))","def get_minknow_sample_id(art):\n\n sample_id_pattern = re.compile(\"(P\\d{5})_(\\d+)\")\n\n # Single sample\n if len(art.samples) == 1:\n re_match = re.match(sample_id_pattern, art.samples[0].name)\n if re_match:\n return re_match.group()\n else:\n return None\n\n # Pool\n else:\n # Look at the name of the first sample in the pool\n re_match = re.match(sample_id_pattern, art.samples[0].name)\n # If all samples in the pool have the same project\n if all(\n [\n re.match(sample_id_pattern, sample.name).groups()[0]\n == re_match.groups()[0]\n for sample in art.samples\n ]\n ):\n return f\"{re_match.groups()[0]}_{art.id}\"\n else:\n return art.id","def get_slug_in_language(record, language):\n if not record or not hasattr(record, \"safe_translation_getter\"):\n return None\n return record.safe_translation_getter(\n field=\"slug\", language_code=language, default=None, )","def get_first_lesson(module):\n try:\n return get_all_lessons(module)[0]\n except IndexError:\n return None","def get_item_from_modulestore(usage_key, draft=False):\r\n store = modulestore('draft') if draft else modulestore('direct')\r\n return store.get_item(usage_key)","def get_by_uuid(self, uuid):\n\n result_filter = [r for r in self.content if r.uuid() == uuid]\n\n try:\n return result_filter[0]\n except IndexError:\n return None","def find_sample_from_filename(fn):\n # type: (str) -> str\n for k in PURITY_DICT.keys():\n if fn.find(k) != -1:\n return k\n return None","def get_post_or_page(slug=None, id=None):\n if id:\n try:\n return Post.objects.public().get(id=id)\n except Post.DoesNotExist:\n pass\n\n elif slug:\n try:\n return Post.objects.public().get(slug=slug)\n except Post.DoesNotExist:\n pass\n\n return ''","def snippet_detail_apiview(request, pk, format=None):\n try:\n snippet = Snippet.objects.get(pk=pk)\n except Snippet.DoesNotExist:\n return Response(status=status.HTTP_404_NOT_FOUND)\n\n if request.method == 'GET':\n serializer = SnippetSerializer(snippet, context={'request': request})\n return Response(serializer.data)\n\n elif request.method == 'PUT':\n serializer = SnippetSerializer(snippet, data=request.data, context={'request': request})\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data)\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\n\n elif request.method == 'DELETE':\n snippet.delete()\n return Response(status=status.HTTP_204_NO_CONTENT)","def get_source(self) -> Optional[SourceIdentifierParameter]:\n return self.get_param_by_type(SourceIdentifierParameter)","def code(self) -> Optional[str]:\n return pulumi.get(self, \"code\")","def code(self) -> Optional[str]:\n return pulumi.get(self, \"code\")","def code(self) -> Optional[str]:\n return pulumi.get(self, \"code\")","def code(self) -> Optional[str]:\n return pulumi.get(self, \"code\")","def get_synopsis(file_data):\n for individual in file_data:\n if 'synopsis' in individual:\n synopsis = individual.split('\"')\n return synopsis[1]","def create_snippet(self, doc, spdx_id):\n self.reset_snippet()\n spdx_id = spdx_id.split('#')[-1]\n if validations.validate_snippet_spdx_id(spdx_id):\n doc.add_snippet(snippet.Snippet(spdx_id=spdx_id))\n self.snippet_spdx_id_set = True\n return True\n else:\n raise SPDXValueError('Snippet::SnippetSPDXID')","def get_sample(self, sample_name):\n samples = self.get_samples([sample_name])\n if len(samples) > 1:\n _LOGGER.warning(\"More than one sample was detected; \"\n \"returning the first\")\n try:\n return samples[0]\n except IndexError:\n raise ValueError(\"Project has no sample named {}.\"\n .format(sample_name))","def get(name: str):\n if name not in Replacements._rep:\n return None\n return Replacements._rep[name]","def get_source(self, source_name: str) -> Optional[Tag]:\n # sanitize the name, this will also add index if there isn't one\n source_name, *_ = Tags._sanitize_tag(source_name, 0, 0)\n return next(self.tags.filter(name=source_name, valid=None), None)","def fetch(cls, slug):\n try:\n article = Article.objects.get(slug=slug)\n except Article.DoesNotExist:\n raise exceptions.NotFound(f'Article with slug {slug} nonexistent')\n else:\n return article","def fetch(cls, slug):\n try:\n article = Article.objects.get(slug=slug)\n except Article.DoesNotExist:\n raise exceptions.NotFound(f'Article of slug {slug} nonexistent')\n else:\n return article","def snippet_gist(request, snippet_id): # pragma: no cover\n snippet = get_object_or_404(Snippet, secret_id=snippet_id)\n data = {\n 'description': getattr(settings, 'DPASTE_DEFAULT_GIST_DESCRIPTION', ''),\n 'public': False,\n 'files': {\n getattr(settings, 'DPASTE_DEFAULT_GIST_NAME', 'dpaste.de_snippet.py'): {\n 'content': snippet.content,\n }\n }\n }\n\n try:\n payload = json.dumps(data)\n response = requests.post('https://api.github.com/gists', data=payload)\n response_dict = response.json()\n gist_url = response_dict.get('html_url')\n\n # Github could be down, could return invalid JSON, it's rare\n except:\n return HttpResponse('Creating a Github Gist failed. Sorry, please go back and try again.')\n\n return HttpResponseRedirect(gist_url)","def get_item_description(item_slug):\n return session.query(\n Items.description).filter_by(\n slug=item_slug).first()[0]","def _get_scripts_resource(pe):\n return next(\n (\n entry.directory.entries[0].directory.entries[0]\n for entry in pe.DIRECTORY_ENTRY_RESOURCE.entries\n if entry.name and entry.name.string == b\"PYTHONSCRIPT\"\n ),\n None,\n )","def _CreateSnippet(self, content):\r\n content = re.sub('</?[^>/]+/?>', '', content)\r\n if len(content) < 50:\r\n return content\r\n return content[0:49] + '...'","def dummy_movie_snippet(doc_id):\n with open('2018_movies.json') as f:\n doc = json.load(f)\n doc_file = doc[doc_id]\n s = doc_file['Text'][:100] + \"......\"\n return (doc_id, doc_file['Title'], s)","def _getValue(self, field):\n if self._contents.has_key(field):\n return self._contents[field]\n else:\n return None","def get(self, _id):\n try:\n doc = self._db[_id]\n # For speed testing\n del self._db[_id]\n except KeyError:\n return None\n else:\n return self._parse_doc(doc)","def GetSource(self, unused_node):\n if self.matched_text is None:\n return self.default\n return self.matched_text","def get_line(self, path, line):\n\t\tlines = self.find_source(path)\n\t\tif lines == None:\n\t\t\treturn None\n\t\telse:\n\t\t\ttry:\n\t\t\t\treturn lines[line - 1]\n\t\t\texcept IndexError:\n\t\t\t\treturn None","def sample(self, sample_id: str):\n\n class LimsSample:\n \"\"\" A mock class for a sample coming from LIMS. It only needs a comment \"\"\"\n\n def __init__(self, sample_id):\n self.sample_id = sample_id\n self.sample_data = {\"comment\": \"a comment in LimsSample\"}\n\n def get(self, key):\n \"\"\" only here to get the sample.get('comment') \"\"\"\n return self.sample_data.get(key, \"not found\")\n\n # haha, it's a factory!\n if not self.lims_sample:\n self.lims_sample = LimsSample(sample_id)\n\n return self.lims_sample","def get_item(self, name: str) -> Optional[Item]:\n item = self.filter_items(name, limit=1)\n return item[0] if item else None","def get_context(self):\n uuid = self.data.get('uuid', None)\n if uuid is None:\n return\n item = ploneapi.content.get(UID=uuid)\n return item","def put(name, snippet):\n # commenting the 3 lines below in order to try and refactor the put method to use context managers\n # logging.info(\"Storing snippet {!r}: {!r}\".format(name, snippet))\n # cursor = connection.cursor()\n # command = \"insert into snippets values (%s, %s)\"\n with connection, connection.cursor() as cursor:\n cursor.execute(\"store snippets where values=%s\", (snippet,))\n\n \n try:\n command = \"insert into snippets values (%s, %s)\"\n cursor.execute(command, (name, snippet))\n except psycopg2.IntegrityError as e:\n connection.rollback()\n command = \"update snippets set message=% where keyword=%s\"\n cursor.execute(command, (snippet, name))\n connection.commit()\n logging.debug(\"Snippet stored successfully.\")\n return name, snippet","def get_text(item_id):\n if item_id in all_items:\n return all_items[item_id]['text']\n return None","def get_course_title_only(code):\n coursepage = get_coursepage(code)\n soup = BeautifulSoup(coursepage.content, 'lxml')\n title = [soup.find_all('h1')[2].string][0]\n return title","def __getitem__(self, name):\n tag = self._find(name)\n if tag is not None:\n return tag.text\n raise KeyError(name)","def get1(node: md.Document, name: str) -> md.Element | None:\n s = get(node, name)\n if s:\n return s[0]\n else:\n return None","def _get_locator_from_cache(self, location, published):\r\n entry = self.cache.get(u'{}+{}'.format(location.course_key, location))\r\n if entry is not None:\r\n if published:\r\n return entry[0]\r\n else:\r\n return entry[1]\r\n return None","def get_product(self, identifier):\n # try to find an id corresponding to the code\n for p in self['products']:\n if identifier in p.get('ids', []):\n return p\n # if no product associated with the code found, return None\n return None","def add_snippet(request):\n original_id = request.GET.get('oid', None)\n \n if request.method == 'POST':\n form = forms.AddSnippetForm(request.POST)\n if form.is_valid():\n new_snippet = form.save(commit=False)\n new_snippet.author = request.user\n if original_id:\n new_snippet.original_id = original_id\n new_snippet.save()\n return HttpResponseRedirect(new_snippet.get_absolute_url())\n else:\n form = forms.AddSnippetForm()\n return render_to_response('cab/add_snippet_form.html',\n { 'form': form },\n context_instance=RequestContext(request))","def extract_gateway_template(\n templates: Dict[str, Any], namespace: Optional[str], purpose: str,\n) -> Optional[str]:\n for gateway_template in templates['gateway-templates']:\n if (\n gateway_template['namespace'] == namespace\n and gateway_template['purpose'] == purpose\n ):\n ret = gateway_template['template']\n assert isinstance(ret, str)\n return ret\n return None","def get_lookup_pepper(self) -> Optional[str]:\n\n if self._cached_lookup_pepper is not None:\n return self._cached_lookup_pepper\n\n cur = self.sydent.db.cursor()\n res = cur.execute(\"select lookup_pepper from hashing_metadata\")\n # Annotation safety: lookup_pepper is marked as varchar(256) in the\n # schema, so could be null. I.e. `row` should strictly be\n # Optional[Tuple[Optional[str]].\n # But I think the application code is such that either\n # - hashing_metadata contains no rows\n # - or it contains exactly one row with a nonnull lookup_pepper.\n row: Optional[Tuple[str]] = res.fetchone()\n\n if not row:\n return None\n\n pepper = row[0]\n\n # Ensure we're dealing with unicode.\n if isinstance(pepper, bytes):\n pepper = pepper.decode(\"UTF-8\")\n\n self._cached_lookup_pepper = pepper\n\n return pepper","def parse_snippet(self, ultisnip_file: Path) -> dict:\n snippets_dictionary = {}\n with open(ultisnip_file, \"r\") as f:\n for line in f:\n if line.startswith(\"snippet\"):\n snippet = {}\n prefix = line.split()[1].strip()\n snippet[\"prefix\"] = prefix\n if '\"' in line:\n snippet_name = line.split('\"')[1].strip()\n snippet[\"description\"] = snippet_name\n body = []\n line = next(f)\n while not line.startswith(\"endsnippet\"):\n body.append(self._replace_variables(line.strip(\"\\n\")))\n line = next(f)\n snippet[\"body\"] = body\n snippets_dictionary[prefix] = snippet\n return snippets_dictionary","def get_show_with_slug(self, slug: str) -> int:\n shows = self.show_source.show_names\n show_slugs = \\\n {\n self.sluggify(name): show\n for name, show in shows.items()\n }\n try:\n return show_slugs[slug]\n except KeyError as e:\n raise NoSuchShowError from e","def pollution_scenario(pollution, injection):\n try:\n return pollution[injection]\n except KeyError:\n error = \"Can't find .pkl file for pollution injection at \" + injection\n raise KeyError(error)","def get_fragment(self, fragment_id):\n if self.fragment_dict.has_key(fragment_id):\n return self.fragment_dict[fragment_id]\n return None","def get_subreddit_translation(subreddit, bible_section):\n\n if bible_section == \"Old Testament\":\n section = \"ot_default\"\n elif bible_section == \"New Testament\":\n section = \"nt_default\"\n else:\n section = \"deut_default\"\n with _conn.cursor() as cur:\n cur.execute(\"SELECT %s FROM subreddit_translations WHERE sub = '%s';\" % (section, subreddit.lower()))\n try:\n trans = cur.fetchone()[0]\n return trans\n except (psycopg2.ProgrammingError, TypeError) as e:\n return None","def get_raw_secret_from_file(\n secret: PotentialSecret,\n line_getter_factory: Callable[[str], 'LineGetter'] = open_file,\n) -> Optional[str]:\n if not secret.line_number:\n raise NoLineNumberError\n\n for item in get_raw_secrets_from_file(secret, line_getter_factory):\n return item.secret_value\n\n raise SecretNotFoundOnSpecifiedLineError(secret.line_number)","def load_post_synopsis_by_id(self, id):\n post_synopsis = None\n posts = self.session.query(PostSynopsis).filter(PostSynopsis.id == id).all()\n if len(posts) > 0:\n post_synopsis = posts[0]\n return post_synopsis","def source(self) -> Optional[str]:\n return pulumi.get(self, \"source\")","def pysnippet(self, code, lineno=1, colno=None, extralines=3, line_numbers=True):\n with self._lock:\n if not code:\n return\n if colno is not None:\n highlight_columns = (colno - 1, colno)\n else:\n highlight_columns = None\n _lineno = max(0, lineno - extralines)\n\n highlighter = PythonHighlighter()\n\n self.snippet(\n code,\n (_lineno, _lineno + extralines * 2 + 1),\n highlight_line=lineno,\n highlight_columns=highlight_columns,\n line_numbers=True,\n highlighter=highlighter,\n )\n return self","def _get_source(self, source_id):\n logging.debug(\"Getting entity for source_id %s\", source_id)\n if self.trace.has_item(source_id):\n return self.trace.get_item(source_id)\n\n source_components = source_id.split('/')\n if len(source_components) not in [2, 4]:\n logging.error(\n \"Expecting source with either 2 or 4 components, got %s\",\n source_id)\n return None\n\n if not re.match(\"[0-9]+\", source_components[0]):\n logging.error(\n \"Expecting source beginning with item ID, got %s\",\n source_components[0])\n return None\n\n if len(source_components) == 2:\n source_item_id = source_components[0]\n well = source_components[1]\n\n pattern = r\"\\[\\[([0-9]+),[ \\t]*([0-9]+)\\]\\]\"\n match = re.match(pattern, source_components[1])\n if match:\n well = well_coordinates(int(match[1]), int(match[2]))\n\n elif len(source_components) == 4:\n source_item_id = source_components[1]\n well = source_components[3]\n\n source_item_entity = self.factory.get_item(item_id=source_item_id)\n\n if not source_item_entity.is_collection():\n msg = \"Ignoring source part %s from non-collection %s\"\n logging.info(msg, well, source_item_id)\n return source_item_entity\n\n source_part_entity = self.factory.get_part(\n collection=source_item_entity,\n well=well\n )\n\n return source_part_entity","def FindHalDescription(hal_desc, hal_package_name):\n for hal_full_name in hal_desc:\n if hal_desc[hal_full_name].hal_name == hal_package_name:\n return hal_desc[hal_full_name]\n return None","def find_yelp_item (topic, location, k):\n import re\n if k < 1: return None\n \n # Download page\n url_command = 'http://yelp.com/search'\n url_args = {'find_desc': topic,\n 'find_loc': location,\n 'start': k-1\n }\n \n response = requests.get (url_command, params=url_args)\n if not response: return None\n \n # Split page into lines\n lines = response.text.split ('\\n')\n \n # Look for the line containing the name of the k-th item\n item_pattern = re.compile ('<span class=\"indexed-biz-name\">{}\\..*<span >(?P<item_name>.*)</span></a>'.format (k))\n for l in lines:\n item_match = item_pattern.search (l)\n if item_match:\n return item_match.group ('item_name')\n\n # No matches, evidently\n return None","def test_render_no_snippet_id(self):\n snippet = SnippetFactory.build(template__code='<p>{{ snippet_id }}</p>')\n snippet.template.render = Mock()\n snippet.render()\n snippet.template.render.assert_called_with({'snippet_id': 0})"],"string":"[\n \"def get_snippet(self, title=None):\\n for snippet in self.snippets:\\n if snippet[\\\"title\\\"] == title:\\n return snippet\\n return None\",\n \"def get_snippet(res_type, snippet_name):\\n\\treturn get_settings_resource(res_type, snippet_name, 'snippets');\",\n \"def get(name):\\n # cursor = connection.cursor()\\n # command = \\\"select message from snippets where keyword='%s'\\\"%name\\n # cursor.execute(command)\\n # connection.commit()\\n # message_tuple=cursor.fetchone()\\n \\n with connection, connection.cursor() as cursor:\\n cursor.execute(\\\"select message from snippets where keyword=%s\\\", (name,))\\n row = cursor.fetchone()\\n \\n if len(row)>0:\\n logging.debug(\\\"Get Snippet successfully.\\\")\\n return row[0]\\n else:\\n logging.debug(\\\"No Snippet got\\\")\\n return \\\"\\\"\",\n \"def get(name):\\n #retrieve the snippet from the db - commnet from session of nicole darcy\\n #i added the 'cursor= ' line because it said it was unused code, copied it from def put()\\n# commenting lines below to replace with new code as per class lesson\\n # cursor=connection.cursor()\\n # row = cursor.fetchone()\\n # connection.commit()\\n with connection, connection.cursor() as cursor:\\n cursor.execute(\\\"select message from snippets where keyword=%s\\\", (name,))\\n row = cursor.fetchone()\\n if not row:\\n #No snippet was found with that name.\\n return \\\"404: Snippet not Found\\\"\\n return row[0]\\n \\n # warning for 'unreachable code' so i commented it out...\\n # logging.error(\\\"FIXME: Unimplemented - get({!r})\\\".format(name))\\n # print(\\\"this function is running\\\",get.__name__)\\n # return \\\"\\\"\",\n \"def snippet(self) -> global___Snippet:\",\n \"def _load_snippet(filename) -> str:\\n fullpath = f'{dirname(__file__)}/js/{filename}'\\n file = open(fullpath, 'r')\\n script = file.read()\\n file.close()\\n return script\",\n \"def get_snippet(self):\\n return html_utils.strip_tags(self.html)[:120] + ' ...'\",\n \"def snippet_detail(request, pk):\\n try:\\n snippet = Snippet.objects.get(pk=pk)\\n except Snippet.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = SnippetSerializer(snippet)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = SnippetSerializer(snippet, data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n snippet.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def snippet_detail(request, pk):\\n try:\\n snippet = Snippet.objects.get(pk=pk)\\n except Snippet.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = SnippetSerializer(snippet)\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = SnippetSerializer(snippet, data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n snippet.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def snippet_detail(request, snippet_id):\\n snippet = get_object_or_404(Snippet, pk=snippet_id)\\n return render_to_response('cab/snippet_detail.html',\\n { 'object': snippet,\\n 'num_ratings': snippet.rating_set.count(),\\n 'rating_score': Rating.objects.score_for_snippet(snippet.id) },\\n context_instance=RequestContext(request))\",\n \"def snippet_detail(request, pk, format=None):\\r\\n try:\\r\\n snippet = Snippet.objects.get(pk=pk)\\r\\n except Snippet.DoesNotExist:\\r\\n return Response(status=status.HTTP_404_NOT_FOUND)\\r\\n\\r\\n if request.method == 'GET':\\r\\n serializer = SnippetSerializer(snippet)\\r\\n return Response(serializer.data)\\r\\n\\r\\n elif request.method == 'PUT':\\r\\n serializer = SnippetSerializer(snippet, data=request.data)\\r\\n if serializer.is_valid():\\r\\n serializer.save()\\r\\n return Response(serializer.data)\\r\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\r\\n\\r\\n elif request.method == 'DELETE':\\r\\n snippet.delete()\\r\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def get_entry(title):\\n try:\\n f = default_storage.open(f\\\"entries/{title}.md\\\")\\n return f.read().decode(\\\"utf-8\\\")\\n except FileNotFoundError:\\n return None\",\n \"def get_entry(title):\\n try:\\n f = default_storage.open(f\\\"entries/{title}.md\\\")\\n return f.read().decode(\\\"utf-8\\\")\\n\\n except FileNotFoundError:\\n return None\",\n \"def _get_description(li):\\n\\n sdiv = li.find(\\\"div\\\", attrs={\\\"class\\\": \\\"result__body\\\"})\\n if sdiv:\\n stspan = sdiv.find(\\\"a\\\", attrs={\\\"class\\\": \\\"result__snippet\\\"})\\n if stspan is not None:\\n # return stspan.text.encode(\\\"utf-8\\\").strip()\\n return stspan.text.strip()\\n else:\\n return None\",\n \"def visit_snippet(self, node):\\n lang = node[\\\"language\\\"]\\n linenos = node.get('linenos', False)\\n fname = node['filename']\\n highlight_args = node.get('highlight_args', {})\\n if 'language' in node:\\n # code-block directives\\n lang = node['language']\\n highlight_args['force'] = True\\n if 'linenos' in node:\\n linenos = node['linenos']\\n\\n def warner(msg):\\n self.builder.warn(msg, (self.builder.current_docname, node.line))\\n\\n highlighted = self.highlighter.highlight_block(node.rawsource, lang,\\n warn=warner,\\n linenos=linenos,\\n **highlight_args)\\n starttag = self.starttag(node, 'div', suffix='',\\n CLASS='highlight-%s snippet' % lang)\\n self.body.append(starttag)\\n self.body.append('<div class=\\\"snippet-filename\\\">%s</div>\\\\n''' % (fname,))\\n self.body.append(highlighted)\\n self.body.append('</div>\\\\n')\\n raise nodes.SkipNode\",\n \"def is_snippet(abbr, doc_type = 'html'):\\n\\treturn get_snippet(doc_type, abbr) and True or False\",\n \"def snippet_details(request, snippet_id, template_name='dpaste/snippet_details.html', is_raw=False):\\n snippet = get_object_or_404(Snippet, secret_id=snippet_id)\\n\\n # One time snippet get deleted if the view count matches our limit\\n if snippet.expire_type == Snippet.EXPIRE_ONETIME \\\\\\n and snippet.view_count >= ONETIME_LIMIT:\\n snippet.delete()\\n raise Http404()\\n\\n # Increase the view count of the snippet\\n snippet.view_count += 1\\n snippet.save()\\n\\n tree = snippet.get_root()\\n tree = tree.get_descendants(include_self=True)\\n\\n new_snippet_initial = {\\n 'content': snippet.content,\\n 'lexer': snippet.lexer,\\n }\\n\\n if request.method == \\\"POST\\\":\\n snippet_form = SnippetForm(\\n data=request.POST,\\n request=request,\\n initial=new_snippet_initial)\\n if snippet_form.is_valid():\\n new_snippet = snippet_form.save(parent=snippet)\\n url = new_snippet.get_absolute_url()\\n return HttpResponseRedirect(url)\\n else:\\n snippet_form = SnippetForm(\\n initial=new_snippet_initial,\\n request=request)\\n\\n template_context = {\\n 'snippet_form': snippet_form,\\n 'snippet': snippet,\\n 'lexers': LEXER_LIST,\\n 'lines': range(snippet.get_linecount()),\\n 'tree': tree,\\n 'wordwrap': snippet.lexer in LEXER_WORDWRAP and 'True' or 'False',\\n }\\n\\n response = render_to_response(\\n template_name,\\n template_context,\\n RequestContext(request)\\n )\\n\\n if is_raw:\\n response['Content-Type'] = 'text/plain;charset=UTF-8'\\n response['X-Content-Type-Options'] = 'nosniff'\\n return response\\n else:\\n return response\",\n \"def get_snippet(dockey, baseurl, timeout):\\n try:\\n url = baseurl + \\\"/raw/\\\" + dockey\\n response = requests.get(url, timeout=float(timeout))\\n except requests.exceptions.Timeout:\\n exit(\\\"Error: connection timed out\\\")\\n\\n return response.text\",\n \"def examine_document(self, snippet):\\n\\n if self.documents_examined < len(snippet):\\n snippet = snippet[self.documents_examined]\\n screen = self.driver.perform_action((20, snippet))\\n self.documents_examined = self.documents_examined + 1\\n\\n return screen\\n else:\\n self.driver.perform_action((00, None))\\n return None\",\n \"def _get_source(self, uri: str) -> Optional[_Source]:\\n\\n for source in self._sources:\\n if uri == source.uri:\\n return source\\n\\n return None\",\n \"def get_entry(title):\\n try:\\n f = default_storage.open(f\\\"entries/{title}.md\\\")\\n data = f.read()\\n markdowner = Markdown()\\n html = markdowner.convert(data)\\n return html\\n except FileNotFoundError:\\n return None\",\n \"def snippet_delete(request, snippet_id=None):\\n snippet_id = snippet_id or request.POST.get('snippet_id')\\n if not snippet_id:\\n raise Http404('No snippet id given')\\n snippet = get_object_or_404(Snippet, secret_id=snippet_id)\\n snippet.delete()\\n return HttpResponseRedirect(reverse('snippet_new'))\",\n \"def snippet_detail(request, pk):\\n try:\\n snippet = Quickstart.objects.get(pk=pk)\\n except Quickstart.DoesNotExist:\\n return HttpResponse(status=404)\\n\\n if request.method == 'GET':\\n serializer = QuickstartSerializer(snippet)\\n return JsonResponse(serializer.data)\\n\\n elif request.method == 'PUT':\\n data = JSONParser().parse(request)\\n serializer = QuickstartSerializer(snippet, data=data)\\n if serializer.is_valid():\\n serializer.save()\\n return JsonResponse(serializer.data)\\n return JsonResponse(serializer.errors, status=400)\\n\\n elif request.method == 'DELETE':\\n quickstart.delete()\\n return HttpResponse(status=204)\",\n \"def visit_snippet_literal(self, node):\\n self.visit_literal_block(node)\",\n \"def _get_output_snippet(path, beam, snippet_name):\\n snippet = getattr(madx_snippets, snippet_name)\\n ids = IDS.copy()\\n\\n return {out: snippet(path, \\\"b{:d}.{:s}\\\".format(beam, ids[out]))\\n for out in ids.keys()}\",\n \"def get_for_language(self, language):\\r\\n assert isinstance(language, str)\\r\\n\\r\\n language = language.strip().lower()\\r\\n if language in self.__languages:\\r\\n code = self.__languages[language]\\r\\n return code\\r\\n return None\",\n \"def get_movie_snippet(doc_id, data):\\n doc_id = str(doc_id)\\n return doc_id, data[doc_id]['Title'][0], data[doc_id]['Text'][:300]+'......'\",\n \"def extract_metadata(parser_config, snippet):\\n return parser_config['implementation'](snippet)\",\n \"def getItem(self) -> Optional[items.Item]:\\n return None if self.__itemRef is None else self.__itemRef()\",\n \"def getSourceForId(context, identifier):\\n nearest = getattr(context, identifier, None)\\n if IExternalSource.providedBy(nearest):\\n return nearest\\n return None\",\n \"def snippetDetail(requeset, pk, format = None):\",\n \"def get_by_slug(self, slug):\\n return self.get(slug=slug)\",\n \"def getSkill(self, skillName):\\r\\n if self.__contains__(skillName):\\r\\n return self.skills[skillName]\\r\\n return None\",\n \"async def snippet(command, app):\\n response = Message()\\n response[\\\"channel\\\"] = command[\\\"channel_id\\\"]\\n response[\\\"unfurl_links\\\"] = False\\n\\n response[\\\"text\\\"] = (\\n \\\"Please use the snippet feature, or backticks, when sharing code. \\\\n\\\"\\n \\\"To include a snippet, click the :paperclip: on the left and hover over \\\"\\n \\\"`Create new...` then select `Code or text snippet`.\\\\n\\\"\\n \\\"By wrapping the text/code with backticks (`) you get:\\\\n\\\"\\n \\\"`text formatted like this`\\\\n\\\"\\n \\\"By wrapping a multiple line block with three backticks (```) you can get:\\\\n\\\"\\n )\\n\\n await app.plugins[\\\"slack\\\"].api.query(url=methods.CHAT_POST_MESSAGE, data=response)\\n\\n response[\\\"text\\\"] = (\\n \\\"```\\\\n\\\"\\n \\\"A multiline codeblock\\\\nwhich is great for short snippets!\\\\n\\\"\\n \\\"```\\\\n\\\"\\n \\\"For more information on snippets, click \\\"\\n \\\"<https://get.slack.help/hc/en-us/articles/204145658-Create-a-snippet|here>.\\\\n\\\"\\n \\\"For more information on inline code formatting with backticks click \\\"\\n \\\"<https://get.slack.help/hc/en-us/articles/202288908-Format-your-messages#inline-code|here>.\\\"\\n )\\n\\n await app.plugins[\\\"slack\\\"].api.query(url=methods.CHAT_POST_MESSAGE, data=response)\",\n \"def get_source(self) -> Optional[str]:\\n return self._source\",\n \"def test_render_snippet_id(self):\\n template = SnippetTemplateFactory(code='<p>{{ snippet_id }}</p>')\\n eq_(template.render({'myvar': 'foo'}), '<p>0</p>')\",\n \"def snippets_by_language(request, slug):\\n language = get_object_or_404(Language, slug__exact=slug)\\n return list_detail.object_list(request,\\n queryset=Snippet.objects.get_by_language(slug),\\n extra_context={ 'object': language },\\n template_name='cab/language_detail.html',\\n **base_generic_dict)\",\n \"def get_question(self, id):\\n\\t\\tif id < len(self.questions) and id >= 0:\\n\\t\\t\\treturn self.questions[id]\\n\\t\\telse:\\n\\t\\t\\treturn None\",\n \"def snippet(self, source, *args, **kwds):\\n tables = {\\\"directives\\\" : self.directives, **self.tables, **kwds}\\n return c_snippet(source, *args, **tables)\",\n \"def get_product_by_slug(self, slug):\\n return self.get_products({ 'review_url': slug })[0]\",\n \"def get_headline(id_headline):\\n try:\\n item = db.get_item(id_headline)[0]\\n return item\\n except (ValueError, IndexError):\\n return \\\"Not found\\\", 404, {\\\"x-error\\\": \\\"not found\\\"}\",\n \"def get_piece(self, addr: str) -> Optional[\\\"Piece\\\"]:\\n piece = self.get_pos(addr).piece\\n if isinstance(piece, Piece):\\n return piece\\n else:\\n return None\",\n \"async def fetch_bitbucket_snippet(session, repo, ref, file_path, start_line, end_line):\\n\\n file_contents = await fetch_http(\\n session,\\n f'https://bitbucket.org/{quote_plus(repo)}/raw/{quote_plus(ref)}/{quote_plus(file_path)}',\\n 'text',\\n )\\n\\n return await snippet_to_embed(file_contents, file_path, start_line, end_line)\",\n \"def getItemByCode(self, code):\\n try:\\n PATH = os.path.dirname(os.path.realpath(__file__))\\n DATABASE = os.path.join(PATH, '..', 'db', 'store.db')\\n conn = sqlite3.connect(DATABASE)\\n c = conn.cursor()\\n c.execute('SELECT * FROM ITEMS WHERE CODE=?', (code,))\\n row = c.fetchone()\\n while True:\\n if row == None:\\n return None\\n else:\\n return row\\n except sqlite3.Error as e:\\n print(\\\"An error occurred while retrieving Item: \\\", e.args[0])\\n return None\\n finally:\\n c.close()\\n conn.close()\",\n \"def edit_snippet(request, snippet_id):\\n snippet = get_object_or_404(Snippet,\\n pk=snippet_id,\\n author__pk=request.user.id)\\n if request.method == 'POST':\\n form = forms.EditSnippetForm(request.POST, instance=snippet)\\n if form.is_valid():\\n form.save()\\n return HttpResponseRedirect(snippet.get_absolute_url())\\n else:\\n form = forms.EditSnippetForm(instance=snippet)\\n return render_to_response('cab/edit_snippet_form.html',\\n { 'form': form,\\n 'original': snippet },\\n context_instance=RequestContext(request))\",\n \"def get_minknow_sample_id(art):\\n\\n sample_id_pattern = re.compile(\\\"(P\\\\d{5})_(\\\\d+)\\\")\\n\\n # Single sample\\n if len(art.samples) == 1:\\n re_match = re.match(sample_id_pattern, art.samples[0].name)\\n if re_match:\\n return re_match.group()\\n else:\\n return None\\n\\n # Pool\\n else:\\n # Look at the name of the first sample in the pool\\n re_match = re.match(sample_id_pattern, art.samples[0].name)\\n # If all samples in the pool have the same project\\n if all(\\n [\\n re.match(sample_id_pattern, sample.name).groups()[0]\\n == re_match.groups()[0]\\n for sample in art.samples\\n ]\\n ):\\n return f\\\"{re_match.groups()[0]}_{art.id}\\\"\\n else:\\n return art.id\",\n \"def get_slug_in_language(record, language):\\n if not record or not hasattr(record, \\\"safe_translation_getter\\\"):\\n return None\\n return record.safe_translation_getter(\\n field=\\\"slug\\\", language_code=language, default=None, )\",\n \"def get_first_lesson(module):\\n try:\\n return get_all_lessons(module)[0]\\n except IndexError:\\n return None\",\n \"def get_item_from_modulestore(usage_key, draft=False):\\r\\n store = modulestore('draft') if draft else modulestore('direct')\\r\\n return store.get_item(usage_key)\",\n \"def get_by_uuid(self, uuid):\\n\\n result_filter = [r for r in self.content if r.uuid() == uuid]\\n\\n try:\\n return result_filter[0]\\n except IndexError:\\n return None\",\n \"def find_sample_from_filename(fn):\\n # type: (str) -> str\\n for k in PURITY_DICT.keys():\\n if fn.find(k) != -1:\\n return k\\n return None\",\n \"def get_post_or_page(slug=None, id=None):\\n if id:\\n try:\\n return Post.objects.public().get(id=id)\\n except Post.DoesNotExist:\\n pass\\n\\n elif slug:\\n try:\\n return Post.objects.public().get(slug=slug)\\n except Post.DoesNotExist:\\n pass\\n\\n return ''\",\n \"def snippet_detail_apiview(request, pk, format=None):\\n try:\\n snippet = Snippet.objects.get(pk=pk)\\n except Snippet.DoesNotExist:\\n return Response(status=status.HTTP_404_NOT_FOUND)\\n\\n if request.method == 'GET':\\n serializer = SnippetSerializer(snippet, context={'request': request})\\n return Response(serializer.data)\\n\\n elif request.method == 'PUT':\\n serializer = SnippetSerializer(snippet, data=request.data, context={'request': request})\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\\n\\n elif request.method == 'DELETE':\\n snippet.delete()\\n return Response(status=status.HTTP_204_NO_CONTENT)\",\n \"def get_source(self) -> Optional[SourceIdentifierParameter]:\\n return self.get_param_by_type(SourceIdentifierParameter)\",\n \"def code(self) -> Optional[str]:\\n return pulumi.get(self, \\\"code\\\")\",\n \"def code(self) -> Optional[str]:\\n return pulumi.get(self, \\\"code\\\")\",\n \"def code(self) -> Optional[str]:\\n return pulumi.get(self, \\\"code\\\")\",\n \"def code(self) -> Optional[str]:\\n return pulumi.get(self, \\\"code\\\")\",\n \"def get_synopsis(file_data):\\n for individual in file_data:\\n if 'synopsis' in individual:\\n synopsis = individual.split('\\\"')\\n return synopsis[1]\",\n \"def create_snippet(self, doc, spdx_id):\\n self.reset_snippet()\\n spdx_id = spdx_id.split('#')[-1]\\n if validations.validate_snippet_spdx_id(spdx_id):\\n doc.add_snippet(snippet.Snippet(spdx_id=spdx_id))\\n self.snippet_spdx_id_set = True\\n return True\\n else:\\n raise SPDXValueError('Snippet::SnippetSPDXID')\",\n \"def get_sample(self, sample_name):\\n samples = self.get_samples([sample_name])\\n if len(samples) > 1:\\n _LOGGER.warning(\\\"More than one sample was detected; \\\"\\n \\\"returning the first\\\")\\n try:\\n return samples[0]\\n except IndexError:\\n raise ValueError(\\\"Project has no sample named {}.\\\"\\n .format(sample_name))\",\n \"def get(name: str):\\n if name not in Replacements._rep:\\n return None\\n return Replacements._rep[name]\",\n \"def get_source(self, source_name: str) -> Optional[Tag]:\\n # sanitize the name, this will also add index if there isn't one\\n source_name, *_ = Tags._sanitize_tag(source_name, 0, 0)\\n return next(self.tags.filter(name=source_name, valid=None), None)\",\n \"def fetch(cls, slug):\\n try:\\n article = Article.objects.get(slug=slug)\\n except Article.DoesNotExist:\\n raise exceptions.NotFound(f'Article with slug {slug} nonexistent')\\n else:\\n return article\",\n \"def fetch(cls, slug):\\n try:\\n article = Article.objects.get(slug=slug)\\n except Article.DoesNotExist:\\n raise exceptions.NotFound(f'Article of slug {slug} nonexistent')\\n else:\\n return article\",\n \"def snippet_gist(request, snippet_id): # pragma: no cover\\n snippet = get_object_or_404(Snippet, secret_id=snippet_id)\\n data = {\\n 'description': getattr(settings, 'DPASTE_DEFAULT_GIST_DESCRIPTION', ''),\\n 'public': False,\\n 'files': {\\n getattr(settings, 'DPASTE_DEFAULT_GIST_NAME', 'dpaste.de_snippet.py'): {\\n 'content': snippet.content,\\n }\\n }\\n }\\n\\n try:\\n payload = json.dumps(data)\\n response = requests.post('https://api.github.com/gists', data=payload)\\n response_dict = response.json()\\n gist_url = response_dict.get('html_url')\\n\\n # Github could be down, could return invalid JSON, it's rare\\n except:\\n return HttpResponse('Creating a Github Gist failed. Sorry, please go back and try again.')\\n\\n return HttpResponseRedirect(gist_url)\",\n \"def get_item_description(item_slug):\\n return session.query(\\n Items.description).filter_by(\\n slug=item_slug).first()[0]\",\n \"def _get_scripts_resource(pe):\\n return next(\\n (\\n entry.directory.entries[0].directory.entries[0]\\n for entry in pe.DIRECTORY_ENTRY_RESOURCE.entries\\n if entry.name and entry.name.string == b\\\"PYTHONSCRIPT\\\"\\n ),\\n None,\\n )\",\n \"def _CreateSnippet(self, content):\\r\\n content = re.sub('</?[^>/]+/?>', '', content)\\r\\n if len(content) < 50:\\r\\n return content\\r\\n return content[0:49] + '...'\",\n \"def dummy_movie_snippet(doc_id):\\n with open('2018_movies.json') as f:\\n doc = json.load(f)\\n doc_file = doc[doc_id]\\n s = doc_file['Text'][:100] + \\\"......\\\"\\n return (doc_id, doc_file['Title'], s)\",\n \"def _getValue(self, field):\\n if self._contents.has_key(field):\\n return self._contents[field]\\n else:\\n return None\",\n \"def get(self, _id):\\n try:\\n doc = self._db[_id]\\n # For speed testing\\n del self._db[_id]\\n except KeyError:\\n return None\\n else:\\n return self._parse_doc(doc)\",\n \"def GetSource(self, unused_node):\\n if self.matched_text is None:\\n return self.default\\n return self.matched_text\",\n \"def get_line(self, path, line):\\n\\t\\tlines = self.find_source(path)\\n\\t\\tif lines == None:\\n\\t\\t\\treturn None\\n\\t\\telse:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\treturn lines[line - 1]\\n\\t\\t\\texcept IndexError:\\n\\t\\t\\t\\treturn None\",\n \"def sample(self, sample_id: str):\\n\\n class LimsSample:\\n \\\"\\\"\\\" A mock class for a sample coming from LIMS. It only needs a comment \\\"\\\"\\\"\\n\\n def __init__(self, sample_id):\\n self.sample_id = sample_id\\n self.sample_data = {\\\"comment\\\": \\\"a comment in LimsSample\\\"}\\n\\n def get(self, key):\\n \\\"\\\"\\\" only here to get the sample.get('comment') \\\"\\\"\\\"\\n return self.sample_data.get(key, \\\"not found\\\")\\n\\n # haha, it's a factory!\\n if not self.lims_sample:\\n self.lims_sample = LimsSample(sample_id)\\n\\n return self.lims_sample\",\n \"def get_item(self, name: str) -> Optional[Item]:\\n item = self.filter_items(name, limit=1)\\n return item[0] if item else None\",\n \"def get_context(self):\\n uuid = self.data.get('uuid', None)\\n if uuid is None:\\n return\\n item = ploneapi.content.get(UID=uuid)\\n return item\",\n \"def put(name, snippet):\\n # commenting the 3 lines below in order to try and refactor the put method to use context managers\\n # logging.info(\\\"Storing snippet {!r}: {!r}\\\".format(name, snippet))\\n # cursor = connection.cursor()\\n # command = \\\"insert into snippets values (%s, %s)\\\"\\n with connection, connection.cursor() as cursor:\\n cursor.execute(\\\"store snippets where values=%s\\\", (snippet,))\\n\\n \\n try:\\n command = \\\"insert into snippets values (%s, %s)\\\"\\n cursor.execute(command, (name, snippet))\\n except psycopg2.IntegrityError as e:\\n connection.rollback()\\n command = \\\"update snippets set message=% where keyword=%s\\\"\\n cursor.execute(command, (snippet, name))\\n connection.commit()\\n logging.debug(\\\"Snippet stored successfully.\\\")\\n return name, snippet\",\n \"def get_text(item_id):\\n if item_id in all_items:\\n return all_items[item_id]['text']\\n return None\",\n \"def get_course_title_only(code):\\n coursepage = get_coursepage(code)\\n soup = BeautifulSoup(coursepage.content, 'lxml')\\n title = [soup.find_all('h1')[2].string][0]\\n return title\",\n \"def __getitem__(self, name):\\n tag = self._find(name)\\n if tag is not None:\\n return tag.text\\n raise KeyError(name)\",\n \"def get1(node: md.Document, name: str) -> md.Element | None:\\n s = get(node, name)\\n if s:\\n return s[0]\\n else:\\n return None\",\n \"def _get_locator_from_cache(self, location, published):\\r\\n entry = self.cache.get(u'{}+{}'.format(location.course_key, location))\\r\\n if entry is not None:\\r\\n if published:\\r\\n return entry[0]\\r\\n else:\\r\\n return entry[1]\\r\\n return None\",\n \"def get_product(self, identifier):\\n # try to find an id corresponding to the code\\n for p in self['products']:\\n if identifier in p.get('ids', []):\\n return p\\n # if no product associated with the code found, return None\\n return None\",\n \"def add_snippet(request):\\n original_id = request.GET.get('oid', None)\\n \\n if request.method == 'POST':\\n form = forms.AddSnippetForm(request.POST)\\n if form.is_valid():\\n new_snippet = form.save(commit=False)\\n new_snippet.author = request.user\\n if original_id:\\n new_snippet.original_id = original_id\\n new_snippet.save()\\n return HttpResponseRedirect(new_snippet.get_absolute_url())\\n else:\\n form = forms.AddSnippetForm()\\n return render_to_response('cab/add_snippet_form.html',\\n { 'form': form },\\n context_instance=RequestContext(request))\",\n \"def extract_gateway_template(\\n templates: Dict[str, Any], namespace: Optional[str], purpose: str,\\n) -> Optional[str]:\\n for gateway_template in templates['gateway-templates']:\\n if (\\n gateway_template['namespace'] == namespace\\n and gateway_template['purpose'] == purpose\\n ):\\n ret = gateway_template['template']\\n assert isinstance(ret, str)\\n return ret\\n return None\",\n \"def get_lookup_pepper(self) -> Optional[str]:\\n\\n if self._cached_lookup_pepper is not None:\\n return self._cached_lookup_pepper\\n\\n cur = self.sydent.db.cursor()\\n res = cur.execute(\\\"select lookup_pepper from hashing_metadata\\\")\\n # Annotation safety: lookup_pepper is marked as varchar(256) in the\\n # schema, so could be null. I.e. `row` should strictly be\\n # Optional[Tuple[Optional[str]].\\n # But I think the application code is such that either\\n # - hashing_metadata contains no rows\\n # - or it contains exactly one row with a nonnull lookup_pepper.\\n row: Optional[Tuple[str]] = res.fetchone()\\n\\n if not row:\\n return None\\n\\n pepper = row[0]\\n\\n # Ensure we're dealing with unicode.\\n if isinstance(pepper, bytes):\\n pepper = pepper.decode(\\\"UTF-8\\\")\\n\\n self._cached_lookup_pepper = pepper\\n\\n return pepper\",\n \"def parse_snippet(self, ultisnip_file: Path) -> dict:\\n snippets_dictionary = {}\\n with open(ultisnip_file, \\\"r\\\") as f:\\n for line in f:\\n if line.startswith(\\\"snippet\\\"):\\n snippet = {}\\n prefix = line.split()[1].strip()\\n snippet[\\\"prefix\\\"] = prefix\\n if '\\\"' in line:\\n snippet_name = line.split('\\\"')[1].strip()\\n snippet[\\\"description\\\"] = snippet_name\\n body = []\\n line = next(f)\\n while not line.startswith(\\\"endsnippet\\\"):\\n body.append(self._replace_variables(line.strip(\\\"\\\\n\\\")))\\n line = next(f)\\n snippet[\\\"body\\\"] = body\\n snippets_dictionary[prefix] = snippet\\n return snippets_dictionary\",\n \"def get_show_with_slug(self, slug: str) -> int:\\n shows = self.show_source.show_names\\n show_slugs = \\\\\\n {\\n self.sluggify(name): show\\n for name, show in shows.items()\\n }\\n try:\\n return show_slugs[slug]\\n except KeyError as e:\\n raise NoSuchShowError from e\",\n \"def pollution_scenario(pollution, injection):\\n try:\\n return pollution[injection]\\n except KeyError:\\n error = \\\"Can't find .pkl file for pollution injection at \\\" + injection\\n raise KeyError(error)\",\n \"def get_fragment(self, fragment_id):\\n if self.fragment_dict.has_key(fragment_id):\\n return self.fragment_dict[fragment_id]\\n return None\",\n \"def get_subreddit_translation(subreddit, bible_section):\\n\\n if bible_section == \\\"Old Testament\\\":\\n section = \\\"ot_default\\\"\\n elif bible_section == \\\"New Testament\\\":\\n section = \\\"nt_default\\\"\\n else:\\n section = \\\"deut_default\\\"\\n with _conn.cursor() as cur:\\n cur.execute(\\\"SELECT %s FROM subreddit_translations WHERE sub = '%s';\\\" % (section, subreddit.lower()))\\n try:\\n trans = cur.fetchone()[0]\\n return trans\\n except (psycopg2.ProgrammingError, TypeError) as e:\\n return None\",\n \"def get_raw_secret_from_file(\\n secret: PotentialSecret,\\n line_getter_factory: Callable[[str], 'LineGetter'] = open_file,\\n) -> Optional[str]:\\n if not secret.line_number:\\n raise NoLineNumberError\\n\\n for item in get_raw_secrets_from_file(secret, line_getter_factory):\\n return item.secret_value\\n\\n raise SecretNotFoundOnSpecifiedLineError(secret.line_number)\",\n \"def load_post_synopsis_by_id(self, id):\\n post_synopsis = None\\n posts = self.session.query(PostSynopsis).filter(PostSynopsis.id == id).all()\\n if len(posts) > 0:\\n post_synopsis = posts[0]\\n return post_synopsis\",\n \"def source(self) -> Optional[str]:\\n return pulumi.get(self, \\\"source\\\")\",\n \"def pysnippet(self, code, lineno=1, colno=None, extralines=3, line_numbers=True):\\n with self._lock:\\n if not code:\\n return\\n if colno is not None:\\n highlight_columns = (colno - 1, colno)\\n else:\\n highlight_columns = None\\n _lineno = max(0, lineno - extralines)\\n\\n highlighter = PythonHighlighter()\\n\\n self.snippet(\\n code,\\n (_lineno, _lineno + extralines * 2 + 1),\\n highlight_line=lineno,\\n highlight_columns=highlight_columns,\\n line_numbers=True,\\n highlighter=highlighter,\\n )\\n return self\",\n \"def _get_source(self, source_id):\\n logging.debug(\\\"Getting entity for source_id %s\\\", source_id)\\n if self.trace.has_item(source_id):\\n return self.trace.get_item(source_id)\\n\\n source_components = source_id.split('/')\\n if len(source_components) not in [2, 4]:\\n logging.error(\\n \\\"Expecting source with either 2 or 4 components, got %s\\\",\\n source_id)\\n return None\\n\\n if not re.match(\\\"[0-9]+\\\", source_components[0]):\\n logging.error(\\n \\\"Expecting source beginning with item ID, got %s\\\",\\n source_components[0])\\n return None\\n\\n if len(source_components) == 2:\\n source_item_id = source_components[0]\\n well = source_components[1]\\n\\n pattern = r\\\"\\\\[\\\\[([0-9]+),[ \\\\t]*([0-9]+)\\\\]\\\\]\\\"\\n match = re.match(pattern, source_components[1])\\n if match:\\n well = well_coordinates(int(match[1]), int(match[2]))\\n\\n elif len(source_components) == 4:\\n source_item_id = source_components[1]\\n well = source_components[3]\\n\\n source_item_entity = self.factory.get_item(item_id=source_item_id)\\n\\n if not source_item_entity.is_collection():\\n msg = \\\"Ignoring source part %s from non-collection %s\\\"\\n logging.info(msg, well, source_item_id)\\n return source_item_entity\\n\\n source_part_entity = self.factory.get_part(\\n collection=source_item_entity,\\n well=well\\n )\\n\\n return source_part_entity\",\n \"def FindHalDescription(hal_desc, hal_package_name):\\n for hal_full_name in hal_desc:\\n if hal_desc[hal_full_name].hal_name == hal_package_name:\\n return hal_desc[hal_full_name]\\n return None\",\n \"def find_yelp_item (topic, location, k):\\n import re\\n if k < 1: return None\\n \\n # Download page\\n url_command = 'http://yelp.com/search'\\n url_args = {'find_desc': topic,\\n 'find_loc': location,\\n 'start': k-1\\n }\\n \\n response = requests.get (url_command, params=url_args)\\n if not response: return None\\n \\n # Split page into lines\\n lines = response.text.split ('\\\\n')\\n \\n # Look for the line containing the name of the k-th item\\n item_pattern = re.compile ('<span class=\\\"indexed-biz-name\\\">{}\\\\..*<span >(?P<item_name>.*)</span></a>'.format (k))\\n for l in lines:\\n item_match = item_pattern.search (l)\\n if item_match:\\n return item_match.group ('item_name')\\n\\n # No matches, evidently\\n return None\",\n \"def test_render_no_snippet_id(self):\\n snippet = SnippetFactory.build(template__code='<p>{{ snippet_id }}</p>')\\n snippet.template.render = Mock()\\n snippet.render()\\n snippet.template.render.assert_called_with({'snippet_id': 0})\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7803083","0.7509804","0.68043727","0.6783305","0.64907616","0.5895668","0.5698813","0.5681696","0.5681696","0.5670628","0.5629642","0.55866885","0.5575976","0.5484937","0.5417822","0.53710085","0.5361792","0.5350893","0.5321844","0.5257878","0.5215702","0.5203412","0.5199043","0.5137295","0.50727254","0.50598747","0.5055567","0.50322056","0.5023398","0.5015891","0.5012302","0.49736628","0.4969346","0.49572796","0.49492416","0.4943343","0.49420053","0.49412116","0.4935113","0.49235862","0.4905417","0.48841625","0.48583686","0.48543617","0.48306912","0.4823475","0.482064","0.4819738","0.4808271","0.48003626","0.47996005","0.47966418","0.47796252","0.47721744","0.47610104","0.47610104","0.47610104","0.47610104","0.4760928","0.47604197","0.47464693","0.4745483","0.4740227","0.4739617","0.47386646","0.4717397","0.47171202","0.47153354","0.47117293","0.47116366","0.46999255","0.46952623","0.4694542","0.46920025","0.46890455","0.46834385","0.46790534","0.46788365","0.46772245","0.4673561","0.4671946","0.46557814","0.46460804","0.46447694","0.4638803","0.46293637","0.46280533","0.46279514","0.4621577","0.46199843","0.4616918","0.46073562","0.46048138","0.46001998","0.4596877","0.45911065","0.45909062","0.45883298","0.4587021","0.45846272"],"string":"[\n \"0.7803083\",\n \"0.7509804\",\n \"0.68043727\",\n \"0.6783305\",\n \"0.64907616\",\n \"0.5895668\",\n \"0.5698813\",\n \"0.5681696\",\n \"0.5681696\",\n \"0.5670628\",\n \"0.5629642\",\n \"0.55866885\",\n \"0.5575976\",\n \"0.5484937\",\n \"0.5417822\",\n \"0.53710085\",\n \"0.5361792\",\n \"0.5350893\",\n \"0.5321844\",\n \"0.5257878\",\n \"0.5215702\",\n \"0.5203412\",\n \"0.5199043\",\n \"0.5137295\",\n \"0.50727254\",\n \"0.50598747\",\n \"0.5055567\",\n \"0.50322056\",\n \"0.5023398\",\n \"0.5015891\",\n \"0.5012302\",\n \"0.49736628\",\n \"0.4969346\",\n \"0.49572796\",\n \"0.49492416\",\n \"0.4943343\",\n \"0.49420053\",\n \"0.49412116\",\n \"0.4935113\",\n \"0.49235862\",\n \"0.4905417\",\n \"0.48841625\",\n \"0.48583686\",\n \"0.48543617\",\n \"0.48306912\",\n \"0.4823475\",\n \"0.482064\",\n \"0.4819738\",\n \"0.4808271\",\n \"0.48003626\",\n \"0.47996005\",\n \"0.47966418\",\n \"0.47796252\",\n \"0.47721744\",\n \"0.47610104\",\n \"0.47610104\",\n \"0.47610104\",\n \"0.47610104\",\n \"0.4760928\",\n \"0.47604197\",\n \"0.47464693\",\n \"0.4745483\",\n \"0.4740227\",\n \"0.4739617\",\n \"0.47386646\",\n \"0.4717397\",\n \"0.47171202\",\n \"0.47153354\",\n \"0.47117293\",\n \"0.47116366\",\n \"0.46999255\",\n \"0.46952623\",\n \"0.4694542\",\n \"0.46920025\",\n \"0.46890455\",\n \"0.46834385\",\n \"0.46790534\",\n \"0.46788365\",\n \"0.46772245\",\n \"0.4673561\",\n \"0.4671946\",\n \"0.46557814\",\n \"0.46460804\",\n \"0.46447694\",\n \"0.4638803\",\n \"0.46293637\",\n \"0.46280533\",\n \"0.46279514\",\n \"0.4621577\",\n \"0.46199843\",\n \"0.4616918\",\n \"0.46073562\",\n \"0.46048138\",\n \"0.46001998\",\n \"0.4596877\",\n \"0.45911065\",\n \"0.45909062\",\n \"0.45883298\",\n \"0.4587021\",\n \"0.45846272\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55412996"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":90583,"cells":{"query":{"kind":"string","value":"Returns a query for all the specified snippets."},"document":{"kind":"string","value":"def get_all(user_id, tag_text=None) -> Query:\n query = Snippet.query.filter_by(user_id=user_id)\n if tag_text:\n tag = Tag.query.filter_by(text=tag_text).first()\n tag_id = tag and tag.id\n query = query.join(tagged_snippets).filter_by(tag_id=tag_id)\n return query.order_by(Snippet.year.desc(), Snippet.week.desc())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getSnippets(self, folderpath):\n print(\"Getting snippets for {}\".format(folderpath))\n # s2q = self.helper.loadJson(os.path.join(folderpath, 'final',\n # 'subject2svoqueries.json'))\n queries = self.helper.loadCsv(\n folderpath+\"/final\", \"candidate_queries.csv\")\n fullPath = os.path.join(self.rootpath, folderpath)\n\n relevant = []\n for idx, query in enumerate(queries):\n print(\"Crawling query {} ...\".format(query[1]))\n googleSnippets = Information.GoogleSnippets(fullPath, query[0],\n idx, query[1])\n res = googleSnippets.start_crawl()\n relevant.append(res)\n time.sleep(random.randint(1, 11))\n # for topic in s2q:\n # relevant = []\n # for idx, t in enumerate(s2q[topic]):\n # # print(\"Searching for topic {} with query {}\".format(topic,\n # # query))\n # googleSnippets = Information.GoogleSnippets(fullPath, topic,\n # idx, t['query'])\n # res = googleSnippets.start_crawl()\n # relevant.append(res)\n # time.sleep(random.randint(1, 11))\n output_root = os.path.join(folderpath, 'final')\n self.helper.dumpJson(output_root, \"snippets.json\", relevant)\n # output_root = os.path.join(folderpath, 'final', 'snippets')\n # if not os.path.exists(output_root):\n # os.makedirs(output_root)\n # self.helper.dumpJson(output_root, \"snippets.json\", total_snippets)","def snippets(self):\n\n queries = []\n\n from tagged_document import TagQuery\n\n # start with a version of ourself that has no expanded snippets\n source_lines = self.cleaned_contents.split(\"\\n\")\n\n # the list of lines we're working with\n output_lines = []\n\n # default to working with files at the current state on disk; this\n # can change to specific refs when a // tag: instruction is\n # encountered in the document\n current_ref = WORKSPACE_REF\n\n tag_regex = re.compile(r\"$\\/\\/\\s*tag:?\\s*(.*)^\", flags=re.IGNORECASE)\n snip_regex = re.compile(r\"$\\/\\/\\s*tag:?\\s*(.*)^\", flags=re.IGNORECASE)\n\n for line in source_lines:\n output_lines.append(line)\n\n # change which tag we're looking at if we hit an instruction to\n # do so\n tag = tag_regex.match(line)\n\n if tag:\n current_ref = tag.groups(1).strip()\n\n # is this a snippet?\n snippet = snip_regex.match(line)\n if snippet:\n\n # figure out what tags we're supposed to be using here\n query_text = snippet.groups(1)\n\n # build the tag query from this\n query = TagQuery(query_text, ref=current_ref)\n\n queries.append(query)\n\n return queries","def snippet_list(request):\n if request.method == 'GET':\n snippets = Snippet.objects.all()\n serializer = SnippetSerializer(snippets, many=True)\n return Response(serializer.data)\n\n elif request.method == 'POST':\n serializer = SnippetSerializer(data=request.data)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def snippet_list(request):\n if request.method == 'GET':\n snippets = Snippet.objects.all()\n serializer = SnippetSerializer(snippets, many=True)\n return Response(serializer.data)\n\n elif request.method == 'POST':\n serializer = SnippetSerializer(data=request.data)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def get_all(self, q=None, limit=None):\r\n q = q or []\r\n\r\n if limit and limit < 0:\r\n raise ClientSideError(_(\"Limit must be positive\"))\r\n kwargs = _query_to_kwargs(q, storage.SampleFilter.__init__)\r\n f = storage.SampleFilter(**kwargs)\r\n return map(Sample.from_db_model,\r\n pecan.request.storage_conn.get_samples(f, limit=limit))","def query_all(self):\n return multisearch.queries.QueryAll().connect(self)","def snippet_list(request, format=None): # format=None: 데이터 형태에 대한 포맷정보가 붙는다.\r\n if request.method == 'GET':\r\n snippets = Snippet.objects.all()\r\n serializer = SnippetSerializer(snippets, many=True)\r\n return Response(serializer.data)\r\n\r\n elif request.method == 'POST':\r\n serializer = SnippetSerializer(data=request.data)\r\n if serializer.is_valid():\r\n serializer.save()\r\n return Response(serializer.data, status=status.HTTP_201_CREATED)\r\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def query_all():\n\tstudents = session.query(Student).all()\n\treturn students","def snippet_list(request):\n if request.method == 'GET':\n quickstart = Quickstart.objects.all()\n serializer = QuickstartSerializer(snippets, many=True)\n return JsonResponse(serializer.data, safe=False)\n\n elif request.method == 'POST':\n data = JSONParser().parse(request)\n serializer = QuickstartSerializer(data=data)\n if serializer.is_valid():\n serializer.save()\n return JsonResponse(serializer.data, status=201)\n return JsonResponse(serializer.errors, status=400)","def get_all(self, queries):\n return [self._unpack(x.ids) for x in self.server.select2([\n ttypes.SelectQuery(\n [ttypes.SelectOperation(\n operation_type=\\\n ttypes.SelectOperationType.SimpleQuery,\n term=self._query_term(*x)\n )\n ],\n ttypes.Page(self.page_length, -1)\n )\n for x in queries])]","def get_all():\n return SavedQuery.get_all()","def getSnippets(self, asDict=False):\n\t\t\n\t\titems = self.index\n\n\t\tif asDict:\n\t\t\tsnippets = {}\n\t\telse:\n\t\t\tsnippets = []\n\n\t\tfor item in items:\n\n\t\t\t\tif asDict:\n\t\t\t\t\tsnippets[item] = self.getSnippet(item)\n\t\t\t\telse:\n\t\t\t\t\tsnippets.append(self.getSnippet(item))\n\n\t\treturn snippets","def raw_as_qs(self, raw_query, params=()):\n cursor = connection.cursor()\n try:\n cursor.execute(raw_query, params)\n return self.filter(id__in=(x[0] for x in cursor))\n finally:\n cursor.close()","def make_webapp_per_sample_view_query():\n file_table_id, case_table_id, file_assoc_table_id, aliquot_table_id, study_table_id = get_mapping_table_ids()\n\n # todo change query after next file metadata pull\n return f\"\"\"\n SELECT DISTINCT fm.file_id, fa.case_id, ac.case_submitter_id, ac.sample_id, ac.sample_submitter_id, \n ac.sample_type, REPLACE(s.project_short_name, '_', '-') AS project_short_name, s.program_short_name, \n fm.file_type, fm.data_category, fm.experiment_type, \n fm.file_size, fm.file_format, fm.instrument, fm.file_name,\n REPLACE(fm.url, 'https://d3iwtkuvwz4jtf.cloudfront.net/', 's3://pdcdatastore/') AS file_name_key, \n fm.`access`\n FROM `{file_table_id}` fm\n JOIN `{file_assoc_table_id}` fa\n ON fm.file_id = fa.file_id\n JOIN `{aliquot_table_id}` ac\n ON fa.case_id = ac.case_id\n JOIN `{case_table_id}` cm\n ON ac.case_id = cm.case_id\n JOIN `{study_table_id}` s\n ON s.project_id = cm.project_id\n \"\"\"","def query(self, queries):\n final_result = []\n results = self.__return_query('query', queries)\n if results == None:\n return None\n else:\n if len(results) > 1:\n for result in results:\n final_result.append(result['data'])\n else:\n final_result = results\n return final_result","def get_queries() -> List[str]:\n\n logging.info(\"getting query files\")\n gcs = storage.Client(project=GCP_PROJECT)\n bucket = gcs.bucket(GCS_BUCKET)\n blobs = bucket.list_blobs(prefix='layered_gis')\n queries = {}\n for blob in blobs:\n blob_name = blob.name\n if '.sh' in blob_name:\n continue\n filename = blob_name.replace('layered_gis/', '')\n layer, _ = filename.split('/')\n sql_query = blob.download_as_string().decode('utf-8')\n full_query = queries.get(layer, '')\n if full_query:\n full_query += 'UNION ALL \\n'\n full_query += sql_query + '\\n'\n queries[layer] = full_query\n return queries.values()","def get_all_by_user_and_template(user_id, template_id):\n return SavedQuery.get_all_by_user_and_template(user_id, template_id)","def queries(self):\n request = Request(method=\"get\", endpoint=\"/query/current\")\n\n def response_handler(resp):\n if not resp.is_success:\n raise C8QLQueryListError(resp, request)\n return self._format_queries(resp.body)\n\n return self._execute(request, response_handler)","def get_all_of_experiment(self, experiment_name: str):\n query = (\n f\"SELECT * FROM {self.table_name} WHERE experiment_name='{experiment_name}'\"\n )\n c = self.db.cursor()\n c.execute(query)\n queries = c.fetchall()\n return queries","def getStars(queries, lcs_fold, query_path=None, progb_txt=\"Querying stars: \"):\n ORDINARY_QUERY_KEY = \"QUERY:\"\n\n stars = []\n for query in tqdm(queries, desc=progb_txt):\n query = query.strip()\n\n if query.startswith(ORDINARY_QUERY_KEY):\n stars += getStarsFromRemoteDb(\n query[len(ORDINARY_QUERY_KEY):], query_path)\n\n else:\n stars += getStarsFromFolder(query, lcs_fold)\n\n if not stars:\n raise QueryInputError(\"There no stars. Your query: %s\" % queries)\n\n return stars","def get_all(self, q=None, limit=None):\r\n q = q or []\r\n if limit and limit < 0:\r\n raise ClientSideError(_(\"Limit must be positive\"))\r\n kwargs = _query_to_kwargs(q, storage.SampleFilter.__init__)\r\n kwargs['meter'] = self.meter_name\r\n f = storage.SampleFilter(**kwargs)\r\n return [OldSample.from_db_model(e)\r\n for e in pecan.request.storage_conn.get_samples(f, limit=limit)\r\n ]","def query(self):\n query_url = self.get_query_url()\n logging.info('Querying: ' + query_url)\n json_data = request.urlopen(query_url).read().decode()\n logging.debug('Retrieved the following ' + json_data)\n response = json.loads(json_data)\n\n return self.get_docs_from_response(response)","def get_queryset(self):\n queryset = Snippet.objects.all()\n username = self.request.query_params.get('username', None)\n userqueryset = User.objects.all()\n users = userqueryset.filter(username=username)\n if users.count() != 0 and username is not None:\n queryset = queryset.filter(owner=users[0])\n return queryset\n return []","def get_all(self, *ids):","def getExampleQueries(self, selectedID = 0):\r\n return \"\"","def get_snippet_info_list(self):\n snippets = []\n for snippet in self.snippets:\n snippets.append([snippet[\"title\"], snippet[\"description\"]])\n return snippets","def author_queries(case, author):\n query_set = {\n \"0\": [],\n \"1\": [1],\n \"2\": [4,1],\n \"3\": [2,1],\n \"4\": [3,2,1],\n \"5\": [5,4,3,2,1],\n \"6\": [6,5,4,3,2,1]\n }\n qs = query_set[str(case)]\n query_list = []\n for q in qs:\n query_list.append(author_case_query(q, author))\n return query_list","def get_queryset(self):\n\n qs = SynonymList.objects.all()\n\n terms = self.request.query_params.get(\"q\", \"\")\n\n if terms:\n terms = self.request.query_params.get(\"q\", \"\")\n query = parse_query(remove_accents(terms))\n qs = qs.filter(search_vector_keywords_list=query).annotate(\n rank=SearchRank(F(\"search_vector_keywords_list\"), query)\n )\n\n qs = qs.order_by(\"name\").distinct()\n\n return qs","def sample_queries(self) -> Sequence['outputs.CodelessUiConnectorConfigPropertiesResponseSampleQueries']:\n return pulumi.get(self, \"sample_queries\")","def query_many(self, *q, read_as=None):\n raise NotImplementedError","def snippets_by_language(request, slug):\n language = get_object_or_404(Language, slug__exact=slug)\n return list_detail.object_list(request,\n queryset=Snippet.objects.get_by_language(slug),\n extra_context={ 'object': language },\n template_name='cab/language_detail.html',\n **base_generic_dict)","def query_items(self, request, params, payload):\n return util.ndb_query_from_values(self.model, params).fetch()","def queries(self):\n return self.__queries","def apply_special_queries(query, specials):\n for i in specials:\n query = FILTERS_LIST[i](specials[i], query)\n return query","def prepare_queries(self):\n self.log.info(\"preparing queries ...\")\n self.prepared_queries = {}\n self.prepared_query_to_str = {}\n initNs = {\"rdfs\": RDFApi.RDFS}\n get_classes = \"\"\"\n SELECT ?class\n WHERE {\n ?class rdf:type rdfs:Class .\n }\n \"\"\"\n self.add_prepared_query(\"get_classes\", get_classes, initNs)\n\n get_properties = \"\"\"\n SELECT ?property\n WHERE {\n ?property rdf:type rdf:Property .\n }\n \"\"\"\n self.add_prepared_query(\"get_properties\", get_properties, None)\n\n get_term_to_label = \"\"\"\n SELECT ?term ?label\n WHERE {\n ?term rdfs:label ?label\n }\n \"\"\"\n self.add_prepared_query(\"get_term_to_label\", get_term_to_label, initNs)\n\n get_term_to_desc = \"\"\"\n SELECT ?term ?desc\n WHERE {\n ?term rdfs:comment ?desc\n }\n \"\"\"\n self.add_prepared_query(\"get_term_to_desc\", get_term_to_desc, initNs)\n\n get_ancestors = \"\"\"\n SELECT ?class\n WHERE {\n ?subject rdfs:subClassOf* ?mid .\n ?mid rdfs:subClassOf* ?class .\n }\n group by ?class\n order by count(?mid)\n \"\"\"\n self.add_prepared_query(\"get_ancestors\", get_ancestors, initNs)","def get_queryset(self):\n queryset = TShirt.objects.all()\n code = self.request.query_params.get('code', None)\n if code is not None:\n queryset = queryset.filter(code=code)\n return queryset\n return []","def db_select_all(self):\n \n query = \"SELECT * FROM %s\" % PUBLICATIONS_TABLE\n with self.connection:\n c = self.connection.cursor()\n c.execute(query)\n return c.fetchall()","def get_queryset(self):\n queryset = Book.objects.all()\n title = self.request.query_params.get(\"title\", None)\n if title:\n queryset = queryset.filter(title__icontains=title)\n author = self.request.query_params.get(\"author\", None)\n if author:\n queryset = queryset.filter(author__icontains=author)\n publication_language = self.request.query_params.get(\n \"publication_language\", None\n )\n if publication_language:\n queryset = queryset.filter(\n publication_language__icontains=publication_language\n )\n publication_date_start = self.request.query_params.get(\n \"publication_date_start\", None\n )\n if publication_date_start:\n queryset = queryset.filter(publication_date__gte=publication_date_start)\n publication_date_end = self.request.query_params.get(\n \"publication_date_end\", None\n )\n if publication_date_end:\n queryset = queryset.filter(publication_date__lte=publication_date_end)\n return queryset","def snippet_list_apiview(request, format=None):\n if request.method == 'GET':\n snippets = Snippet.objects.all()\n serializer = SnippetSerializer(snippets, many=True, context={'request': request})\n return Response(serializer.data)\n\n elif request.method == 'POST':\n serializer = SnippetSerializer(data=request.data, context={'request': request})\n if serializer.is_valid():\n serializer.save(owner=request.user)\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def get_source_query(self) -> QuerySet:\n raise NotImplementedError","def snippetList(requeset, format = None):","def driver_queries(self) -> Iterable[Dict[str, str]]:\n return self.svc_queries","def search_samples():\n r = req('GET', SUB_API + 'search/samples', params=apply_search_filters())\n samples = []\n for sample in demisto.get(r.json(), 'data.items'):\n samples.append({\n 'ID': demisto.get(sample, 'result'),\n 'Details': demisto.get(sample, 'details')\n })\n demisto.results({\n 'Type': entryTypes['note'],\n 'EntryContext': {'ThreatGrid.Sample': samples},\n 'HumanReadable': tableToMarkdown('ThreatGrid - Sample Search', samples, ['Result', 'Details']),\n 'ContentsFormat': formats['json'],\n 'Contents': r.json()\n })","def select_all_from_students_db(connection):\r\n with connection:\r\n r = connection.execute(GET_ALL_STUDENTS)\r\n return r.fetchall()","def get_qs(self):\n if self.qs == None:\n # Get the Lemma PKs\n qs = self.get_queryset()\n else:\n qs = self.qs\n return qs","def get_qs(self):\n if self.qs == None:\n # Get the Lemma PKs\n qs = self.get_queryset()\n else:\n qs = self.qs\n return qs","def generate_query(self):\n return","def get_all(self, lang: str = None):\n pass","def query(self, queries):\n times = []\n for q in queries:\n # print(\"Starting \" + q)\n t_start = time.time()\n self.solr.search(\"text:\" + q, rows=self.n_rows)\n times.append(time.time()-t_start)\n return {\"times_query\": np.mean(times)}","def Mime_Query_All(mimes):\n split_mimes = mimes.split(\",\")\n for mime in split_mimes:\n Mime_Query(mime)","def on_snippets_loaded(self, snippets):\n self.snippets = snippets","def all_query() -> list:\n data = []\n posts = Posts.query.all()\n for post in posts:\n x = {\n \"title\": post.title,\n \"body\": post.body,\n \"timestamp\": post.timestamp,\n \"id\": post.id,\n \"url\": make_url_from_title(post.title),\n }\n data.append(x)\n return data","def get_query_list():\n prov_list = QueryProvider.list_data_environments()\n\n print(\"Generating documentation for for the following providers\")\n print(\", \".join(list(PROVIDERS)))\n print(\"Skipping the following providers\")\n print(\", \".join(list(set(prov_list) - set(PROVIDERS))))\n env_providers = {prov: QueryProvider(prov) for prov in tqdm.tqdm(PROVIDERS)}\n\n query_series = []\n for env, env_queries in env_providers.items():\n query_names = env_queries.list_queries()\n for query_name in query_names:\n q_group, q_name = query_name.split(\".\")\n qry = env_queries.query_store.get_query(q_group + \".\" + q_name)\n if \"table\" in qry.default_params:\n q_table = qry.default_params[\"table\"].get(\"default\", \"na\").split()[0]\n elif \"table\" in qry.required_params:\n q_table = qry.required_params[\"table\"].get(\"default\", \"na\").split()[0]\n else:\n q_table = \"-\"\n q_dict = {\n \"Environment\": env,\n \"QueryGroup\": q_group,\n \"Query\": q_name,\n \"Description\": qry.description,\n \"Req-Params\": \", \".join(\n sorted(\n [\n f\"{param} ({p_data.get('type')})\"\n for param, p_data in qry.required_params.items()\n ]\n )\n ),\n # \"OtherParams\": \", \".join([f\"{param}\" for param in qry.default_params]),\n \"Table\": q_table,\n }\n query_series.append(pd.Series(q_dict))\n print()\n return pd.DataFrame(query_series).sort_values(\n [\"Environment\", \"QueryGroup\", \"Query\"]\n )","def getQuery(self, context, obj):\n return TestModel.all()","def get_all_recipes(current_user):\n # default query\n query = Recipe.query.join(Recipe.used).group_by(Recipe.id)\n\n # get query string\n query_string = request.args\n\n # filters\n name_keyword = query_string.get('name')\n text_keyword = query_string.get('text')\n ingredient_keyword_list = query_string.getlist('ingredient')\n\n # order\n order_keyword = query_string.get('order')\n\n # go through args\n if name_keyword:\n query = query.filter(Recipe.name.ilike(f'%{name_keyword}%'))\n if text_keyword:\n query = query.filter(Recipe.text.ilike(f'%{text_keyword}%'))\n if ingredient_keyword_list and len(ingredient_keyword_list) != 0:\n print('ingredients found')\n\n # for item in ingredient_keyword_list:\n # item.lower()\n\n # query = query.filter(func.lower(Ingredient.name).in_(ingredient_keyword_list))\n # query = query.join(Ingredient.used).group_by(Recipe.id)\n\n # for ingredient in ingredient_keyword_list:\n # query_tmp = query.filter(Ingredient.name.ilike(f'%{ingredient}%'))\n # print(ingredient)\n # # query = query.filter(Ingredient.name.ilike(f'%{ingredient}%'))\n # query = query.intersect(query_tmp)\n # print(query.all())\n # print(query_tmp.all())\n\n # order the query\n if order_keyword:\n\n if order_keyword == 'max_ing':\n \"\"\"\n filter recipes by ingredients used\n\n select recipe_id, count(ingredient_id) from ingredients_used\n group by recipe_id\n order by count(ingredient_id) <desc - asc>\n \"\"\"\n query = query.order_by(desc(func.count(Ingredient.id))) \n else:\n query = query.order_by(func.count(Ingredient.id))\n\n\n query = query.all()\n if len(query) == 0:\n return jsonify({'message': 'No recipes found'}), 204\n\n output = []\n for recipe in query:\n recipe_obj = {}\n recipe_obj['name'] = recipe.name\n recipe_obj['average_rating'] = recipe.average_rating\n recipe_obj['text'] = recipe.text\n recipe_obj['author'] = recipe.author.email\n recipe_obj['ingredients'] = []\n\n for ingredient in recipe.used:\n recipe_obj['ingredients'].append(ingredient.name)\n \n output.append(recipe_obj)\n\n return jsonify({'message': 'Enjoy these recipes :)', 'data': output})","def search_example(self, query: str) -> List[Example]:\n raise NotImplementedError","def search(self, query: str, lang: str = 'en') -> list([str]):\n self.set_language(lang)\n return self.wiki.search(query)","def read_query_files(**kwargs):\n # Read query files contents and write to query_list\n query_list = {\"query_group\": \"\", \"queries\": []}\n query_group = kwargs[\"queries_dir\"].split(\"/\")[-1]\n query_list.update(query_group=query_group)\n logging.debug(\"Queries dir: \" + kwargs[\"queries_dir\"])\n try:\n for query_filename in sorted(os.listdir(kwargs[\"queries_dir\"])):\n logging.debug(\"Validating query filename: \" + query_filename)\n if validate_query_file(query_filename=query_filename):\n with open(\n kwargs[\"queries_dir\"] + \"/\" + query_filename, \"r\"\n ) as query_filepath:\n logging.debug(\n \"Reading query with filename: \" + query_filename\n )\n query_mapdql = query_filepath.read().replace(\"\\n\", \" \")\n query_mapdql = query_mapdql.replace(\n \"##TAB##\", kwargs[\"source_table\"]\n )\n query_list[\"queries\"].append(\n {\"name\": query_filename, \"mapdql\": query_mapdql}\n )\n logging.info(\"Read all query files\")\n return query_list\n except FileNotFoundError:\n logging.exception(\"Could not find queries directory.\")\n return False","def generateDRQFor(self, domain):\n block = BasicRangeQuery.generateBaseDRQ(self, domain)\n query = set()\n for set_of_queries in block: # Put all Queries from all Blocks into one big block\n query.update(set_of_queries)\n return query","def query_from_strings(\n query_cls: Type[query.CollectionQuery],\n model_cls: Type[Model],\n prefixes: Dict,\n query_parts: Collection[str],\n) -> query.Query:\n subqueries = []\n for part in query_parts:\n subqueries.append(construct_query_part(model_cls, prefixes, part))\n if not subqueries: # No terms in query.\n subqueries = [query.TrueQuery()]\n return query_cls(subqueries)","def show_all():\n\n QUERY = \"\"\"\n SELECT first_name, last_name, github\n FROM students\n \"\"\"\n\n db_cursor = db.session.execute(QUERY)\n\n rows = db_cursor.fetchall()\n\n return rows","def get_items_for_query(self, query_str):\n raise NotImplementedError()","def fetch_all(q, *params):\n db = Database()\n db.cur.execute(q, params)\n ret = db.cur.fetchall()\n db.con.close()\n return ret","def _collection_samples(collection_query, limit, config):\n just_cid = lambda obj : obj.get('meta', {}).get('concept-id')\n found_collections = scom.search_by_page(\"collections\",\n query=collection_query,\n filters=just_cid,\n page_state=scom.create_page_state(limit=limit),\n config=config)\n return found_collections[:limit]","def get_samples(**project_filters):\n p = get_project(**project_filters)\n return Sample.query.filter_by(_project_id=p.id).all()","def getQueries(self):\r\n\t\tp=[]\r\n\t\tfor pa in self.session.query(Query):\r\n\t\t\tp.append(pa)\r\n\t\treturn p","def _query_by_es_query(self, body: str, **kwargs) -> typing.Optional[typing.List[dict]]:\n return self.qm.search(body=body, **kwargs)","def get_queryset(self):\n # tags = self.request.query_params.get('tags')\n # ingredients = self.request.query_params.get('ingredients')\n queryset = self.queryset\n # if tags:\n # tag_ids = self._params_to_ints(tags)\n # queryset = queryset.filter(tags__id__in=tag_ids)\n # if ingredients:\n # ingredient_ids = self._params_to_ints(ingredients)\n # queryset = queryset.filter(ingredients__id__in=ingredient_ids)\n\n return queryset.filter(user=self.request.user).order_by('-id')","def getQueries(self):\n return sorted( self.qryDocs.keys() )","def make_cases_aliquots_query(offset, limit):\n return f\"\"\"{{ \n paginatedCasesSamplesAliquots(offset:{offset} limit:{limit} acceptDUA: true) {{ \n total \n casesSamplesAliquots {{\n case_id \n case_submitter_id\n days_to_lost_to_followup\n disease_type\n index_date\n lost_to_followup\n primary_site\n samples {{\n sample_id\n sample_submitter_id\n sample_type\n #is_ffpe # field removed from API\n preservation_method\n biospecimen_anatomic_site\n current_weight\n days_to_collection\n freezing_method\n initial_weight\n intermediate_dimension\n longest_dimension\n shortest_dimension\n time_between_clamping_and_freezing\n time_between_excision_and_freezing\n aliquots {{ \n aliquot_id \n aliquot_submitter_id\n analyte_type\n aliquot_run_metadata {{\n aliquot_run_metadata_id\n }}\n }}\n }}\n }}\n pagination {{ \n count \n from \n page \n total \n pages \n size \n }}\n }}\n }}\"\"\"","def all(cls):\n return SelectQuery(cls)","def search():\n\n # no search query retrieved\n if not request.args.get(\"q\"):\n raise RuntimeError(\"missing search parameter q\")\n\n # store search query\n q = request.args.get(\"q\")\n\n # remove any punctuation\n for punc in string.punctuation:\n q = q.replace(punc, '')\n\n # prevents http 500 error when string started with punctuation\n if q == \"\":\n q = \"xyz\"\n\n # split multi-word query\n elements = []\n for word in q.split():\n # add to array, concat with SQL wildcard\n elements.append(word + '%')\n\n if len(elements) == 1:\n # assuming: city // state\n station_list = Station.query.join(Place).\\\n filter(db.or_(Place.city.like(elements[0]), Place.state.like(elements[0]))).all()\n\n # assuming: name // call\n station_list += Station.query.\\\n filter(db.or_(Station.name.like(elements[0]), Station.call.like(elements[0]))).all()\n\n elif len(elements) == 2:\n # assuming: city city\n station_list = Station.query.join(Place).\\\n filter(Place.city.like(elements[0]+elements[1])).all()\n\n # assuming: city, state\n station_list += Station.query.join(Place).\\\n filter(db.and_(Place.city.like(elements[0]), Place.state.like(elements[1]))).all()\n\n # assuming: name / call, city / state\n station_list += Station.query.join(Place).\\\n filter(db.and_(\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\n db.or_(Place.city.like(elements[1]), Place.state.like(elements[1])))).all()\n\n elif len(elements) == 3:\n # assuming: city city, state\n station_list = Station.query.join(Place).\\\n filter(db.and_(Place.city.like(elements[0]+elements[1]), Place.state.like(elements[2]))).all()\n\n # assuming: name / call, city city\n station_list += Station.query.join(Place).\\\n filter(db.and_(\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\n Place.city.like(elements[1]+elements[2]))).all()\n\n # assuming: name / call, city, state\n station_list += Station.query.join(Place).\\\n filter(db.and_(\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\n db.and_(Place.city.like(elements[1]), Place.state.like(elements[2])))).all()\n\n elif len(elements) == 4:\n # assuming: name / call, city city, state\n station_list = Station.query.join(Place).\\\n filter(db.and_(\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\n db.and_(Place.city.like(elements[1]+elements[2]), Place.state.like(elements[3])))).all()\n\n # serialize thequery set\n result = geo_stations.dump(station_list)\n\n return jsonify(result.data)","def snippets(self):\n if not hasattr(self, 'solr_response'):\n return {}\n if hasattr(self.solr_response, 'highlighting'):\n joined_snippets = {}\n for uid, snippets in self.solr_response.highlighting.items():\n joined_snippets[uid] = ' '.join([' '.join(snippet) for snippet\n in snippets.values()]).strip()\n return joined_snippets\n return {}","def query_many(self, queries):\n assert isinstance(queries, list)\n cursor = self._cursor()\n results = []\n for query in queries:\n try:\n cursor.execute(query)\n result = cursor.fetchall()\n except Exception as e:\n print(e)\n result = []\n results.append(result)\n return results","def get_queryset(self):\n samples = AudioSample.objects.distinct()\n if samples:\n return samples.filter(\n pub_date__lte=timezone.now()\n ).order_by('-pub_date')\n else:\n return []","def get_google_links_snippets(query):\r\n config = serpscrap.Config()\r\n config.set('scrape_urls', False)\r\n config.set('do_caching', False)\r\n\r\n scrap = serpscrap.SerpScrap()\r\n scrap.init(config=config.get(), keywords=[query])\r\n results = scrap.scrap_serps()\r\n i = 0\r\n\r\n urls = []\r\n google_snippets = []\r\n\r\n for result in results:\r\n if result['serp_snippet'] and i < 10:\r\n urls.append(result['serp_url'])\r\n google_snippets.append(re.sub(r'[^\\x00-\\x7F]+', ' ', result['serp_snippet']).replace('\\n', ''))\r\n i += 1\r\n\r\n return urls, google_snippets","def snippet_history(request, template_name='dpaste/snippet_list.html'):\n snippet_list = None\n snippet_id_list = request.session.get('snippet_list', None)\n if snippet_id_list:\n snippet_list = Snippet.objects.filter(pk__in=snippet_id_list)\n\n if 'delete-all' in request.GET:\n if snippet_list:\n for s in snippet_list:\n s.delete()\n return HttpResponseRedirect(reverse('snippet_history'))\n\n template_context = {\n 'snippets_max': getattr(settings, 'DPASTE_MAX_SNIPPETS_PER_USER', 10),\n 'snippet_list': snippet_list,\n }\n\n return render_to_response(\n template_name,\n template_context,\n RequestContext(request)\n )","def get_queries(self, query_ids):\n return [\n self.resource_loader.query_cache.get(query_id) for query_id in query_ids\n ]","def raw_all(self, dirs=None):\n return self._gather(directories=dirs)","def get_all(self, datastore, *ids):\n return datastore.query(self.__model__).filter(self.__model__.id.in_(ids)).all()","def read_queryset(self, using=None):\n return self.index_queryset(using=using)","def _create_queries(self, mode: QueryMode) -> List[Query]:\n queries: List[Query] = []\n for model in self.project.models:\n for explore in model.explores:\n if mode == \"batch\" or (mode == \"hybrid\" and not explore.queried):\n query = self._create_explore_query(explore, model.name)\n queries.append(query)\n elif mode == \"single\" or (mode == \"hybrid\" and explore.errored):\n explore_queries = self._create_dimension_queries(\n explore, model.name\n )\n queries.extend(explore_queries)\n return queries","def get_any_sample_query(ctrl, srvid, database, queryid, _from, _to):\n has_pgqs = ctrl.has_extension_version(srvid, \"pg_qualstats\", \"0.0.7\")\n example_query = None\n if has_pgqs:\n rs = list(ctrl.execute(text(\"\"\"\n SELECT pg_qualstats_example_query(:queryid)\n LIMIT 1\n \"\"\"), params={\"queryid\": queryid}, srvid=srvid, remote_access=True))\n if len(rs) > 0:\n example_query = rs[0][0]\n if example_query is not None:\n unprepared = unprepare(example_query)\n if example_query == unprepared:\n return example_query\n return get_unjumbled_query(ctrl, srvid, database, queryid,\n _from, _to, 'most executed')","def find_queries(self, senses):\n queries = set()\n for token in senses:\n queries.add(token)\n\n if (len(queries) == 0):\n focus = self.q_classifer.matched_groups['focus'].split()\n focus = [f for f in focus if f not in set(stopwords.words('english'))]\n queries = focus\n\n return queries","def knowledge_query():\n params = flask.request.get_json()\n if params is None or 'sql' not in params:\n return flask.jsonify({'error': 'No SQL specified in request'})\n else:\n knowledge_store = KnowledgeStore(settings['FLATMAP_ROOT'], create=False, read_only=True)\n result = knowledge_store.query(params.get('sql'), params.get('params', []))\n knowledge_store.close()\n if 'error' in result:\n app.logger.warning('SQL: {}'.format(result['error']))\n return flask.jsonify(result)","def get_all(self, start=0, count=-1, sort='', query='', view=''):\n return self._client.get_all(start, count, sort=sort, query=query, view=view)","def get_snippets(self, constraints):\n for ind, text in enumerate(self.__mongo_db.get({\"title\": \"Chapter 1\"})):\n self.__postgre_db.insert(\"texts\", {\"title\": text['title']})\n self.find_text_window(text['text'], text['id'], constraints)\n print(\"Chapter \" + str(text['id']) + \" done.\")","def study_list_all(self):\n envelope_copy = et.fromstring(self.envelope)\n body = [i for i in envelope_copy.iterfind(\n './/se:Body', {'se': self.ns_se})][0]\n\n method_name = 'listAllRequest'\n list_all = et.Element(et.QName(self.ns_study, method_name))\n body.append(list_all)\n\n envelope = et.tostring(envelope_copy)\n response = self.request(\n self.ocws_url, envelope, method_name, self.ns_study)\n return response","def query_executions(self):\n return self._call_txtrader_api('query_executions', {})","def get_query_specs(self, *args, **keyword_args):\n sandbox_zips_with_whitespace = {\n cdr_consts.QUERY:\n SANDBOX_ZIPS_WITH_WHITESPACE.render(\n project_id=self.project_id,\n sandbox_dataset_id=self.sandbox_dataset_id,\n whitespace_sandbox=ZIPS_WITH_WHITESPACE_SANDBOX,\n dataset_id=self.dataset_id,\n obs_table=OBSERVATION)\n }\n\n sandbox_invalid_zip_codes = {\n cdr_consts.QUERY:\n SANDBOX_INVALID_ZIP_CODES.render(\n project_id=self.project_id,\n sandbox_dataset_id=self.sandbox_dataset_id,\n sandbox_table=self.sandbox_table_for(OBSERVATION),\n dataset_id=self.dataset_id,\n obs_table=OBSERVATION,\n pipeline_tables=PIPELINE_TABLES,\n zip3_lookup=ZIP3_LOOKUP)\n }\n\n clean_zips_of_whitespace = {\n cdr_consts.QUERY:\n CLEAN_ZIPS_OF_WHITESPACE.render(\n project_id=self.project_id,\n dataset_id=self.dataset_id,\n obs_table=OBSERVATION,\n sandbox_dataset_id=self.sandbox_dataset_id,\n whitespace_sandbox=ZIPS_WITH_WHITESPACE_SANDBOX)\n }\n\n update_zip_codes = {\n cdr_consts.QUERY:\n UPDATE_INVALID_ZIP_CODES.render(\n project_id=self.project_id,\n dataset_id=self.dataset_id,\n obs_table=OBSERVATION,\n sandbox_dataset_id=self.sandbox_dataset_id,\n sandbox_table=self.sandbox_table_for(OBSERVATION))\n }\n\n return [\n sandbox_zips_with_whitespace, clean_zips_of_whitespace,\n sandbox_invalid_zip_codes, update_zip_codes\n ]","def test_returns_all_studies_with_no_query(self):\n url = self.get_url()\n response = self.client.get(url)\n pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))","def test_returns_all_studies_with_no_query(self):\n url = self.get_url()\n response = self.client.get(url)\n pks = get_autocomplete_view_ids(response)\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))","def test_get_all_samples(self):\n self.login()\n\n page_size = 20\n\n # hit the API endpoint for both pages\n for page in range(1, 3):\n\n data = {'page': page,\n 'page_size': page_size}\n response = self.client.get(reverse('searchsamples'), data, format='json')\n\n expected = Sample.objects.all().order_by(\"-received\")\n\n paginator = Paginator(expected, page_size)\n res = paginator.page(page)\n\n # format queryset into json for returning\n serializer = SampleSerializer(res, many=True)\n\n context = {\n 'data': serializer.data,\n 'more': (page == 1)\n }\n\n self.assertEqual(response.json(), context)\n self.assertEqual(response.status_code, status.HTTP_200_OK)","def get_all(class_name):\n result = class_name.query.all()\n return result","def all_javascriptExercises(self):\n\n with sqlite3.connect(self.db_path) as conn:\n conn.row_factory = lambda cursor, row: JavascriptExercises(row[0], row[1])\n db_cursor = conn.cursor()\n\n db_cursor.execute(\"\"\"\n SELECT [Language], [Name]\n FROM Exercise\n WHERE [Language] in (\"Javascript\");\n \"\"\")\n\n all_javascriptExercises = db_cursor.fetchall()\n for exercise in all_javascriptExercises:\n print(exercise)","def get_queryset(self):\n ##Check for the url keyword arguments\n q = self.request.QUERY_PARAMS.get('q', None)\n if q:\n return Clip.live.filter(\n Q(title__icontains=q) |\n Q(author__username__icontains=q) |\n Q(categories__slug__in=[q]) |\n Q(tags__name__in=[q]) |\n Q(description__icontains=q)\n ).order_by('-created').distinct()\n\n return Clip.live.all().order_by('-created')","def n1qlQueryAll(self, *args, **kwargs):\n if not self.connected:\n cb = lambda x: self.n1qlQueryAll(*args, **kwargs)\n return self.connect().addCallback(cb)\n\n kwargs['itercls'] = BatchedN1QLRequest\n o = super(RawBucket, self).n1ql_query(*args, **kwargs)\n o.start()\n return o._getDeferred()","def generateDRQFor(self, domain):\n block = PatternRangeQuery.generateBaseDRQ(self, domain)\n query = set()\n for set_of_queries in block: # Put the contents of all blocks into one big block\n query.update(set_of_queries)\n return query","def findall(cls, *lst, **dct):\n query = cls.where(*lst, **dct).select()\n result = query.execute()\n return result.fetchall()","def get_all_questions(self):\n query = (\"SELECT * FROM tbl_questions;\")\n user_reqeusts = get_just_query(query)\n return user_reqeusts"],"string":"[\n \"def getSnippets(self, folderpath):\\n print(\\\"Getting snippets for {}\\\".format(folderpath))\\n # s2q = self.helper.loadJson(os.path.join(folderpath, 'final',\\n # 'subject2svoqueries.json'))\\n queries = self.helper.loadCsv(\\n folderpath+\\\"/final\\\", \\\"candidate_queries.csv\\\")\\n fullPath = os.path.join(self.rootpath, folderpath)\\n\\n relevant = []\\n for idx, query in enumerate(queries):\\n print(\\\"Crawling query {} ...\\\".format(query[1]))\\n googleSnippets = Information.GoogleSnippets(fullPath, query[0],\\n idx, query[1])\\n res = googleSnippets.start_crawl()\\n relevant.append(res)\\n time.sleep(random.randint(1, 11))\\n # for topic in s2q:\\n # relevant = []\\n # for idx, t in enumerate(s2q[topic]):\\n # # print(\\\"Searching for topic {} with query {}\\\".format(topic,\\n # # query))\\n # googleSnippets = Information.GoogleSnippets(fullPath, topic,\\n # idx, t['query'])\\n # res = googleSnippets.start_crawl()\\n # relevant.append(res)\\n # time.sleep(random.randint(1, 11))\\n output_root = os.path.join(folderpath, 'final')\\n self.helper.dumpJson(output_root, \\\"snippets.json\\\", relevant)\\n # output_root = os.path.join(folderpath, 'final', 'snippets')\\n # if not os.path.exists(output_root):\\n # os.makedirs(output_root)\\n # self.helper.dumpJson(output_root, \\\"snippets.json\\\", total_snippets)\",\n \"def snippets(self):\\n\\n queries = []\\n\\n from tagged_document import TagQuery\\n\\n # start with a version of ourself that has no expanded snippets\\n source_lines = self.cleaned_contents.split(\\\"\\\\n\\\")\\n\\n # the list of lines we're working with\\n output_lines = []\\n\\n # default to working with files at the current state on disk; this\\n # can change to specific refs when a // tag: instruction is\\n # encountered in the document\\n current_ref = WORKSPACE_REF\\n\\n tag_regex = re.compile(r\\\"$\\\\/\\\\/\\\\s*tag:?\\\\s*(.*)^\\\", flags=re.IGNORECASE)\\n snip_regex = re.compile(r\\\"$\\\\/\\\\/\\\\s*tag:?\\\\s*(.*)^\\\", flags=re.IGNORECASE)\\n\\n for line in source_lines:\\n output_lines.append(line)\\n\\n # change which tag we're looking at if we hit an instruction to\\n # do so\\n tag = tag_regex.match(line)\\n\\n if tag:\\n current_ref = tag.groups(1).strip()\\n\\n # is this a snippet?\\n snippet = snip_regex.match(line)\\n if snippet:\\n\\n # figure out what tags we're supposed to be using here\\n query_text = snippet.groups(1)\\n\\n # build the tag query from this\\n query = TagQuery(query_text, ref=current_ref)\\n\\n queries.append(query)\\n\\n return queries\",\n \"def snippet_list(request):\\n if request.method == 'GET':\\n snippets = Snippet.objects.all()\\n serializer = SnippetSerializer(snippets, many=True)\\n return Response(serializer.data)\\n\\n elif request.method == 'POST':\\n serializer = SnippetSerializer(data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def snippet_list(request):\\n if request.method == 'GET':\\n snippets = Snippet.objects.all()\\n serializer = SnippetSerializer(snippets, many=True)\\n return Response(serializer.data)\\n\\n elif request.method == 'POST':\\n serializer = SnippetSerializer(data=request.data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def get_all(self, q=None, limit=None):\\r\\n q = q or []\\r\\n\\r\\n if limit and limit < 0:\\r\\n raise ClientSideError(_(\\\"Limit must be positive\\\"))\\r\\n kwargs = _query_to_kwargs(q, storage.SampleFilter.__init__)\\r\\n f = storage.SampleFilter(**kwargs)\\r\\n return map(Sample.from_db_model,\\r\\n pecan.request.storage_conn.get_samples(f, limit=limit))\",\n \"def query_all(self):\\n return multisearch.queries.QueryAll().connect(self)\",\n \"def snippet_list(request, format=None): # format=None: 데이터 형태에 대한 포맷정보가 붙는다.\\r\\n if request.method == 'GET':\\r\\n snippets = Snippet.objects.all()\\r\\n serializer = SnippetSerializer(snippets, many=True)\\r\\n return Response(serializer.data)\\r\\n\\r\\n elif request.method == 'POST':\\r\\n serializer = SnippetSerializer(data=request.data)\\r\\n if serializer.is_valid():\\r\\n serializer.save()\\r\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\r\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def query_all():\\n\\tstudents = session.query(Student).all()\\n\\treturn students\",\n \"def snippet_list(request):\\n if request.method == 'GET':\\n quickstart = Quickstart.objects.all()\\n serializer = QuickstartSerializer(snippets, many=True)\\n return JsonResponse(serializer.data, safe=False)\\n\\n elif request.method == 'POST':\\n data = JSONParser().parse(request)\\n serializer = QuickstartSerializer(data=data)\\n if serializer.is_valid():\\n serializer.save()\\n return JsonResponse(serializer.data, status=201)\\n return JsonResponse(serializer.errors, status=400)\",\n \"def get_all(self, queries):\\n return [self._unpack(x.ids) for x in self.server.select2([\\n ttypes.SelectQuery(\\n [ttypes.SelectOperation(\\n operation_type=\\\\\\n ttypes.SelectOperationType.SimpleQuery,\\n term=self._query_term(*x)\\n )\\n ],\\n ttypes.Page(self.page_length, -1)\\n )\\n for x in queries])]\",\n \"def get_all():\\n return SavedQuery.get_all()\",\n \"def getSnippets(self, asDict=False):\\n\\t\\t\\n\\t\\titems = self.index\\n\\n\\t\\tif asDict:\\n\\t\\t\\tsnippets = {}\\n\\t\\telse:\\n\\t\\t\\tsnippets = []\\n\\n\\t\\tfor item in items:\\n\\n\\t\\t\\t\\tif asDict:\\n\\t\\t\\t\\t\\tsnippets[item] = self.getSnippet(item)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tsnippets.append(self.getSnippet(item))\\n\\n\\t\\treturn snippets\",\n \"def raw_as_qs(self, raw_query, params=()):\\n cursor = connection.cursor()\\n try:\\n cursor.execute(raw_query, params)\\n return self.filter(id__in=(x[0] for x in cursor))\\n finally:\\n cursor.close()\",\n \"def make_webapp_per_sample_view_query():\\n file_table_id, case_table_id, file_assoc_table_id, aliquot_table_id, study_table_id = get_mapping_table_ids()\\n\\n # todo change query after next file metadata pull\\n return f\\\"\\\"\\\"\\n SELECT DISTINCT fm.file_id, fa.case_id, ac.case_submitter_id, ac.sample_id, ac.sample_submitter_id, \\n ac.sample_type, REPLACE(s.project_short_name, '_', '-') AS project_short_name, s.program_short_name, \\n fm.file_type, fm.data_category, fm.experiment_type, \\n fm.file_size, fm.file_format, fm.instrument, fm.file_name,\\n REPLACE(fm.url, 'https://d3iwtkuvwz4jtf.cloudfront.net/', 's3://pdcdatastore/') AS file_name_key, \\n fm.`access`\\n FROM `{file_table_id}` fm\\n JOIN `{file_assoc_table_id}` fa\\n ON fm.file_id = fa.file_id\\n JOIN `{aliquot_table_id}` ac\\n ON fa.case_id = ac.case_id\\n JOIN `{case_table_id}` cm\\n ON ac.case_id = cm.case_id\\n JOIN `{study_table_id}` s\\n ON s.project_id = cm.project_id\\n \\\"\\\"\\\"\",\n \"def query(self, queries):\\n final_result = []\\n results = self.__return_query('query', queries)\\n if results == None:\\n return None\\n else:\\n if len(results) > 1:\\n for result in results:\\n final_result.append(result['data'])\\n else:\\n final_result = results\\n return final_result\",\n \"def get_queries() -> List[str]:\\n\\n logging.info(\\\"getting query files\\\")\\n gcs = storage.Client(project=GCP_PROJECT)\\n bucket = gcs.bucket(GCS_BUCKET)\\n blobs = bucket.list_blobs(prefix='layered_gis')\\n queries = {}\\n for blob in blobs:\\n blob_name = blob.name\\n if '.sh' in blob_name:\\n continue\\n filename = blob_name.replace('layered_gis/', '')\\n layer, _ = filename.split('/')\\n sql_query = blob.download_as_string().decode('utf-8')\\n full_query = queries.get(layer, '')\\n if full_query:\\n full_query += 'UNION ALL \\\\n'\\n full_query += sql_query + '\\\\n'\\n queries[layer] = full_query\\n return queries.values()\",\n \"def get_all_by_user_and_template(user_id, template_id):\\n return SavedQuery.get_all_by_user_and_template(user_id, template_id)\",\n \"def queries(self):\\n request = Request(method=\\\"get\\\", endpoint=\\\"/query/current\\\")\\n\\n def response_handler(resp):\\n if not resp.is_success:\\n raise C8QLQueryListError(resp, request)\\n return self._format_queries(resp.body)\\n\\n return self._execute(request, response_handler)\",\n \"def get_all_of_experiment(self, experiment_name: str):\\n query = (\\n f\\\"SELECT * FROM {self.table_name} WHERE experiment_name='{experiment_name}'\\\"\\n )\\n c = self.db.cursor()\\n c.execute(query)\\n queries = c.fetchall()\\n return queries\",\n \"def getStars(queries, lcs_fold, query_path=None, progb_txt=\\\"Querying stars: \\\"):\\n ORDINARY_QUERY_KEY = \\\"QUERY:\\\"\\n\\n stars = []\\n for query in tqdm(queries, desc=progb_txt):\\n query = query.strip()\\n\\n if query.startswith(ORDINARY_QUERY_KEY):\\n stars += getStarsFromRemoteDb(\\n query[len(ORDINARY_QUERY_KEY):], query_path)\\n\\n else:\\n stars += getStarsFromFolder(query, lcs_fold)\\n\\n if not stars:\\n raise QueryInputError(\\\"There no stars. Your query: %s\\\" % queries)\\n\\n return stars\",\n \"def get_all(self, q=None, limit=None):\\r\\n q = q or []\\r\\n if limit and limit < 0:\\r\\n raise ClientSideError(_(\\\"Limit must be positive\\\"))\\r\\n kwargs = _query_to_kwargs(q, storage.SampleFilter.__init__)\\r\\n kwargs['meter'] = self.meter_name\\r\\n f = storage.SampleFilter(**kwargs)\\r\\n return [OldSample.from_db_model(e)\\r\\n for e in pecan.request.storage_conn.get_samples(f, limit=limit)\\r\\n ]\",\n \"def query(self):\\n query_url = self.get_query_url()\\n logging.info('Querying: ' + query_url)\\n json_data = request.urlopen(query_url).read().decode()\\n logging.debug('Retrieved the following ' + json_data)\\n response = json.loads(json_data)\\n\\n return self.get_docs_from_response(response)\",\n \"def get_queryset(self):\\n queryset = Snippet.objects.all()\\n username = self.request.query_params.get('username', None)\\n userqueryset = User.objects.all()\\n users = userqueryset.filter(username=username)\\n if users.count() != 0 and username is not None:\\n queryset = queryset.filter(owner=users[0])\\n return queryset\\n return []\",\n \"def get_all(self, *ids):\",\n \"def getExampleQueries(self, selectedID = 0):\\r\\n return \\\"\\\"\",\n \"def get_snippet_info_list(self):\\n snippets = []\\n for snippet in self.snippets:\\n snippets.append([snippet[\\\"title\\\"], snippet[\\\"description\\\"]])\\n return snippets\",\n \"def author_queries(case, author):\\n query_set = {\\n \\\"0\\\": [],\\n \\\"1\\\": [1],\\n \\\"2\\\": [4,1],\\n \\\"3\\\": [2,1],\\n \\\"4\\\": [3,2,1],\\n \\\"5\\\": [5,4,3,2,1],\\n \\\"6\\\": [6,5,4,3,2,1]\\n }\\n qs = query_set[str(case)]\\n query_list = []\\n for q in qs:\\n query_list.append(author_case_query(q, author))\\n return query_list\",\n \"def get_queryset(self):\\n\\n qs = SynonymList.objects.all()\\n\\n terms = self.request.query_params.get(\\\"q\\\", \\\"\\\")\\n\\n if terms:\\n terms = self.request.query_params.get(\\\"q\\\", \\\"\\\")\\n query = parse_query(remove_accents(terms))\\n qs = qs.filter(search_vector_keywords_list=query).annotate(\\n rank=SearchRank(F(\\\"search_vector_keywords_list\\\"), query)\\n )\\n\\n qs = qs.order_by(\\\"name\\\").distinct()\\n\\n return qs\",\n \"def sample_queries(self) -> Sequence['outputs.CodelessUiConnectorConfigPropertiesResponseSampleQueries']:\\n return pulumi.get(self, \\\"sample_queries\\\")\",\n \"def query_many(self, *q, read_as=None):\\n raise NotImplementedError\",\n \"def snippets_by_language(request, slug):\\n language = get_object_or_404(Language, slug__exact=slug)\\n return list_detail.object_list(request,\\n queryset=Snippet.objects.get_by_language(slug),\\n extra_context={ 'object': language },\\n template_name='cab/language_detail.html',\\n **base_generic_dict)\",\n \"def query_items(self, request, params, payload):\\n return util.ndb_query_from_values(self.model, params).fetch()\",\n \"def queries(self):\\n return self.__queries\",\n \"def apply_special_queries(query, specials):\\n for i in specials:\\n query = FILTERS_LIST[i](specials[i], query)\\n return query\",\n \"def prepare_queries(self):\\n self.log.info(\\\"preparing queries ...\\\")\\n self.prepared_queries = {}\\n self.prepared_query_to_str = {}\\n initNs = {\\\"rdfs\\\": RDFApi.RDFS}\\n get_classes = \\\"\\\"\\\"\\n SELECT ?class\\n WHERE {\\n ?class rdf:type rdfs:Class .\\n }\\n \\\"\\\"\\\"\\n self.add_prepared_query(\\\"get_classes\\\", get_classes, initNs)\\n\\n get_properties = \\\"\\\"\\\"\\n SELECT ?property\\n WHERE {\\n ?property rdf:type rdf:Property .\\n }\\n \\\"\\\"\\\"\\n self.add_prepared_query(\\\"get_properties\\\", get_properties, None)\\n\\n get_term_to_label = \\\"\\\"\\\"\\n SELECT ?term ?label\\n WHERE {\\n ?term rdfs:label ?label\\n }\\n \\\"\\\"\\\"\\n self.add_prepared_query(\\\"get_term_to_label\\\", get_term_to_label, initNs)\\n\\n get_term_to_desc = \\\"\\\"\\\"\\n SELECT ?term ?desc\\n WHERE {\\n ?term rdfs:comment ?desc\\n }\\n \\\"\\\"\\\"\\n self.add_prepared_query(\\\"get_term_to_desc\\\", get_term_to_desc, initNs)\\n\\n get_ancestors = \\\"\\\"\\\"\\n SELECT ?class\\n WHERE {\\n ?subject rdfs:subClassOf* ?mid .\\n ?mid rdfs:subClassOf* ?class .\\n }\\n group by ?class\\n order by count(?mid)\\n \\\"\\\"\\\"\\n self.add_prepared_query(\\\"get_ancestors\\\", get_ancestors, initNs)\",\n \"def get_queryset(self):\\n queryset = TShirt.objects.all()\\n code = self.request.query_params.get('code', None)\\n if code is not None:\\n queryset = queryset.filter(code=code)\\n return queryset\\n return []\",\n \"def db_select_all(self):\\n \\n query = \\\"SELECT * FROM %s\\\" % PUBLICATIONS_TABLE\\n with self.connection:\\n c = self.connection.cursor()\\n c.execute(query)\\n return c.fetchall()\",\n \"def get_queryset(self):\\n queryset = Book.objects.all()\\n title = self.request.query_params.get(\\\"title\\\", None)\\n if title:\\n queryset = queryset.filter(title__icontains=title)\\n author = self.request.query_params.get(\\\"author\\\", None)\\n if author:\\n queryset = queryset.filter(author__icontains=author)\\n publication_language = self.request.query_params.get(\\n \\\"publication_language\\\", None\\n )\\n if publication_language:\\n queryset = queryset.filter(\\n publication_language__icontains=publication_language\\n )\\n publication_date_start = self.request.query_params.get(\\n \\\"publication_date_start\\\", None\\n )\\n if publication_date_start:\\n queryset = queryset.filter(publication_date__gte=publication_date_start)\\n publication_date_end = self.request.query_params.get(\\n \\\"publication_date_end\\\", None\\n )\\n if publication_date_end:\\n queryset = queryset.filter(publication_date__lte=publication_date_end)\\n return queryset\",\n \"def snippet_list_apiview(request, format=None):\\n if request.method == 'GET':\\n snippets = Snippet.objects.all()\\n serializer = SnippetSerializer(snippets, many=True, context={'request': request})\\n return Response(serializer.data)\\n\\n elif request.method == 'POST':\\n serializer = SnippetSerializer(data=request.data, context={'request': request})\\n if serializer.is_valid():\\n serializer.save(owner=request.user)\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def get_source_query(self) -> QuerySet:\\n raise NotImplementedError\",\n \"def snippetList(requeset, format = None):\",\n \"def driver_queries(self) -> Iterable[Dict[str, str]]:\\n return self.svc_queries\",\n \"def search_samples():\\n r = req('GET', SUB_API + 'search/samples', params=apply_search_filters())\\n samples = []\\n for sample in demisto.get(r.json(), 'data.items'):\\n samples.append({\\n 'ID': demisto.get(sample, 'result'),\\n 'Details': demisto.get(sample, 'details')\\n })\\n demisto.results({\\n 'Type': entryTypes['note'],\\n 'EntryContext': {'ThreatGrid.Sample': samples},\\n 'HumanReadable': tableToMarkdown('ThreatGrid - Sample Search', samples, ['Result', 'Details']),\\n 'ContentsFormat': formats['json'],\\n 'Contents': r.json()\\n })\",\n \"def select_all_from_students_db(connection):\\r\\n with connection:\\r\\n r = connection.execute(GET_ALL_STUDENTS)\\r\\n return r.fetchall()\",\n \"def get_qs(self):\\n if self.qs == None:\\n # Get the Lemma PKs\\n qs = self.get_queryset()\\n else:\\n qs = self.qs\\n return qs\",\n \"def get_qs(self):\\n if self.qs == None:\\n # Get the Lemma PKs\\n qs = self.get_queryset()\\n else:\\n qs = self.qs\\n return qs\",\n \"def generate_query(self):\\n return\",\n \"def get_all(self, lang: str = None):\\n pass\",\n \"def query(self, queries):\\n times = []\\n for q in queries:\\n # print(\\\"Starting \\\" + q)\\n t_start = time.time()\\n self.solr.search(\\\"text:\\\" + q, rows=self.n_rows)\\n times.append(time.time()-t_start)\\n return {\\\"times_query\\\": np.mean(times)}\",\n \"def Mime_Query_All(mimes):\\n split_mimes = mimes.split(\\\",\\\")\\n for mime in split_mimes:\\n Mime_Query(mime)\",\n \"def on_snippets_loaded(self, snippets):\\n self.snippets = snippets\",\n \"def all_query() -> list:\\n data = []\\n posts = Posts.query.all()\\n for post in posts:\\n x = {\\n \\\"title\\\": post.title,\\n \\\"body\\\": post.body,\\n \\\"timestamp\\\": post.timestamp,\\n \\\"id\\\": post.id,\\n \\\"url\\\": make_url_from_title(post.title),\\n }\\n data.append(x)\\n return data\",\n \"def get_query_list():\\n prov_list = QueryProvider.list_data_environments()\\n\\n print(\\\"Generating documentation for for the following providers\\\")\\n print(\\\", \\\".join(list(PROVIDERS)))\\n print(\\\"Skipping the following providers\\\")\\n print(\\\", \\\".join(list(set(prov_list) - set(PROVIDERS))))\\n env_providers = {prov: QueryProvider(prov) for prov in tqdm.tqdm(PROVIDERS)}\\n\\n query_series = []\\n for env, env_queries in env_providers.items():\\n query_names = env_queries.list_queries()\\n for query_name in query_names:\\n q_group, q_name = query_name.split(\\\".\\\")\\n qry = env_queries.query_store.get_query(q_group + \\\".\\\" + q_name)\\n if \\\"table\\\" in qry.default_params:\\n q_table = qry.default_params[\\\"table\\\"].get(\\\"default\\\", \\\"na\\\").split()[0]\\n elif \\\"table\\\" in qry.required_params:\\n q_table = qry.required_params[\\\"table\\\"].get(\\\"default\\\", \\\"na\\\").split()[0]\\n else:\\n q_table = \\\"-\\\"\\n q_dict = {\\n \\\"Environment\\\": env,\\n \\\"QueryGroup\\\": q_group,\\n \\\"Query\\\": q_name,\\n \\\"Description\\\": qry.description,\\n \\\"Req-Params\\\": \\\", \\\".join(\\n sorted(\\n [\\n f\\\"{param} ({p_data.get('type')})\\\"\\n for param, p_data in qry.required_params.items()\\n ]\\n )\\n ),\\n # \\\"OtherParams\\\": \\\", \\\".join([f\\\"{param}\\\" for param in qry.default_params]),\\n \\\"Table\\\": q_table,\\n }\\n query_series.append(pd.Series(q_dict))\\n print()\\n return pd.DataFrame(query_series).sort_values(\\n [\\\"Environment\\\", \\\"QueryGroup\\\", \\\"Query\\\"]\\n )\",\n \"def getQuery(self, context, obj):\\n return TestModel.all()\",\n \"def get_all_recipes(current_user):\\n # default query\\n query = Recipe.query.join(Recipe.used).group_by(Recipe.id)\\n\\n # get query string\\n query_string = request.args\\n\\n # filters\\n name_keyword = query_string.get('name')\\n text_keyword = query_string.get('text')\\n ingredient_keyword_list = query_string.getlist('ingredient')\\n\\n # order\\n order_keyword = query_string.get('order')\\n\\n # go through args\\n if name_keyword:\\n query = query.filter(Recipe.name.ilike(f'%{name_keyword}%'))\\n if text_keyword:\\n query = query.filter(Recipe.text.ilike(f'%{text_keyword}%'))\\n if ingredient_keyword_list and len(ingredient_keyword_list) != 0:\\n print('ingredients found')\\n\\n # for item in ingredient_keyword_list:\\n # item.lower()\\n\\n # query = query.filter(func.lower(Ingredient.name).in_(ingredient_keyword_list))\\n # query = query.join(Ingredient.used).group_by(Recipe.id)\\n\\n # for ingredient in ingredient_keyword_list:\\n # query_tmp = query.filter(Ingredient.name.ilike(f'%{ingredient}%'))\\n # print(ingredient)\\n # # query = query.filter(Ingredient.name.ilike(f'%{ingredient}%'))\\n # query = query.intersect(query_tmp)\\n # print(query.all())\\n # print(query_tmp.all())\\n\\n # order the query\\n if order_keyword:\\n\\n if order_keyword == 'max_ing':\\n \\\"\\\"\\\"\\n filter recipes by ingredients used\\n\\n select recipe_id, count(ingredient_id) from ingredients_used\\n group by recipe_id\\n order by count(ingredient_id) <desc - asc>\\n \\\"\\\"\\\"\\n query = query.order_by(desc(func.count(Ingredient.id))) \\n else:\\n query = query.order_by(func.count(Ingredient.id))\\n\\n\\n query = query.all()\\n if len(query) == 0:\\n return jsonify({'message': 'No recipes found'}), 204\\n\\n output = []\\n for recipe in query:\\n recipe_obj = {}\\n recipe_obj['name'] = recipe.name\\n recipe_obj['average_rating'] = recipe.average_rating\\n recipe_obj['text'] = recipe.text\\n recipe_obj['author'] = recipe.author.email\\n recipe_obj['ingredients'] = []\\n\\n for ingredient in recipe.used:\\n recipe_obj['ingredients'].append(ingredient.name)\\n \\n output.append(recipe_obj)\\n\\n return jsonify({'message': 'Enjoy these recipes :)', 'data': output})\",\n \"def search_example(self, query: str) -> List[Example]:\\n raise NotImplementedError\",\n \"def search(self, query: str, lang: str = 'en') -> list([str]):\\n self.set_language(lang)\\n return self.wiki.search(query)\",\n \"def read_query_files(**kwargs):\\n # Read query files contents and write to query_list\\n query_list = {\\\"query_group\\\": \\\"\\\", \\\"queries\\\": []}\\n query_group = kwargs[\\\"queries_dir\\\"].split(\\\"/\\\")[-1]\\n query_list.update(query_group=query_group)\\n logging.debug(\\\"Queries dir: \\\" + kwargs[\\\"queries_dir\\\"])\\n try:\\n for query_filename in sorted(os.listdir(kwargs[\\\"queries_dir\\\"])):\\n logging.debug(\\\"Validating query filename: \\\" + query_filename)\\n if validate_query_file(query_filename=query_filename):\\n with open(\\n kwargs[\\\"queries_dir\\\"] + \\\"/\\\" + query_filename, \\\"r\\\"\\n ) as query_filepath:\\n logging.debug(\\n \\\"Reading query with filename: \\\" + query_filename\\n )\\n query_mapdql = query_filepath.read().replace(\\\"\\\\n\\\", \\\" \\\")\\n query_mapdql = query_mapdql.replace(\\n \\\"##TAB##\\\", kwargs[\\\"source_table\\\"]\\n )\\n query_list[\\\"queries\\\"].append(\\n {\\\"name\\\": query_filename, \\\"mapdql\\\": query_mapdql}\\n )\\n logging.info(\\\"Read all query files\\\")\\n return query_list\\n except FileNotFoundError:\\n logging.exception(\\\"Could not find queries directory.\\\")\\n return False\",\n \"def generateDRQFor(self, domain):\\n block = BasicRangeQuery.generateBaseDRQ(self, domain)\\n query = set()\\n for set_of_queries in block: # Put all Queries from all Blocks into one big block\\n query.update(set_of_queries)\\n return query\",\n \"def query_from_strings(\\n query_cls: Type[query.CollectionQuery],\\n model_cls: Type[Model],\\n prefixes: Dict,\\n query_parts: Collection[str],\\n) -> query.Query:\\n subqueries = []\\n for part in query_parts:\\n subqueries.append(construct_query_part(model_cls, prefixes, part))\\n if not subqueries: # No terms in query.\\n subqueries = [query.TrueQuery()]\\n return query_cls(subqueries)\",\n \"def show_all():\\n\\n QUERY = \\\"\\\"\\\"\\n SELECT first_name, last_name, github\\n FROM students\\n \\\"\\\"\\\"\\n\\n db_cursor = db.session.execute(QUERY)\\n\\n rows = db_cursor.fetchall()\\n\\n return rows\",\n \"def get_items_for_query(self, query_str):\\n raise NotImplementedError()\",\n \"def fetch_all(q, *params):\\n db = Database()\\n db.cur.execute(q, params)\\n ret = db.cur.fetchall()\\n db.con.close()\\n return ret\",\n \"def _collection_samples(collection_query, limit, config):\\n just_cid = lambda obj : obj.get('meta', {}).get('concept-id')\\n found_collections = scom.search_by_page(\\\"collections\\\",\\n query=collection_query,\\n filters=just_cid,\\n page_state=scom.create_page_state(limit=limit),\\n config=config)\\n return found_collections[:limit]\",\n \"def get_samples(**project_filters):\\n p = get_project(**project_filters)\\n return Sample.query.filter_by(_project_id=p.id).all()\",\n \"def getQueries(self):\\r\\n\\t\\tp=[]\\r\\n\\t\\tfor pa in self.session.query(Query):\\r\\n\\t\\t\\tp.append(pa)\\r\\n\\t\\treturn p\",\n \"def _query_by_es_query(self, body: str, **kwargs) -> typing.Optional[typing.List[dict]]:\\n return self.qm.search(body=body, **kwargs)\",\n \"def get_queryset(self):\\n # tags = self.request.query_params.get('tags')\\n # ingredients = self.request.query_params.get('ingredients')\\n queryset = self.queryset\\n # if tags:\\n # tag_ids = self._params_to_ints(tags)\\n # queryset = queryset.filter(tags__id__in=tag_ids)\\n # if ingredients:\\n # ingredient_ids = self._params_to_ints(ingredients)\\n # queryset = queryset.filter(ingredients__id__in=ingredient_ids)\\n\\n return queryset.filter(user=self.request.user).order_by('-id')\",\n \"def getQueries(self):\\n return sorted( self.qryDocs.keys() )\",\n \"def make_cases_aliquots_query(offset, limit):\\n return f\\\"\\\"\\\"{{ \\n paginatedCasesSamplesAliquots(offset:{offset} limit:{limit} acceptDUA: true) {{ \\n total \\n casesSamplesAliquots {{\\n case_id \\n case_submitter_id\\n days_to_lost_to_followup\\n disease_type\\n index_date\\n lost_to_followup\\n primary_site\\n samples {{\\n sample_id\\n sample_submitter_id\\n sample_type\\n #is_ffpe # field removed from API\\n preservation_method\\n biospecimen_anatomic_site\\n current_weight\\n days_to_collection\\n freezing_method\\n initial_weight\\n intermediate_dimension\\n longest_dimension\\n shortest_dimension\\n time_between_clamping_and_freezing\\n time_between_excision_and_freezing\\n aliquots {{ \\n aliquot_id \\n aliquot_submitter_id\\n analyte_type\\n aliquot_run_metadata {{\\n aliquot_run_metadata_id\\n }}\\n }}\\n }}\\n }}\\n pagination {{ \\n count \\n from \\n page \\n total \\n pages \\n size \\n }}\\n }}\\n }}\\\"\\\"\\\"\",\n \"def all(cls):\\n return SelectQuery(cls)\",\n \"def search():\\n\\n # no search query retrieved\\n if not request.args.get(\\\"q\\\"):\\n raise RuntimeError(\\\"missing search parameter q\\\")\\n\\n # store search query\\n q = request.args.get(\\\"q\\\")\\n\\n # remove any punctuation\\n for punc in string.punctuation:\\n q = q.replace(punc, '')\\n\\n # prevents http 500 error when string started with punctuation\\n if q == \\\"\\\":\\n q = \\\"xyz\\\"\\n\\n # split multi-word query\\n elements = []\\n for word in q.split():\\n # add to array, concat with SQL wildcard\\n elements.append(word + '%')\\n\\n if len(elements) == 1:\\n # assuming: city // state\\n station_list = Station.query.join(Place).\\\\\\n filter(db.or_(Place.city.like(elements[0]), Place.state.like(elements[0]))).all()\\n\\n # assuming: name // call\\n station_list += Station.query.\\\\\\n filter(db.or_(Station.name.like(elements[0]), Station.call.like(elements[0]))).all()\\n\\n elif len(elements) == 2:\\n # assuming: city city\\n station_list = Station.query.join(Place).\\\\\\n filter(Place.city.like(elements[0]+elements[1])).all()\\n\\n # assuming: city, state\\n station_list += Station.query.join(Place).\\\\\\n filter(db.and_(Place.city.like(elements[0]), Place.state.like(elements[1]))).all()\\n\\n # assuming: name / call, city / state\\n station_list += Station.query.join(Place).\\\\\\n filter(db.and_(\\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\\n db.or_(Place.city.like(elements[1]), Place.state.like(elements[1])))).all()\\n\\n elif len(elements) == 3:\\n # assuming: city city, state\\n station_list = Station.query.join(Place).\\\\\\n filter(db.and_(Place.city.like(elements[0]+elements[1]), Place.state.like(elements[2]))).all()\\n\\n # assuming: name / call, city city\\n station_list += Station.query.join(Place).\\\\\\n filter(db.and_(\\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\\n Place.city.like(elements[1]+elements[2]))).all()\\n\\n # assuming: name / call, city, state\\n station_list += Station.query.join(Place).\\\\\\n filter(db.and_(\\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\\n db.and_(Place.city.like(elements[1]), Place.state.like(elements[2])))).all()\\n\\n elif len(elements) == 4:\\n # assuming: name / call, city city, state\\n station_list = Station.query.join(Place).\\\\\\n filter(db.and_(\\n db.or_(Station.name.like(elements[0]), Station.call.like(elements[0])),\\n db.and_(Place.city.like(elements[1]+elements[2]), Place.state.like(elements[3])))).all()\\n\\n # serialize thequery set\\n result = geo_stations.dump(station_list)\\n\\n return jsonify(result.data)\",\n \"def snippets(self):\\n if not hasattr(self, 'solr_response'):\\n return {}\\n if hasattr(self.solr_response, 'highlighting'):\\n joined_snippets = {}\\n for uid, snippets in self.solr_response.highlighting.items():\\n joined_snippets[uid] = ' '.join([' '.join(snippet) for snippet\\n in snippets.values()]).strip()\\n return joined_snippets\\n return {}\",\n \"def query_many(self, queries):\\n assert isinstance(queries, list)\\n cursor = self._cursor()\\n results = []\\n for query in queries:\\n try:\\n cursor.execute(query)\\n result = cursor.fetchall()\\n except Exception as e:\\n print(e)\\n result = []\\n results.append(result)\\n return results\",\n \"def get_queryset(self):\\n samples = AudioSample.objects.distinct()\\n if samples:\\n return samples.filter(\\n pub_date__lte=timezone.now()\\n ).order_by('-pub_date')\\n else:\\n return []\",\n \"def get_google_links_snippets(query):\\r\\n config = serpscrap.Config()\\r\\n config.set('scrape_urls', False)\\r\\n config.set('do_caching', False)\\r\\n\\r\\n scrap = serpscrap.SerpScrap()\\r\\n scrap.init(config=config.get(), keywords=[query])\\r\\n results = scrap.scrap_serps()\\r\\n i = 0\\r\\n\\r\\n urls = []\\r\\n google_snippets = []\\r\\n\\r\\n for result in results:\\r\\n if result['serp_snippet'] and i < 10:\\r\\n urls.append(result['serp_url'])\\r\\n google_snippets.append(re.sub(r'[^\\\\x00-\\\\x7F]+', ' ', result['serp_snippet']).replace('\\\\n', ''))\\r\\n i += 1\\r\\n\\r\\n return urls, google_snippets\",\n \"def snippet_history(request, template_name='dpaste/snippet_list.html'):\\n snippet_list = None\\n snippet_id_list = request.session.get('snippet_list', None)\\n if snippet_id_list:\\n snippet_list = Snippet.objects.filter(pk__in=snippet_id_list)\\n\\n if 'delete-all' in request.GET:\\n if snippet_list:\\n for s in snippet_list:\\n s.delete()\\n return HttpResponseRedirect(reverse('snippet_history'))\\n\\n template_context = {\\n 'snippets_max': getattr(settings, 'DPASTE_MAX_SNIPPETS_PER_USER', 10),\\n 'snippet_list': snippet_list,\\n }\\n\\n return render_to_response(\\n template_name,\\n template_context,\\n RequestContext(request)\\n )\",\n \"def get_queries(self, query_ids):\\n return [\\n self.resource_loader.query_cache.get(query_id) for query_id in query_ids\\n ]\",\n \"def raw_all(self, dirs=None):\\n return self._gather(directories=dirs)\",\n \"def get_all(self, datastore, *ids):\\n return datastore.query(self.__model__).filter(self.__model__.id.in_(ids)).all()\",\n \"def read_queryset(self, using=None):\\n return self.index_queryset(using=using)\",\n \"def _create_queries(self, mode: QueryMode) -> List[Query]:\\n queries: List[Query] = []\\n for model in self.project.models:\\n for explore in model.explores:\\n if mode == \\\"batch\\\" or (mode == \\\"hybrid\\\" and not explore.queried):\\n query = self._create_explore_query(explore, model.name)\\n queries.append(query)\\n elif mode == \\\"single\\\" or (mode == \\\"hybrid\\\" and explore.errored):\\n explore_queries = self._create_dimension_queries(\\n explore, model.name\\n )\\n queries.extend(explore_queries)\\n return queries\",\n \"def get_any_sample_query(ctrl, srvid, database, queryid, _from, _to):\\n has_pgqs = ctrl.has_extension_version(srvid, \\\"pg_qualstats\\\", \\\"0.0.7\\\")\\n example_query = None\\n if has_pgqs:\\n rs = list(ctrl.execute(text(\\\"\\\"\\\"\\n SELECT pg_qualstats_example_query(:queryid)\\n LIMIT 1\\n \\\"\\\"\\\"), params={\\\"queryid\\\": queryid}, srvid=srvid, remote_access=True))\\n if len(rs) > 0:\\n example_query = rs[0][0]\\n if example_query is not None:\\n unprepared = unprepare(example_query)\\n if example_query == unprepared:\\n return example_query\\n return get_unjumbled_query(ctrl, srvid, database, queryid,\\n _from, _to, 'most executed')\",\n \"def find_queries(self, senses):\\n queries = set()\\n for token in senses:\\n queries.add(token)\\n\\n if (len(queries) == 0):\\n focus = self.q_classifer.matched_groups['focus'].split()\\n focus = [f for f in focus if f not in set(stopwords.words('english'))]\\n queries = focus\\n\\n return queries\",\n \"def knowledge_query():\\n params = flask.request.get_json()\\n if params is None or 'sql' not in params:\\n return flask.jsonify({'error': 'No SQL specified in request'})\\n else:\\n knowledge_store = KnowledgeStore(settings['FLATMAP_ROOT'], create=False, read_only=True)\\n result = knowledge_store.query(params.get('sql'), params.get('params', []))\\n knowledge_store.close()\\n if 'error' in result:\\n app.logger.warning('SQL: {}'.format(result['error']))\\n return flask.jsonify(result)\",\n \"def get_all(self, start=0, count=-1, sort='', query='', view=''):\\n return self._client.get_all(start, count, sort=sort, query=query, view=view)\",\n \"def get_snippets(self, constraints):\\n for ind, text in enumerate(self.__mongo_db.get({\\\"title\\\": \\\"Chapter 1\\\"})):\\n self.__postgre_db.insert(\\\"texts\\\", {\\\"title\\\": text['title']})\\n self.find_text_window(text['text'], text['id'], constraints)\\n print(\\\"Chapter \\\" + str(text['id']) + \\\" done.\\\")\",\n \"def study_list_all(self):\\n envelope_copy = et.fromstring(self.envelope)\\n body = [i for i in envelope_copy.iterfind(\\n './/se:Body', {'se': self.ns_se})][0]\\n\\n method_name = 'listAllRequest'\\n list_all = et.Element(et.QName(self.ns_study, method_name))\\n body.append(list_all)\\n\\n envelope = et.tostring(envelope_copy)\\n response = self.request(\\n self.ocws_url, envelope, method_name, self.ns_study)\\n return response\",\n \"def query_executions(self):\\n return self._call_txtrader_api('query_executions', {})\",\n \"def get_query_specs(self, *args, **keyword_args):\\n sandbox_zips_with_whitespace = {\\n cdr_consts.QUERY:\\n SANDBOX_ZIPS_WITH_WHITESPACE.render(\\n project_id=self.project_id,\\n sandbox_dataset_id=self.sandbox_dataset_id,\\n whitespace_sandbox=ZIPS_WITH_WHITESPACE_SANDBOX,\\n dataset_id=self.dataset_id,\\n obs_table=OBSERVATION)\\n }\\n\\n sandbox_invalid_zip_codes = {\\n cdr_consts.QUERY:\\n SANDBOX_INVALID_ZIP_CODES.render(\\n project_id=self.project_id,\\n sandbox_dataset_id=self.sandbox_dataset_id,\\n sandbox_table=self.sandbox_table_for(OBSERVATION),\\n dataset_id=self.dataset_id,\\n obs_table=OBSERVATION,\\n pipeline_tables=PIPELINE_TABLES,\\n zip3_lookup=ZIP3_LOOKUP)\\n }\\n\\n clean_zips_of_whitespace = {\\n cdr_consts.QUERY:\\n CLEAN_ZIPS_OF_WHITESPACE.render(\\n project_id=self.project_id,\\n dataset_id=self.dataset_id,\\n obs_table=OBSERVATION,\\n sandbox_dataset_id=self.sandbox_dataset_id,\\n whitespace_sandbox=ZIPS_WITH_WHITESPACE_SANDBOX)\\n }\\n\\n update_zip_codes = {\\n cdr_consts.QUERY:\\n UPDATE_INVALID_ZIP_CODES.render(\\n project_id=self.project_id,\\n dataset_id=self.dataset_id,\\n obs_table=OBSERVATION,\\n sandbox_dataset_id=self.sandbox_dataset_id,\\n sandbox_table=self.sandbox_table_for(OBSERVATION))\\n }\\n\\n return [\\n sandbox_zips_with_whitespace, clean_zips_of_whitespace,\\n sandbox_invalid_zip_codes, update_zip_codes\\n ]\",\n \"def test_returns_all_studies_with_no_query(self):\\n url = self.get_url()\\n response = self.client.get(url)\\n pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))\",\n \"def test_returns_all_studies_with_no_query(self):\\n url = self.get_url()\\n response = self.client.get(url)\\n pks = get_autocomplete_view_ids(response)\\n self.assertEqual(sorted([study.pk for study in self.studies]), sorted(pks))\",\n \"def test_get_all_samples(self):\\n self.login()\\n\\n page_size = 20\\n\\n # hit the API endpoint for both pages\\n for page in range(1, 3):\\n\\n data = {'page': page,\\n 'page_size': page_size}\\n response = self.client.get(reverse('searchsamples'), data, format='json')\\n\\n expected = Sample.objects.all().order_by(\\\"-received\\\")\\n\\n paginator = Paginator(expected, page_size)\\n res = paginator.page(page)\\n\\n # format queryset into json for returning\\n serializer = SampleSerializer(res, many=True)\\n\\n context = {\\n 'data': serializer.data,\\n 'more': (page == 1)\\n }\\n\\n self.assertEqual(response.json(), context)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\",\n \"def get_all(class_name):\\n result = class_name.query.all()\\n return result\",\n \"def all_javascriptExercises(self):\\n\\n with sqlite3.connect(self.db_path) as conn:\\n conn.row_factory = lambda cursor, row: JavascriptExercises(row[0], row[1])\\n db_cursor = conn.cursor()\\n\\n db_cursor.execute(\\\"\\\"\\\"\\n SELECT [Language], [Name]\\n FROM Exercise\\n WHERE [Language] in (\\\"Javascript\\\");\\n \\\"\\\"\\\")\\n\\n all_javascriptExercises = db_cursor.fetchall()\\n for exercise in all_javascriptExercises:\\n print(exercise)\",\n \"def get_queryset(self):\\n ##Check for the url keyword arguments\\n q = self.request.QUERY_PARAMS.get('q', None)\\n if q:\\n return Clip.live.filter(\\n Q(title__icontains=q) |\\n Q(author__username__icontains=q) |\\n Q(categories__slug__in=[q]) |\\n Q(tags__name__in=[q]) |\\n Q(description__icontains=q)\\n ).order_by('-created').distinct()\\n\\n return Clip.live.all().order_by('-created')\",\n \"def n1qlQueryAll(self, *args, **kwargs):\\n if not self.connected:\\n cb = lambda x: self.n1qlQueryAll(*args, **kwargs)\\n return self.connect().addCallback(cb)\\n\\n kwargs['itercls'] = BatchedN1QLRequest\\n o = super(RawBucket, self).n1ql_query(*args, **kwargs)\\n o.start()\\n return o._getDeferred()\",\n \"def generateDRQFor(self, domain):\\n block = PatternRangeQuery.generateBaseDRQ(self, domain)\\n query = set()\\n for set_of_queries in block: # Put the contents of all blocks into one big block\\n query.update(set_of_queries)\\n return query\",\n \"def findall(cls, *lst, **dct):\\n query = cls.where(*lst, **dct).select()\\n result = query.execute()\\n return result.fetchall()\",\n \"def get_all_questions(self):\\n query = (\\\"SELECT * FROM tbl_questions;\\\")\\n user_reqeusts = get_just_query(query)\\n return user_reqeusts\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6417341","0.5955669","0.5799018","0.5799018","0.57882434","0.56366897","0.56245464","0.56226546","0.55856466","0.55196714","0.5429914","0.54079545","0.53793526","0.53777164","0.5342365","0.534001","0.53096443","0.5303962","0.5249011","0.5232009","0.51953965","0.5179029","0.51765746","0.515724","0.51557356","0.5127053","0.5126256","0.5125006","0.5123101","0.51115555","0.5111246","0.508801","0.5032963","0.5029222","0.50175846","0.5013664","0.5009984","0.5007475","0.5003922","0.498644","0.4940755","0.49291438","0.4927451","0.49257088","0.49173158","0.49173158","0.49146393","0.49104884","0.4887519","0.48648468","0.48641145","0.48510614","0.484485","0.48329476","0.48295912","0.48270953","0.48270628","0.4819259","0.48148453","0.48117924","0.48107058","0.48061064","0.48021737","0.48002514","0.4793559","0.47801352","0.4772959","0.47645125","0.47620127","0.47526067","0.47444636","0.47407714","0.47388875","0.47372597","0.47329426","0.4732337","0.47303015","0.47272032","0.47225326","0.4719933","0.47171792","0.47166976","0.47135097","0.47069117","0.46977395","0.46955103","0.46945333","0.4692759","0.4690159","0.46895322","0.46893358","0.46893358","0.4687414","0.46862912","0.46841776","0.46832544","0.46828318","0.46814552","0.46790746","0.46732527"],"string":"[\n \"0.6417341\",\n \"0.5955669\",\n \"0.5799018\",\n \"0.5799018\",\n \"0.57882434\",\n \"0.56366897\",\n \"0.56245464\",\n \"0.56226546\",\n \"0.55856466\",\n \"0.55196714\",\n \"0.5429914\",\n \"0.54079545\",\n \"0.53793526\",\n \"0.53777164\",\n \"0.5342365\",\n \"0.534001\",\n \"0.53096443\",\n \"0.5303962\",\n \"0.5249011\",\n \"0.5232009\",\n \"0.51953965\",\n \"0.5179029\",\n \"0.51765746\",\n \"0.515724\",\n \"0.51557356\",\n \"0.5127053\",\n \"0.5126256\",\n \"0.5125006\",\n \"0.5123101\",\n \"0.51115555\",\n \"0.5111246\",\n \"0.508801\",\n \"0.5032963\",\n \"0.5029222\",\n \"0.50175846\",\n \"0.5013664\",\n \"0.5009984\",\n \"0.5007475\",\n \"0.5003922\",\n \"0.498644\",\n \"0.4940755\",\n \"0.49291438\",\n \"0.4927451\",\n \"0.49257088\",\n \"0.49173158\",\n \"0.49173158\",\n \"0.49146393\",\n \"0.49104884\",\n \"0.4887519\",\n \"0.48648468\",\n \"0.48641145\",\n \"0.48510614\",\n \"0.484485\",\n \"0.48329476\",\n \"0.48295912\",\n \"0.48270953\",\n \"0.48270628\",\n \"0.4819259\",\n \"0.48148453\",\n \"0.48117924\",\n \"0.48107058\",\n \"0.48061064\",\n \"0.48021737\",\n \"0.48002514\",\n \"0.4793559\",\n \"0.47801352\",\n \"0.4772959\",\n \"0.47645125\",\n \"0.47620127\",\n \"0.47526067\",\n \"0.47444636\",\n \"0.47407714\",\n \"0.47388875\",\n \"0.47372597\",\n \"0.47329426\",\n \"0.4732337\",\n \"0.47303015\",\n \"0.47272032\",\n \"0.47225326\",\n \"0.4719933\",\n \"0.47171792\",\n \"0.47166976\",\n \"0.47135097\",\n \"0.47069117\",\n \"0.46977395\",\n \"0.46955103\",\n \"0.46945333\",\n \"0.4692759\",\n \"0.4690159\",\n \"0.46895322\",\n \"0.46893358\",\n \"0.46893358\",\n \"0.4687414\",\n \"0.46862912\",\n \"0.46841776\",\n \"0.46832544\",\n \"0.46828318\",\n \"0.46814552\",\n \"0.46790746\",\n \"0.46732527\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58999836"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":90584,"cells":{"query":{"kind":"string","value":"Reads ident and direction from packet, and returns the associated struct description from structs global. Normalises return to be a ((str, str), ...)"},"document":{"kind":"string","value":"def get_struct(self, packet):\n\t\to = structs[packet.ident]\n\t\tif isinstance(o, dict):\n\t\t\to = o[packet.direction]\n\t\tif len(o) and not isinstance(o[0], tuple):\n\t\t\to = (o),\n\t\treturn o"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def struct_handler(rdr: TextIO) -> str:\n # What is the indent level?\n line = rdr.readline()\n spaces = 0\n for c in line:\n if c != ' ':\n break\n spaces += 1\n if spaces < 4: # this would be a false positive exit early\n return line\n # define an exit condition\n end = re.compile(f\"^( ){ {spaces - 4} }}}$\")\n # define a regex for fields\n priv_field = re.compile(f\"^( ){ {spaces} }(?!pub )(\\w+)\\:\")\n result = \"\"\n while not end.match(line):\n field_match = priv_field.match(line)\n if field_match:\n line = line[:spaces]+\"pub \"+line[spaces:]\n result += line\n line = rdr.readline()\n result += line # catch the terminal brace\n return result","def get_info(curf, begin, read, param_of_unpack):\n curf.seek(begin)\n info = curf.read(read)\n info = struct.unpack(param_of_unpack, info)\n return str(info[0])","def Structs():\n idx = idc.get_first_struc_idx()\n while idx != ida_idaapi.BADADDR:\n sid = idc.get_struc_by_idx(idx)\n yield (idx, sid, idc.get_struc_name(sid))\n idx = idc.get_next_struc_idx(idx)","def getBriefPacket(self):\n\n # briefPacket = NamedTuple('Brief Packet',\n # ['no', 'time', 'source', 'destination',\n # 'protocol', 'length'])\n return (self.pktIndex, self.pktTime, self.pktSrc,\n self.pktDst, self.pktProt, self.pktLen, self.pktStack)","def parse_from_dref(self, packet):\n\t\tname = packet[9:].strip(b'\\x00').decode('utf-8')\n\t\traw_value = packet[5:9]\n\t\tvalue = struct.unpack('f', raw_value)[0]\n\t\treturn name, value","def read_packet(self):\n\n\t\t#self.debug(\"READ BUFFER SIZE: %d\" % len(self.buff))\n\t\tbackup = self.buff[:]\n\t\tpacket = Packet()\n\t\ttry:\n\t\t\tpacket.direction = self.node\n\t\t\tpacket.ident = self.unpack('ubyte')\n\t\t\t\n\t\t\t#Defined structs from huge dict\n\t\t\tfor datatype, name in self.get_struct(packet):\n\t\t\t\t# this populates packet.data with {name: value}\n\t\t\t\tpacket.data[name] = self.unpack(datatype)\n\n\t\t\t# I believe the following are packet-type specific fixes for variable-length packets.\n\n\t\t\t#0x17\n\t\t\tif packet.ident == 0x17:\n\t\t\t\tif packet.data['unknown'] > 0:\n\t\t\t\t\tpacket.data['x2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['y2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['z2'] = self.unpack('short')\n\t\t\n\t\t\t#0x33\n\t\t\tif packet.ident in (0x33, 0x34):\n\t\t\t\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n#\t\t\t#0x34\n#\t\t\tif packet.ident == 0x34:\n#\t\t\t\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\n#\t\t\t\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tpacket.data[\"blocks\"] = []\n#\t\t\t\tfor i in zip(coords, btype, metadata):\n#\t\t\t\t\tblock = {}\n#\t\t\t\t\tblock[\"x\"] =\t\ti[0] >> 12\n#\t\t\t\t\tblock[\"z\"] = 0x0F & i[0] >> 8\n#\t\t\t\t\tblock[\"y\"] = 0xFF & i[0]\n#\t\t\t\t\tblock[\"type\"] = i[1]\n#\t\t\t\t\tblock[\"metadata\"] = i[2]\n#\t\t\t\t\tpacket.data[\"blocks\"].append(block)\n#\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x3C\n\t\t\tif packet.ident == 0x3C:\n\t\t\t\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\n\t\t\t\ti = 0\n\t\t\t\tpacket.data[\"blocks\"] = []\n\t\t\t\twhile i < packet.data['data_size']*3:\n\t\t\t\t\tpacket.data[\"blocks\"].append(dict(zip(('x','y','z'), records[i:i+3])))\n\t\t\t\t\ti+=3\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x68\n\t\t\tif packet.ident == 0x68:\n\t\t\t\tpacket.data[\"slots_data\"] = self.unpack_array('slot', packet.data[\"data_size\"])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\t#0x82:\n\t\t\tif packet.ident == 0x82:\n\t\t\t\tpacket.data[\"text\"] = []\n\t\t\t\tfor i in range(4):\n\t\t\t\t\tpacket.data[\"text\"].append(packet.data[\"line_%s\" % (i+1)])\n\t\t\t\t\t\n\t\t\t#0x83\n\t\t\tif packet.ident == 0x83:\n\t\t\t\tpacket.data[\"data\"] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\n\t\t\t# Sets packet.original to the byte string that the packet was decoded from.\n\t\t\tpacket.original = backup[:len(backup) - len(self.buff)]\n\n\t\t\treturn packet\n\n\t\texcept IncompleteData:\n\t\t\tself.buff = backup\n\t\t\treturn None\n\t\texcept Exception, ex:\n\t\t\tself.buff = backup\n\t\t\tex.args += (self.buff[20:],)\n\t\t\traise","def visit_Struct(self, node):\n return str_node(node)","def extract_packet(_buffer):\n if len(_buffer)>=5:\n mtype=_buffer[0]\n msglen=struct.unpack('!L',_buffer[1:5])[0]\n if len(_buffer)>=msglen+1:\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\n return None,None,_buffer","def dumppkt(self):\n try:\n return ( (k, getattr(self,k)) for k in self.__pkt_fields__ + self.__dyn_fields__ )\n except AttributeError:\n raise KeyError","def do_read_struct(self, arg):\n self._print_func_result(self.phil.read_struct, arg)","def decode_struct(self, fmt, buf, pos):\n new_pos = pos + struct.calcsize(fmt)\n return struct.unpack(fmt, buf[pos:new_pos])[0], new_pos","def test_snmpwalk_return_structure():\n result = snmpwalk(community='public', ipaddress=SNMP_SRV_ADDR,\n oid='IF-MIB::ifTable', port=SNMP_SRV_PORT)\n assert isinstance(result, list)\n assert isinstance(result[0], tuple)\n assert isinstance(result[0][0], str) and isinstance(result[0][1], str)\n assert result[0][0] == '.1.3.6.1.2.1.2.2.1.1.1'\n assert result[0][1] == '1'","def read(iprot):\r\n data = {}\r\n iprot.readStructBegin()\r\n while True:\r\n (fname, ftype, fid) = iprot.readFieldBegin()\r\n if ftype == TType.STOP:\r\n break\r\n else:\r\n try:\r\n val = _read_one_field(iprot, ftype)\r\n data[\"FIELD_%d\" % fid] = (_type_name(ftype), val)\r\n except:\r\n traceback.print_exc()\r\n iprot.readFieldEnd()\r\n iprot.readStructEnd()\r\n return data","def read(iprot):\n data = {}\n iprot.readStructBegin()\n while True:\n (fname, ftype, fid) = iprot.readFieldBegin()\n if ftype == TType.STOP:\n break\n else:\n try:\n val = _read_one_field(iprot, ftype)\n data[\"FIELD_%d\" % fid] = (_type_name(ftype), val)\n except:\n traceback.print_exc()\n iprot.readFieldEnd()\n iprot.readStructEnd()\n return data","def ReceiveMessageFromPacketInfo(self) -> IPPacketInformation:","def getfield(self, pkt, s):\n class_id = getattr(pkt, self._entity_class)\n entity_class = omci_entities.entity_id_to_class_map.get(class_id)\n data = {}\n for attribute in entity_class.attributes:\n if AttributeAccess.SetByCreate not in attribute.access:\n continue\n if attribute.field.name == 'managed_entity_id':\n continue\n fld = attribute.field\n s, value = fld.getfield(pkt, s)\n data[fld.name] = value\n return s, data","def read_record_head(self):\n ver_inst, rec_type, rec_size = unpack('<HHL', self.stream.read(8))\n instance, version = divmod(ver_inst, 2**4)\n return rec_type, rec_size, (instance, version)","def recv(self) -> tuple:\n (data, c) = self.socket.recvfrom(Rudp.Packet.buffer())\n # print(data)\n (packet, validity) = Rudp.Packet.unpack(data)\n if(validity):\n print(\"Valid Packet Received From: \", c)\n else:\n raise Rudp.InvalidPacket(\"Invalid Packet Received\")\n\n return (packet, validity, c)","def __getHeaderInfo(self, decoded_data):\n\t\tip = decoded_data.child()\n\t\ttcp = ip.child()\n\t\t#src = (ip.get_ip_src(), tcp.get_th_sport())\n\t\ttry:\tsrc = ip.get_ip_src()\n\t\texcept:\tsrc = '?'\n\t\t#dst = (ip.get_ip_dst(), tcp.get_th_dport())\n\t\ttry:\tdst = ip.get_ip_dst()\n\t\texcept:\tdst = '?'\n\t\t#data = tcp.get_data_as_string()\n\t\tdata = tcp.get_packet()\n\t\treturn (src, dst, data)","def get_device_info(ns, device, human_friendly):\n if device.NumberOfBlocks and device.BlockSize:\n size = size2str(device.NumberOfBlocks * device.BlockSize, human_friendly)\n else:\n size = 'N/A'\n\n fslabel = fs.get_device_format_label(ns, device)\n return (device.DeviceID,\n device.Name,\n device.ElementName,\n size,\n fslabel)","def test_snmpget_return_structure():\n result = snmpget(community='public', ipaddress=SNMP_SRV_ADDR,\n oid=SYSDESCR_OID, port=SNMP_SRV_PORT)\n assert 'Linux' in result\n assert isinstance(result, str)","def _decode_header(self, buf):\n ord_data = self._decode_vint(buf)\n f_type = ord_data & 7\n f_id = ord_data >> 3\n return f_type, f_id","def _structUnpack(fmt, data, offs=0, _depth=0):\n assert _depth < 10, \"Maximum depth exceeded\"\n if type(fmt) is str:\n r = struct.unpack_from(fmt, data, offs)\n if len(r) == 1: return r[0] # grumble\n return r\n\n # fmt is ( offset, type, name[, count] ) or a tuple of such\n res = {}\n if type(fmt[0]) is not tuple: fmt = (fmt,)\n for item in fmt:\n if len(item) > 3:\n itemOffs, itemType, itemName, itemCount = item\n else:\n itemOffs, itemType, itemName = item\n itemCount = 1\n size = struct.calcsize(_structTupleToFmt(itemType))\n val = []\n for i in range(itemCount):\n val.append(_structUnpack(itemType, data, offs=offs, _depth=_depth+1))\n offs += size\n if len(val) == 1: res[itemName] = val[0]\n else: res[itemName] = val\n return res","def my_structure_info(self, structure_id):\n r = requests.get(self.base_url + f'/users/{self.username}/structures/{structure_id}', headers=self.auth_header)\n return r.text","def get_external_struct(self):\n self.download_structure()\n parser = MMCIFParser()\n structure = parser.get_structure('STRUCT_OBJ',\n os.path.join(self.struct_dir, self.struct_name) + '.cif')\n return structure","def read_raw_packet(self):\n\n size = 0\n\n # Read our two-byte header from the debugger...\n while not size:\n size = (self._get_next_byte() << 16) | self._get_next_byte()\n\n # ... and read our packet.\n packet = bytearray([self._get_next_byte() for _ in range(size)])\n\n # Return our packet.\n # TODO: extract and provide status flags\n # TODO: generate a timestamp on-device\n return packet, datetime.now(), None","def to_struct(self):\n return parsers.to_struct(self)","def interpret_packet_value_pair(data):\n if data is None:\n return None, None\n packet_type = int.from_bytes(data[3:4], 'little')\n name = value = None\n if packet_type == 1:\n name = str(data[17:], 'utf8') \n value = float(ustruct.unpack('<i', data[12:16])[0])\n elif packet_type == 5:\n name = str(data[21:29], 'ascii').strip()\n value = ustruct.unpack('<d', data[12:20])[0]\n else:\n display.scroll('Packet type {} not recognised'.format(packet_type))\n return name, value","def DNL(fp):\n length = unpack('>H', fp.read(2))[0]\n _nl = unpack('>H', fp.read(2))[0]\n\n info = {\n 'Ld' : length,\n 'NL' : _nl\n }\n\n return info","def get_struct (self):\n return self._intern","def structure(self):\n return self.struct","def get_arp_info(pkt):\n if len(pkt) < 8:\n raise ARPError(\"ARP header too short\")\n ar_hrd, ar_pro, ar_hln, ar_pln, ar_op = struct.unpack(\"!HHBBH\", pkt[0:8])\n pkt_len = 8+(2*ar_hln)+(2*ar_pln)\n if len(pkt) < pkt_len:\n raise ARPError(\"ARP packet too short\")\n ofs = 8\n ar_sha = pkt[ofs:ofs+ar_hln]\n ofs += ar_hln\n ar_spa = pkt[ofs:ofs+ar_pln]\n ofs += ar_pln\n ar_tha = pkt[ofs:ofs+ar_hln]\n ofs += ar_hln\n ar_tpa = pkt[ofs:ofs+ar_pln]\n ofs += ar_pln\n return (ar_hrd, ar_pro, ar_hln, ar_pln,\n ar_op, ar_sha, ar_spa, ar_tha, ar_tpa)","def ProtocolInformation(self) -> _n_0_t_7[_n_0_t_6]:","def print_info(self):\n \n print \"\"\"version: %d\\t header_len: %d\\t tos: %s\\t total_len: %d\n id: %s\\t flags_reservedbit: %d\\t flags_dont_fragment: %d\\t flags_more_fragment: %d\n fragment_offset: %d\\t TTL: %d\\t protocol: %s\\t\n header_checksum: %s\\t\n src: %s\\t dst: %s\n opt_paddings: %s\"\"\" % (\n self.version, self.header_len, self.type_of_service, self.total_len, self.id, self.flags_reservedbit, \n self.flags_dont_fragment, self.flags_more_fragment, \n self.fragment_offset, self.TTL, self.protocol, self.header_checksum, self.src, self.dst, repr(self.opt_paddings))","def decode(self, msg):\n if len(msg) < 2:\n raise ValueError(\"Message is too short - can't fit a preamble\")\n preamble = msg[:2]\n \n (x,) = struct.unpack(\"<H\", preamble)\n \n ID = (x & self.ID_MASK) >> 4\n LEN = x & self.LEN_MASK\n\n if LEN < 0 or LEN > 8:\n raise ValueError(\"Invalid CAN payload length - %d bytes not in [0,8] bytes\" % LEN)\n\n if LEN != len(msg[2:]):\n raise ValueError(\"Length from preamble %d mismatches actual length %d in packet w/id %#x\" %\n (LEN, len(msg[2:]), ID))\n\n TIME = datetime.datetime.utcnow()\n \n if ID in self.descriptors:\n desc = self.descriptors[ID]\n if \"format\" not in desc:\n raise ValueError(\"No format specified for %#x:%s\" % (ID, desc[\"name\"]))\n if LEN != struct.calcsize(\"<\" + str(desc[\"format\"])):\n raise ValueError(\"Error in decoding message id=%#x name=%s - length field %d mismatches descriptor %d\"\n % (ID, desc[\"name\"], LEN, struct.calcsize(\"<\" + str(desc[\"format\"]))))\n\n DATA = struct.unpack(\"<\" + str(desc[\"format\"]), msg[2:2+LEN])\n \n return (TIME, ID, desc, DATA)\n else:\n raise ValueError(\"Unknown message id=%#x, len=%d, data=%r\" % (ID, LEN, msg[2:]))","def _parse_ctrl_block_attrs(raw):\n std_mask, _, ext_mask = struct.unpack('HHI', raw[:8])\n std_attrs = struct.unpack('I' * 16, raw[8:72])\n ext_attrs = struct.unpack('I' * 32, raw[72:200])\n return {\n 'std_mask': std_mask,\n 'ext_mask': ext_mask,\n 'std_attrs': std_attrs,\n 'ext_attrs': ext_attrs\n }","def get_secondary_structure_string(self):\n d = self.data\n struc = self.struc\n \n n = 0\n output = \"\"\n for i, (ires, inscode, chain, aa, sec_struc) in enumerate(zip(d.resnum, d.inscode, d.chain, d.aa, d.struct)):\n if aa == \"!*\":\n continue\n S = sec_struc[0]\n res = self.struc[n]\n assert res.ires == int(ires)\n assert res.inscode == inscode\n assert res.chain == chain\n output += S\n n += 1\n \n assert len(output) == len(struc)\n return output","def _read_old_header(self, raw):\n\n byte_count = 0\n\n data_size = 4\n self.label = struct.unpack('<4s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.version = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.revision = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 26\n self.date = struct.unpack('<26s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.file_format = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.file_type = struct.unpack('<4s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.original_file_name = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.reference_file_name = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.related_file_name_a = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.related_file_name_b = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.related_file_name_c = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.related_file_name_d = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 82\n self.annotate = struct.unpack('<82s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 33\n self.instrument_model = struct.unpack('<33s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 33\n self.instrument_serial_number = struct.unpack('<33s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 33\n self.software_version_number = struct.unpack('<33s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 33\n self.crystal_material = struct.unpack('<33s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.laser_wavelength_microns = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.laser_null_doubling = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.optical_ratio = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.dispersion_constant_xc = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.dispersion_constant_xm = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.dispersion_constant_xb = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.interferogram_size = struct.unpack('<H',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.interferogram_center.append(struct.unpack('<H',\n raw[byte_count:byte_count+data_size])[0])\n byte_count += data_size\n\n data_size = 2\n self.interferogram_center.append(struct.unpack('<H',\n raw[byte_count:byte_count+data_size])[0])\n byte_count += data_size\n\n data_size = 2\n self.acquire_mode = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.emissivity = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.apodization = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.zero_fill = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.run_time_math = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.fft_size = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.number_of_coadds = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 2\n self.number_of_igrams = struct.unpack('<h',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.amb_temperature = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.inst_temperature = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.wbb_temperature = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.cbb_temperature = struct.unpack('<f',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 20\n self.spare_i = struct.unpack('<hhhhhhhhhh',\n raw[byte_count:byte_count+data_size])\n byte_count += data_size\n\n data_size = 40\n self.spare_f = struct.unpack('<ffffffffff',\n raw[byte_count:byte_count+data_size])\n byte_count += data_size\n\n data_size = 40\n self.spare_l = struct.unpack('<ffffffffff',\n raw[byte_count:byte_count+data_size])\n byte_count += data_size\n\n data_size = 65\n self.spare_na = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.spare_nb = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.spare_nc = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.spare_nd = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 65\n self.spare_ne = struct.unpack('<65s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.header_end = struct.unpack('<4s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size","def unpack(self, fmt, length=1):\n return struct.unpack(fmt, self.stream.read(length))[0]","def dce_rpc_endianess(pkt):\n try:\n endianness = pkt.underlayer.endianness\n except AttributeError:\n # handle the case where a PNIO class is\n # built without its DCE-RPC under-layer\n # i.e there is no endianness indication\n return \"!\"\n if endianness == 0: # big endian\n return \">\"\n elif endianness == 1: # little endian\n return \"<\"\n else:\n return \"!\"","def getfield(self, pkt, s):\n class_id = getattr(pkt, self._entity_class)\n attribute_mask = getattr(pkt, self._attributes_mask)\n entity_class = omci_entities.entity_id_to_class_map[class_id]\n indices = entity_class.attribute_indices_from_mask(attribute_mask)\n data = {}\n table_attribute_mask = 0\n for index in indices:\n try:\n fld = entity_class.attributes[index].field\n except IndexError as e:\n log.error(\"attribute-decode-failure\", attribute_index=index,\n entity_class=entity_class, e=e)\n continue\n try:\n s, value = fld.getfield(pkt, s)\n except Exception as _e:\n raise\n if isinstance(pkt, OmciGetResponse) and isinstance(fld, OmciTableField):\n data[fld.name + '_size'] = value\n table_attribute_mask = table_attribute_mask | (1 << (16 - index))\n else:\n data[fld.name] = value\n if table_attribute_mask:\n data['table_attribute_mask'] = table_attribute_mask\n return s, data","def _decode(self):\n \n self.version = int(data_to_hex_str(self.packet[0])[2])\n self.header_len = int(data_to_hex_str(self.packet[0])[3]) * 4\n self.type_of_service = data_to_hex_str(self.packet[1:2])\n self.total_len = int(data_to_hex_str(self.packet[2:4]), 16)\n self.id = data_to_hex_str(self.packet[4:6])\n \n #parse the flags fields(reservedbit, don't fragment, more fragment)\n if ((ord(self.packet[6]) & (1 << 7)) != 0):\n self.flags_reservedbit = 1\n else:\n self.flags_reservedbit = 0\n #endof if\n \n if ((ord(self.packet[6]) & (1 << 6)) != 0):\n self.flags_dont_fragment = 1\n else:\n self.flags_dont_fragment = 0\n #endof if\n \n if ((ord(self.packet[6]) & (1 << 5)) != 0):\n self.flags_more_fragment = 1\n else:\n self.flags_more_fragment = 0\n #endof if\n \n #parse the offset field(in packet[6:7]): 00011111 & packet[6] (to filter flags) -->> get packet[6:7] in hex_str\n #tmp = str(31 & ord(self.packet[6]))\n self.fragment_offset = int(data_to_hex_str(self.packet[6:8]), 16)\n if (self.fragment_offset >= (1 << 13)):\n #take away the flags fields: 00011111 11111111 & self.fragment_offset\n self.fragment_offset = self.fragment_offset & ((1 << 13) - 1) \n \n self.TTL = ord(self.packet[8])\n self.protocol = IPPROTO[ord(self.packet[9])]\n self.header_checksum = data_to_hex_str(self.packet[10:12])\n \n self.src = str(ord(self.packet[12])) + '.' + str(ord(self.packet[13])) + '.' + \\\n str(ord(self.packet[14])) + '.' + str(ord(self.packet[15]))\n self.dst = str(ord(self.packet[16])) + '.' + str(ord(self.packet[17])) + '.' + \\\n str(ord(self.packet[18])) + '.' + str(ord(self.packet[19]))\n \n if (self.header_len > 20):\n self.opt_paddings = self.packet[20 : (self.header_len)]","def get_uploaded_struct(self):\n parser = PDBParser()\n structure = parser.get_structure('STRUCT_OBJ',\n os.path.join(self.struct_dir, self.struct_name))\n return structure","def unpack(self, fmt):\n try:\n data = self.get(struct.calcsize(fmt))\n return struct.unpack(fmt, data)\n except struct.error as e:\n raise BufferError(\n \"Error unpacking struct '%s' <%s>\" %\n (fmt, binascii.hexlify(data).decode())\n )","def read_uef_details(chunks):\n\n\tpos, chunk = find_next_chunk(chunks, 0, [0x0])\n\n\tif pos == None:\n\n\t\toriginator = 'Unknown'\n\n\telif chunk[1] == '':\n\n\t\toriginator = 'Unknown'\n\telse:\n\t\toriginator = chunk[1]\n\n\tpos, chunk = find_next_chunk(chunks, 0, [0x5])\n\n\tif pos == None:\n\n\t\tmachine, keyboard = 'Unknown', 'Unknown'\n\n\telse:\n\n\t\tmachines = ('BBC Model A', 'Electron', 'BBC Model B', 'BBC Master')\n\t\tkeyboards = ('Any layout', 'Physical layout', 'Remapped')\n\n\t\tmachine = ord(chunk[1][0]) & 0x0f\n\t\tkeyboard = (ord(chunk[1][0]) & 0xf0) >> 4\n\n\t\tif machine < len(machines):\n\t\t\tmachine = machines[machine]\n\t\telse:\n\t\t\tmachine = 'Unknown'\n\n\t\tif keyboard < len(keyboards):\n\t\t\tkeyboard = keyboards[keyboard]\n\t\telse:\n\t\t\tkeyboard = 'Unknown'\n\n\tpos, chunk = find_next_chunk(chunks, 0, [0xff00])\n\n\tif pos == None:\n\n\t\temulator = 'Unknown'\n\n\telif chunk[1] == '':\n\n\t\temulator = 'Unknown'\n\telse:\n\t\temulator = chunk[1]\n\n\n\t# Remove trailing null bytes\n\twhile originator[-1] == '\\000':\n\n\t\toriginator = originator[:-1]\n\n\twhile emulator[-1] == '\\000':\n\n\t\temulator = emulator[:-1]\n\n\tfeatures = ''\n\tif find_next_chunk(chunks, 0, [0x1])[0] != None:\n\t\tfeatures = features + '\\n' + 'Instructions'\n\tif find_next_chunk(chunks, 0, [0x2])[0] != None:\n\t\tfeatures = features + '\\n' + 'Credits'\n\tif find_next_chunk(chunks, 0, [0x3])[0] != None:\n\t\tfeatures = features + '\\n' + 'Inlay'\n\n\treturn originator, machine, keyboard, emulator, features","def info(self):\n return (self.kind, self.value)","def deserialize(self, str):\n try:\n end = 0\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.name = str[start:end].decode('utf-8')\n else:\n self.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.red_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.red_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.yellow_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.yellow_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.green_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.green_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.purple_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.purple_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.orange_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.orange_v = struct.unpack(pattern, str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def from_struct(cls, struct):\n return str(struct)","def bytes2obj(buf: bytes) -> StunPacket:\n\n type_raw, length, magic_cookie, transaction_id = unpack_from(\n HEADER_FORMAT, buf, 0)\n\n # Convert message type into bits, to parse it as a class and method.\n type_bits: str = bin(type_raw)[2:].zfill(16)\n if type_bits[:2] != \"00\":\n raise Exception(\n \"STUN packet invalid - most signifigant 2 bits must be zeroes.\")\n type_class = type_bits[7] + type_bits[11]\n type_method = type_bits[2:7] + type_bits[8:11] + type_bits[12:]\n\n message_bytes = unpack_from('!{}s'.format(\n length), buf, calcsize(HEADER_FORMAT))[0]\n # if magic_cookie != bytes.fromhex(\"2112A442\"):\n # print(\"Warning: Request not RFC 8489 compilant.\")\n\n message_read = 0\n message: Dict[bytes, bytes] = {}\n while message_read < length:\n attribute_type, attribute_length = unpack_from(\n ATTRIBUTE_HEADER_FORMAT, message_bytes, message_read\n )\n attribute_val = unpack_from(\n \"!{}s\".format(attribute_length), message_bytes, message_read +\n calcsize(ATTRIBUTE_HEADER_FORMAT)\n )[0]\n message[attribute_type] = attribute_val\n\n message_read += calcsize(ATTRIBUTE_HEADER_FORMAT)\n message_read += attribute_length\n\n return StunPacket(type_class, type_method, magic_cookie, transaction_id, message)","def dump(self) : \n mybuffer = []\n if None not in (self.version, self.operation_id) :\n mybuffer.append(chr(self.version[0]) + chr(self.version[1]))\n mybuffer.append(pack(\">H\", self.operation_id))\n mybuffer.append(pack(\">I\", self.request_id or 1))\n for attrtype in self.attributes_types :\n for attribute in getattr(self, \"_%s_attributes\" % attrtype) :\n if attribute :\n mybuffer.append(chr(self.tagvalues[\"%s-attributes-tag\" % attrtype]))\n for (attrname, value) in attribute :\n nameprinted = 0\n for (vtype, val) in value :\n mybuffer.append(chr(self.tagvalues[vtype]))\n if not nameprinted :\n mybuffer.append(pack(\">H\", len(attrname)))\n mybuffer.append(attrname)\n nameprinted = 1\n else :\n mybuffer.append(pack(\">H\", 0))\n if vtype in (\"integer\", \"enum\") :\n mybuffer.append(pack(\">H\", 4))\n mybuffer.append(pack(\">I\", val))\n elif vtype == \"boolean\" :\n mybuffer.append(pack(\">H\", 1))\n mybuffer.append(chr(val))\n else :\n mybuffer.append(pack(\">H\", len(val)))\n mybuffer.append(val)\n mybuffer.append(chr(self.tagvalues[\"end-of-attributes-tag\"]))\n mybuffer.append(self.data)\n return \"\".join(mybuffer)","def getRecord(self, rr):\n\t\tif rr.type == 1: return {'type': 'a', 'ipv4': socket.inet_ntoa(rr.rdata), 'hostname': rr.name}\n\t\telif rr.type == 28: return {'type': 'aaaa', 'ipv6': socket.inet_ntop(socket.AF_INET6, rr.rdata), 'hostname': rr.name}\n\t\telif rr.type == 5: return {'type': 'cname', 'hostname': rr.name, 'cname': rr.cname}\n\t\telif rr.type == 13: return {'type': 'hostinfo', 'hostname': rr.name, 'info': rr.rdata}\n\t\telif rr.type == 33: return {'type': 'srv', 'hostname': rr.srvname, 'port': rr.port, 'srv': rr.name.split('.')[-3], 'proto': rr.name.split('.')[-2]}\n\t\telif rr.type == 12: return {'type': 'ptr'}\n\t\telif rr.type == 16: return {'type': 'txt'}\n\t\telif rr.type == 10: return {'type': 'wtf'}","def deserialize(self, str):\n try:\n if self.accelerometer is None:\n self.accelerometer = None\n if self.gyro is None:\n self.gyro = None\n if self.orientation is None:\n self.orientation = None\n if self.led_color is None:\n self.led_color = None\n end = 0\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.name = []\n for i in range(0, length):\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1 = str[start:end].decode('utf-8')\n else:\n val1 = str[start:end]\n self.name.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.position = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.velocity = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.effort = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.position_command = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.velocity_command = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.effort_command = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.accelerometer = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Vector3()\n _x = val1\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end])\n self.accelerometer.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.gyro = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Vector3()\n _x = val1\n start = end\n end += 24\n (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end])\n self.gyro.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.orientation = []\n for i in range(0, length):\n val1 = geometry_msgs.msg.Quaternion()\n _x = val1\n start = end\n end += 32\n (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end])\n self.orientation.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.deflection = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.deflection_velocity = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.motor_velocity = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.motor_current = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.motor_winding_current = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.motor_sensor_temperature = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.motor_winding_temperature = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.motor_housing_temperature = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.board_temperature = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.processor_temperature = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.voltage = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.led_color = []\n for i in range(0, length):\n val1 = std_msgs.msg.ColorRGBA()\n _x = val1\n start = end\n end += 16\n (_x.r, _x.g, _x.b, _x.a,) = _get_struct_4f().unpack(str[start:end])\n self.led_color.append(val1)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sQ'%length\n start = end\n end += struct.calcsize(pattern)\n self.sequence_number = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sQ'%length\n start = end\n end += struct.calcsize(pattern)\n self.receive_time = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sQ'%length\n start = end\n end += struct.calcsize(pattern)\n self.transmit_time = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sQ'%length\n start = end\n end += struct.calcsize(pattern)\n self.hardware_receive_time = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sQ'%length\n start = end\n end += struct.calcsize(pattern)\n self.hardware_transmit_time = struct.unpack(pattern, str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def parse_event_attlog(self):\n uid = ''\n ver_type = -1\n date_str = ''\n if self.last_event_code == DEFS.EF_ATTLOG:\n uid = self.last_payload_data[0:9].decode('ascii').\\\n replace('\\x00', '')\n ver_type = struct.unpack('<H', self.last_payload_data[24:26])[0]\n date_str = \"20%i/%i/%i %i:%i:%i\" %\\\n tuple(self.last_payload_data[26:32])\n\n return [uid, ver_type, date_str]","def _read_new_header(self, raw):\n\n byte_count = 0\n\n data_size = 4\n self.label = struct.unpack('<4s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.version = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.revision = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 28\n self.date = struct.unpack('<28s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.file_format = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.file_type = struct.unpack('<4s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.original_file_name = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.reference_file_name = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.related_file_name_a = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.related_file_name_b = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.related_file_name_c = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 84\n self.annotate = struct.unpack('<84s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 36\n self.instrument_model = struct.unpack('<36s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 36\n self.instrument_serial_number = struct.unpack('<36s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 36\n self.software_version_number = struct.unpack('<36s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 36\n self.crystal_material = struct.unpack('<36s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.laser_wavelength_microns = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.laser_null_doubling = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.padding = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.dispersion_constant_xc = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.dispersion_constant_xm = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.dispersion_constant_xb = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.num_chan = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.interferogram_size = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.scan_direction = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.acquire_mode = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.emissivity = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.apodization = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.zero_fill = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.run_time_math = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.fft_size = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.number_of_coadds = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.single_sided = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.chan_display = struct.unpack('<l',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.amb_temperature = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.inst_temperature = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.wbb_temperature = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.cbb_temperature = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.temperature_dwr = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.emissivity_dwr = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 8\n self.laser_temperature = struct.unpack('<d',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 40\n self.spare_i = struct.unpack('<llllllllll',\n raw[byte_count:byte_count+data_size])\n byte_count += data_size\n\n data_size = 80\n self.spare_f = struct.unpack('<dddddddddd',\n raw[byte_count:byte_count+data_size])\n byte_count += data_size\n\n data_size = 68\n self.spare_na = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.spare_nb = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.spare_nc = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.spare_nd = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 68\n self.spare_ne = struct.unpack('<68s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size\n\n data_size = 4\n self.header_end = struct.unpack('<4s',\n raw[byte_count:byte_count+data_size])[0]\n byte_count += data_size","def tcp_pkt_debug_info(pkt: dpkt.ip.IP) -> str:\n if isinstance(pkt, dpkt.ip.IP):\n paylod_len = pkt.len - (4 * pkt.hl) - (4 * pkt.data.off)\n return \"{}:{}-> {}:{}, seq: {}, ack:{}, flag:{}, payload len: {}, payload: {}, sum: {}\".format(\n inet_to_str(pkt.src), pkt.data.sport, inet_to_str(pkt.dst), pkt.data.dport, hex(pkt.data.seq),\n hex(pkt.data.ack), hex(pkt.data.flags), hex(paylod_len), pkt.data.data, hex(pkt.data.sum))","def deserialize(self, str):\n try:\n end = 0\n start = end\n end += 8\n (self.time,) = _get_struct_d().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.q_target = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.qd_target = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.qdd_target = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.i_target = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.m_target = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.q_actual = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.qd_actual = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.i_actual = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.tool_acc_values = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.tcp_force = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.tool_vector = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.tcp_speed = struct.unpack(pattern, str[start:end])\n start = end\n end += 8\n (self.digital_input_bits,) = _get_struct_d().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.motor_temperatures = struct.unpack(pattern, str[start:end])\n _x = self\n start = end\n end += 24\n (_x.controller_timer, _x.test_value, _x.robot_mode,) = _get_struct_3d().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.joint_modes = struct.unpack(pattern, str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) # most likely buffer underfill","def _determine_integer_format(self) -> Dict[int, struct.Struct]:\n endianness_byte = self._elf.read(1) # e_ident[EI_DATA] (endianness)\n if endianness_byte == b'\\x01':\n endianness = '<'\n elif endianness_byte == b'\\x02':\n endianness = '>'\n else:\n raise FileDecodeError(\n 'Unknown endianness {!r}'.format(endianness_byte))\n\n return {\n 1: struct.Struct(endianness + 'B'),\n 2: struct.Struct(endianness + 'H'),\n 4: struct.Struct(endianness + 'I'),\n 8: struct.Struct(endianness + 'Q'),\n }","def get_structure_from_cif(cifdata):\n return cifdata.get_structure()","def make_out_struct(self):\n args ={\n \"name\": self.python_madz_types + (\"OUTSTRUCT\" if self.namespace == \"\" else self._namespace_mangle(self.namespace)),\n \"fields\":\"\"\n }\n\n res = \\\n\"\"\"class {name}(Structure):\n _fields_ = [{fields}]\n\"\"\"\n for node in self.description.definitions():\n args['fields'] += self.gen_type_tuple_string(node.name, node.type) + \", \"\n\n return res.format(**args)","def serialize(self):\n return (self.handle, self.gramps_id, self.type.serialize(),\n cuni(self.name),\n NoteBase.serialize(self),\n AddressBase.serialize(self),\n UrlBase.serialize(self),\n self.change, TagBase.serialize(self), self.private)","def get_info(self):\n\t\tret = 'Flash info\\n'\n\t\tret += '\\tGPNVM bits: ' + str(self.read_gpnvm()) + '\\n'\n\t\tret += '\\tUnique identifier area: ' + self.read_unique_identifier_area().decode('ascii', 'replace') + '\\n'\n\t\tret += '\\tDescriptor: ' + str(self.read_descriptor()) + '\\n'\n\t\treturn ret","def complete_read_struct(self, text, line, begidx, endidx):\n begidx = begidx\n endidx = endidx\n mline = line.partition(' ')[2]\n offs = len(mline) - len(text)\n map_records = [*self.phil.mem_map]\n map_structs = []\n for record in map_records:\n first_name = record.split('.')[0]\n if first_name not in map_structs:\n map_structs.append(first_name)\n return [s[offs:] for s in map_structs if s.startswith(mline)]","def unpackRecHeader(self):\n return self.unpack('4s3i',16,'REC_HEAD')","def print_device_info(device_info):\n assert(isinstance(device_info, tuple))\n assert(len(device_info) == 4)\n print(\" Device Name : %s\" % device_info[0])\n print(\" OS Type : %s\" % device_info[1])\n print(\" IP Address : %s\" % device_info[2])\n print(\" Interfaces : %s\" % device_info[3])","def read(self, fmt):\n fmt = '>' + fmt\n if not PY3:\n fmt = fmt.encode('utf-8')\n return struct.unpack(fmt, self.bin.read(format_byte_size(fmt)))","def parse_info(s:str) -> dict:\n d = {}\n d[\"SVTYPE\"] = re.search(r'(?<=SVTYPE=)\\w+',s).group(0)\n d[\"SUPPORT\"] = re.search(r'(?<=SUPPORT=)\\d+',s).group(0)\n if d[\"SVTYPE\"] in [\"BND\"]:\n return d\n d[\"END\"] = re.search(r'(?<=END=)\\d+',s).group(0)\n if d[\"SVTYPE\"] in [\"INV\"]:\n return d\n d[\"SVLEN\"] = re.search(r'(?<=SVLEN=)(.*?)(?=;)',s).group(0)\n d[\"READS\"] = re.search(r'(?<=READS=)(.*?)(?=$)',s).group(0).split(\",\")\n if d[\"SVTYPE\"] == \"INS\":\n d[\"SEQS\"] = re.search(r'(?<=SEQS=)(.*?)(?=;)',s).group(0).split(\",\")\n return d","def debug_info_struct(fdt):\n # Traverse node tree in depth first\n depth = 0\n path = b''\n root = fdt.get_root_node()\n debug_node(fdt, root, depth, path)","def read_struct_file(struct_file,return_type=GeoStruct):\n\n VARTYPE = {1:SphVario,2:ExpVario,3:GauVario,4:None}\n assert os.path.exists(struct_file)\n structures = []\n variograms = []\n with open(struct_file,'r') as f:\n while True:\n line = f.readline()\n if line == '':\n break\n line = line.strip().lower()\n if line.startswith(\"structure\"):\n name = line.strip().split()[1]\n nugget,transform,variogram_info = _read_structure_attributes(f)\n s = return_type(nugget=nugget,transform=transform,name=name)\n s.variogram_info = variogram_info\n # not sure what is going on, but if I don't copy s here,\n # all the structures end up sharing all the variograms later\n structures.append(copy.deepcopy(s))\n elif line.startswith(\"variogram\"):\n name = line.strip().split()[1].lower()\n vartype,bearing,a,anisotropy = _read_variogram(f)\n if name in variogram_info:\n v = VARTYPE[vartype](variogram_info[name],a,anisotropy=anisotropy,\n bearing=bearing,name=name)\n variograms.append(v)\n\n for i,st in enumerate(structures):\n for vname in st.variogram_info:\n vfound = None\n for v in variograms:\n if v.name == vname:\n vfound = v\n break\n if vfound is None:\n raise Exception(\"variogram {0} not found for structure {1}\".\\\n format(vname,s.name))\n\n st.variograms.append(vfound)\n if len(structures) == 1:\n return structures[0]\n return structures","def getStructPb2():\n return struct_pb2","def __parse_tree(self, packet):\n info = extract_int_data(packet[Ether])\n logger.info('Processing packet with info [%s]', info)\n\n macs = search.findall_by_attr(self.tree, info.get('srcMac'),\n name='name', maxlevel=2, maxcount=1)\n\n mac = None\n src_ip = None\n dst_ip = None\n dst_port = None\n packet_size = None\n\n if len(macs) > 0:\n mac = macs[0]\n src_ips = search.findall_by_attr(\n mac, info.get('srcIP'), name='name', maxlevel=2, maxcount=1)\n if len(src_ips) is not 0:\n src_ip = src_ips[0]\n dst_ips = search.findall_by_attr(\n src_ip, info.get('dstIP'), name='name', maxlevel=2,\n maxcount=1)\n if len(dst_ips) is not 0:\n dst_ip = dst_ips[0]\n logger.info('Processing source IPs - %s', src_ips)\n dst_ports = search.findall_by_attr(\n dst_ip, info.get('dstPort'), name='name',\n maxlevel=2, maxcount=1)\n if len(dst_ports) is not 0:\n dst_port = dst_ports[0]\n packet_sizes = search.findall_by_attr(\n dst_port, info.get('packet_size'),\n name='name', maxlevel=2, maxcount=1)\n if len(packet_sizes) is not 0:\n packet_size = packet_sizes[0]\n\n return mac, src_ip, dst_ip, dst_port, packet_size","def get_net_message():\n # TODO: refactor to use a list of events encoded using masgpack?\n try:\n message, address = serverSocket.recvfrom(1024)\n except:\n return None, None\n message = message.decode('utf-8')\n return message, address","def _parse_general_info_V4X(par, parfile):\n line = None\n while line != '':\n pos = parfile.tell()\n line = parfile.readline()\n #Parse the useful parts of the general info entry on the left and\n #right of the colon: key and value\n m = re.search(r'\\. ([^<>\\(\\)\\[\\]]*[a-zA-Z]).*: *(.*)', line)\n if not m:\n parfile.seek(pos)\n break\n key, val = m.group(1, 2)\n key = _sanitize_to_identifer(key).lower()\n #Try to guess the type of the field by conversion\n _val_split = val.split()\n if len(_val_split) > 1:\n try:\n val = np.array(tuple(float(x) for x in _val_split))\n except:\n pass\n else:\n try:\n val = int(val)\n except ValueError:\n pass\n #logger.debug(\"Key = '{0}' Val = '{1}'\".format(key, val))\n setattr(par.gen_info, key, val)\n return par.gen_info","def grab_cmd_info(cmd):\n r = requests.get(cmd.url)\n r.raise_for_status()\n soup_cmd = bs4.BeautifulSoup(r.text, 'lxml')\n\n # get body text, sanitise\n body = soup_cmd.body.text\n body = re.sub(r'\\n\\n+', '\\n', body) # get rid of extra lines\n body = re.sub(r'\\n[\\s\\xa0]+', '\\n', body) # remove leading spaces\n body = re.sub(r'[\\s\\xa0]+\\n', '\\n', body) # remove trailing spaces\n\n info = {}\n\n # get brief description\n p_brief = re.compile(cmd.name+r'\\n([\\d\\w.()-/ \\'\\n]*)\\nSynopsis', re.IGNORECASE)\n brief_search = p_brief.search(body)\n if brief_search:\n info['brief'] = brief_search.group(1).replace('\\n', ' ')\n else:\n print 'No brief info for', cmd.name\n info['brief'] = None\n\n # get synopsis\n p_synopsis = re.compile(r'Synopsis\\n('+cmd.name+r'.+)[\\n ]+Description', re.IGNORECASE | re.DOTALL)\n synopsis_search = p_synopsis.search(body)\n if synopsis_search:\n synopsis_raw = synopsis_search.group(1)\n info['synopsis'] = [i.replace('\\n', ' ').strip() for i in synopsis_raw.split(cmd.name) if i]\n else:\n print 'No synopsis info for', cmd.name\n info['synopsis'] = None\n\n # get description\n# p_desc = re.compile(r'Description\\n(.*?)\\nOptions', re.IGNORECASE | re.DOTALL)\n return info","def packetDump(packet):\n hex = ''\n start = 0\n size = 16\n ln = len(packet)\n while start < ln:\n # print line number\n line = '%04x ' % start\n #print hex representation\n c = 0\n asc = packet[start:min(start+size, ln)]\n for b in asc:\n if c == 8:\n line = line + ' '\n line = line + '%02x ' % ord(b)\n c = c + 1\n line = ljust(line, 58) + '\"'\n # print ascii representation, replace unprintable characters with spaces\n for i in range(len(asc)):\n if ord(asc[i])<32 or ord(asc[i]) == 209:\n asc = replace(asc, asc[i], ' ')\n line = line + asc + '\"\\n' \n hex = hex + line\n start = start + size\n return hex.rstrip('\\n'), ln","def __str__(self):\n return '\\n%(source)s > %(type)s (0x%(type_d).2x)\\n%(data)s' % \\\n {'type': DGTL.pkt_type_str[self.type], 'type_d': self.type,\n 'data': str(self.decoded) if self.decoded else 'Unknown raw data.',\n 'source': self.source}","def handle_shoot(data: bytes) -> Tuple[bytes, str]:\n length = struct.unpack('H', data[:2])[0]\n name = data[2:length+2]\n direction = struct.unpack('fff', data[length+2:length+2+12])\n return data[2+length:], f'Shot {name.decode()} in direction: {direction}'","def decode_packet(data):\n\n opcodes = [(\"AUTH_LOGON_CHALLENGE\", \"\\x00\"), (\"AUTH_LOGON_PROOF\", \"\\x01\")]\n opcode = data[0] # Opcode of the received packet (First byte)\n if opcode == opcodes[0][1]: # Auth Logon challenge\n srp_rcvd = {\n 'error': data[1], # (you should hope that it is always 0)\n 'B': data[3:35], # Read B and skip 1 field (Length_g)\n 'g': data[36:37], # Read g and skip 1 field (Length_n)\n 'N': data[38:70],\n 's': data[70:102], # Read salt\n 'crc': data[102:] # (useless for private servers)\n }\n return srp_rcvd\n if opcode == opcodes[1][1]:\n # Auth logon proof\n if data[1] == \"\\x00\": # Code error: 0\n srp_rcvd = {'login': 1}\n else:\n srp_rcvd = {'login': 0}\n return srp_rcvd","def info(self, name):\n if isinstance(self._state[name], dict):\n attrs = self._state[name]['attrs']\n return '{} {}({}), {} records: {}'.format(\n attrs['type_str'], name, ','.join(attrs['domain']),\n attrs['records'], attrs['description'])\n else:\n return repr(self[name])","def deserialize(self, str):\n try:\n if self.header is None:\n self.header = std_msgs.msg.Header()\n if self.robot_id is None:\n self.robot_id = opil_v2.msg.Id()\n if self.agv_msg is None:\n self.agv_msg = opil_v2.msg.RobotDescriptionAGV()\n end = 0\n _x = self\n start = end\n end += 12\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.header.frame_id = str[start:end]\n start = end\n end += 4\n (self.robot_id.id,) = _get_struct_I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.robot_id.description = str[start:end].decode('utf-8')\n else:\n self.robot_id.description = str[start:end]\n _x = self\n start = end\n end += 12\n (_x.agv_msg.header.seq, _x.agv_msg.header.stamp.secs, _x.agv_msg.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.agv_msg.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.agv_msg.header.frame_id = str[start:end]\n start = end\n end += 4\n (self.agv_msg.vehicle_id.id,) = _get_struct_I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.agv_msg.vehicle_id.description = str[start:end].decode('utf-8')\n else:\n self.agv_msg.vehicle_id.description = str[start:end]\n _x = self\n start = end\n end += 84\n (_x.agv_msg.left_size, _x.agv_msg.right_size, _x.agv_msg.front_size, _x.agv_msg.rear_size, _x.agv_msg.min_height, _x.agv_msg.max_height, _x.agv_msg.payload, _x.agv_msg.max_pos_x_vel, _x.agv_msg.max_neg_x_vel, _x.agv_msg.max_pos_x_acc, _x.agv_msg.max_neg_x_acc, _x.agv_msg.max_pos_y_vel, _x.agv_msg.max_neg_y_vel, _x.agv_msg.max_pos_y_acc, _x.agv_msg.max_neg_y_acc, _x.agv_msg.max_pos_ang_vel, _x.agv_msg.max_neg_ang_vel, _x.agv_msg.velocity_control_sensitivity, _x.agv_msg.min_turning_radius, _x.agv_msg.batt_capacity, _x.agv_msg.batt_max_voltage,) = _get_struct_21f().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.agv_msg.vehicle_type = str[start:end].decode('utf-8')\n else:\n self.agv_msg.vehicle_type = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.agv_msg.vendor = str[start:end].decode('utf-8')\n else:\n self.agv_msg.vendor = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.agv_msg.action_capability = []\n for i in range(0, length):\n val1 = opil_v2.msg.RobotAction()\n _x = val1\n start = end\n end += 2\n (_x.category, _x.action,) = _get_struct_2B().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n val1.attributes = []\n for i in range(0, length):\n val2 = opil_v2.msg.Tuple()\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val2.type = str[start:end].decode('utf-8')\n else:\n val2.type = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val2.name = str[start:end].decode('utf-8')\n else:\n val2.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val2.value = str[start:end].decode('utf-8')\n else:\n val2.value = str[start:end]\n val1.attributes.append(val2)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.description = str[start:end].decode('utf-8')\n else:\n val1.description = str[start:end]\n self.agv_msg.action_capability.append(val1)\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def _read_packet_from_device(self, adb_info):\n msg = self._read_bytes_from_device(constants.MESSAGE_SIZE, adb_info)\n cmd, arg0, arg1, data_length, data_checksum = unpack(msg)\n command = constants.WIRE_TO_ID.get(cmd)\n\n if not command:\n raise exceptions.InvalidCommandError(\"Unknown command: %d = '%s' (arg0 = %d, arg1 = %d, msg = '%s')\" % (cmd, int_to_cmd(cmd), arg0, arg1, msg))\n\n if data_length == 0:\n return command, arg0, arg1, b\"\"\n\n data = self._read_bytes_from_device(data_length, adb_info)\n actual_checksum = checksum(data)\n if actual_checksum != data_checksum:\n raise exceptions.InvalidChecksumError(\"Received checksum {} != {}\".format(actual_checksum, data_checksum))\n\n return command, arg0, arg1, data","def unpack(self, data_type):\n\t\tif data_type in data_types:\n\t\t\tformat = data_types[data_type]\n\t\t\treturn self.unpack_real(format[0], format[1])\n\t\t\n\t\tif data_type == \"string8\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:length]\n\t\t\tself.buff = self.buff[length:]\n\t\t\treturn string\n\t\tif data_type == \"string16\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < 2*length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:2*length].decode('utf-16be')\n\t\t\tself.buff = self.buff[2*length:]\n\t\t\treturn string\n\t\tif data_type == \"slot\":\n\t\t\to = {}\n\t\t\to[\"id\"] = self.unpack('short')\n\t\t\tif o[\"id\"] > 0:\n\t\t\t\to[\"amount\"] = self.unpack('byte')\n\t\t\t\to[\"damage\"] = self.unpack('short')\n\t\t\tif o[\"id\"] in SLOT_EXTRA_DATA_IDS:\n\t\t\t\textra_len = self.unpack('short')\n\t\t\t\tif extra_len <= 0:\n\t\t\t\t\to[\"extra\"] = None\n\t\t\t\telse:\n\t\t\t\t\tif len(self.buff) < extra_len:\n\t\t\t\t\t\traise IncompleteData()\n\t\t\t\t\textra_buff = self.buff[:extra_len]\n\t\t\t\t\tself.buff = self.buff[extra_len:]\n\t\t\t\t\to[\"extra\"] = extra_buff\n\t\t\treturn o\n\t\tif data_type == \"metadata\":\n\t\t\t#[(17, 0), (0, 0), (16, -1)]\n\t\t\to = []\n\t\t\tmtype = self.unpack('byte')\n\t\t\twhile mtype != 127:\n\t\t\t\tmtype2 = mtype >> 5\n\t\t\t\tt = 0\n\t\t\t\tif mtype2 == 0: t = self.unpack('byte') \n\t\t\t\tif mtype2 == 1: t = self.unpack('short') \n\t\t\t\tif mtype2 == 2: t = self.unpack('int') \n\t\t\t\tif mtype2 == 3: t = self.unpack('float') \n\t\t\t\tif mtype2 == 4: t = self.unpack('string16')\n\t\t\t\tif mtype2 == 5:\n\t\t\t\t\tt = {}\n\t\t\t\t\tt[\"id\"] = self.unpack('short')\n\t\t\t\t\tt[\"count\"] = self.unpack('byte')\n\t\t\t\t\tt[\"damage\"] = self.unpack('short')\n\t\t\t\tif mtype2 == 6:\n\t\t\t\t\tt = []\n\t\t\t\t\tfor i in range(3):\n\t\t\t\t\t\ts = self.unpack('int')\n\t\t\t\t\t\tt.append(s)\n\t\t\t\tt = (mtype, t)\n\t\t\t\to.append(t)\n\t\t\t\tmtype = self.unpack('byte')\n\t\t\treturn o","def device_get_information_about(pnd, buf):\n return _nfc.device_get_information_about(pnd, buf)","def struct_dict(struct):\n get_pair = lambda field_type: (\n field_type[0], getattr(struct, field_type[0]))\n return dict(list(map(get_pair, struct._fields_)))","def get_general(soup):\n \n general_info = {}\n general_info.update(get_route_name(soup))\n general_info.update(get_box_data(soup))\n general_info.update(get_description(soup))\n general_info.update(get_hierarchy(soup))\n general_info.update(get_first_img_source(soup))\n\n return general_info","def get_rsp_ud2(self):\n resp_bytes = []\n resp_bytes.append(0x68) # start\n resp_bytes.append(0xFF) # length\n resp_bytes.append(0xFF) # length\n resp_bytes.append(0x68) # start\n resp_bytes.append(0x08) # C\n resp_bytes.append(self._primary_address) # A\n resp_bytes.append(0x72) # CI\n resp_bytes.extend(self.get_address_bytes())\n resp_bytes.extend(self.get_manufacturer_bytes())\n resp_bytes.append(0x01) # version\n resp_bytes.append(self._type) # medium (heat)\n resp_bytes.append(self._access_number) # access no\n resp_bytes.append(0x00) # status\n resp_bytes.append(0x00) # configuration 1\n resp_bytes.append(0x00) # configuration 2\n\tfor record in self._records:\n\t\tresp_bytes.extend(record.get_bytes())\n resp_bytes.append(self.calculate_checksum(resp_bytes[4:]))\n resp_bytes.append(0x16) # stop\n length = len(resp_bytes) - 9 + 3\n resp_bytes[1] = length\n resp_bytes[2] = length\n ret = [\"{:>2}\".format(hex(x)[2:]).replace(' ', '0') if type(x) == int else x for x in resp_bytes]\n\tif self._access_number < 255:\n\t\tself._access_number = self._access_number + 1\n\telse:\n\t\tself._access_number = 1\n return ''.join(ret).upper()","def deserialize(self, str):\n try:\n if self.header is None:\n self.header = std_msgs.msg.Header()\n if self.vehicle_id is None:\n self.vehicle_id = opil_v2.msg.Id()\n if self.action_capability is None:\n self.action_capability = None\n end = 0\n _x = self\n start = end\n end += 12\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.header.frame_id = str[start:end]\n start = end\n end += 4\n (self.vehicle_id.id,) = _get_struct_I().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.vehicle_id.description = str[start:end].decode('utf-8')\n else:\n self.vehicle_id.description = str[start:end]\n _x = self\n start = end\n end += 84\n (_x.left_size, _x.right_size, _x.front_size, _x.rear_size, _x.min_height, _x.max_height, _x.payload, _x.max_pos_x_vel, _x.max_neg_x_vel, _x.max_pos_x_acc, _x.max_neg_x_acc, _x.max_pos_y_vel, _x.max_neg_y_vel, _x.max_pos_y_acc, _x.max_neg_y_acc, _x.max_pos_ang_vel, _x.max_neg_ang_vel, _x.velocity_control_sensitivity, _x.min_turning_radius, _x.batt_capacity, _x.batt_max_voltage,) = _get_struct_21f().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.vehicle_type = str[start:end].decode('utf-8')\n else:\n self.vehicle_type = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.vendor = str[start:end].decode('utf-8')\n else:\n self.vendor = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n self.action_capability = []\n for i in range(0, length):\n val1 = opil_v2.msg.RobotAction()\n _x = val1\n start = end\n end += 2\n (_x.category, _x.action,) = _get_struct_2B().unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n val1.attributes = []\n for i in range(0, length):\n val2 = opil_v2.msg.Tuple()\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val2.type = str[start:end].decode('utf-8')\n else:\n val2.type = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val2.name = str[start:end].decode('utf-8')\n else:\n val2.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val2.value = str[start:end].decode('utf-8')\n else:\n val2.value = str[start:end]\n val1.attributes.append(val2)\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n val1.description = str[start:end].decode('utf-8')\n else:\n val1.description = str[start:end]\n self.action_capability.append(val1)\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def get_table_info(line):\n\n COMMENT_EXPR = '-- Name: '\n TYPE_EXPR = '; Type: '\n SCHEMA_EXPR = '; Schema: '\n OWNER_EXPR = '; Owner: '\n TABLESPACE_EXPR = '; Tablespace: '\n\n temp = line.strip('\\n')\n type_start = get_all_occurrences(TYPE_EXPR, temp)\n schema_start = get_all_occurrences(SCHEMA_EXPR, temp)\n owner_start = get_all_occurrences(OWNER_EXPR, temp)\n tblspace_start = get_all_occurrences(TABLESPACE_EXPR, temp)\n if len(type_start) != 1 or len(schema_start) != 1 or len(owner_start) != 1:\n return (None, None, None, None)\n name = temp[len(COMMENT_EXPR) : type_start[0]]\n type = temp[type_start[0] + len(TYPE_EXPR) : schema_start[0]]\n schema = temp[schema_start[0] + len(SCHEMA_EXPR) : owner_start[0]]\n if not tblspace_start:\n tblspace_start.append(None)\n owner = temp[owner_start[0] + len(OWNER_EXPR) : tblspace_start[0]]\n return (name, type, schema, owner)","def tcp_pkt_options_debug_info(pkt: dpkt.tcp.TCP) -> str:\n str_repr_list = []\n if isinstance(pkt, dpkt.tcp.TCP) and pkt.opts:\n opts_dict = tcp_pkt_parse_options(pkt.opts)\n for opt_kind in opts_dict.keys():\n str_repr = \"\"\n if type(opt_kind) is str and opt_kind.startswith(UNKNOWN_OPTION_PREFIX):\n str_repr += \"Kind: {}, name: {}, len: {}, data: {}\".format(\n hex(int(opt_kind.split(UNKNOWN_OPTION_PREFIX)[1])), opt_kind, opts_dict[opt_kind][0],\n binascii.hexlify(opts_dict[opt_kind][1]).decode('utf-8'))\n else:\n str_repr += \"Kind: {}, name: {} \".format(hex(opt_kind.value), opt_kind.name)\n if opt_kind == TCPOptions.TCP_OPT_SACK:\n _len = opts_dict[opt_kind][0]\n str_repr += \"length: {} \".format(_len)\n _len -= 2\n s_acks = opts_dict[opt_kind][1]\n for i in range(0, _len, 8):\n str_repr += \"left edge of block: {}, right edge of block: {}, \".format(\n binascii.hexlify(s_acks[i:i+4]).decode('utf-8'),\n binascii.hexlify(s_acks[i+4:i+8]).decode('utf-8'))\n elif opt_kind == TCPOptions.TCP_OPT_TIMESTAMP:\n str_repr += \"length: {}, timestamp value: {}, timestamp echo reply: {}\".format(\n opts_dict[opt_kind][0], binascii.hexlify(opts_dict[opt_kind][1][:4]).decode('utf-8'),\n binascii.hexlify(opts_dict[opt_kind][1][4:]).decode('utf-8'))\n elif not (type(opt_kind) == str or opt_kind == TCPOptions.TCP_OPT_NOP or\n opt_kind == TCPOptions.TCP_OPT_EOL):\n str_repr += \"length: {}, data: {}\".format(opts_dict[opt_kind][0],\n binascii.hexlify(opts_dict[opt_kind][1]).decode('utf-8'))\n str_repr_list.append(str_repr)\n return \"Options: \" + str(str_repr_list)","def _decode_message(self, label: str, buf, typedef=None, pos=0, end=None, group=False):\n print(str(pos) + \" decode_message \" + label)\n if end is None:\n end = len(buf)\n\n if typedef is None:\n typedef = {}\n else:\n # Don't want to accidentally modify the original\n typedef = copy.deepcopy(typedef)\n output = {}\n\n while pos < end:\n oldpos = pos\n tag, pos = decoder._DecodeVarint(buf, pos)\n try:\n field_number, wire_type = wire_format.UnpackTag(tag)\n except Exception as exc:\n raise (ValueError,\n 'Could not read valid tag at pos %d. Ensure it is a valid protobuf message: %s'\n % (pos-len(tag), exc), sys.exc_info()[2])\n # Convert to str\n field_number = str(field_number)\n orig_field_number = field_number\n \n field_typedef = None\n if field_number in typedef:\n field_typedef = typedef[field_number]\n else:\n field_typedef = {}\n field_typedef['type'] = self.wire_type_defaults[wire_type]\n field_type = field_typedef['type']\n if self.debug:\n ft = field_type\n if ft == None:\n ft = \"None\"\n print(\"@\" + str(oldpos) + \"-\" + str(pos-1) + \":\" + label + \" field_number \" +\n str(field_number) +\n \" wire_type \" + str(wire_type) +\n \" field_type \" + str(ft))\n # If field_type is None, its either an unsupported wire type, length delim or group\n # length delim we have to try and decode first\n field_out = None\n if field_type == 'LD':\n field_out, pos = self.decode_message_LD(label, buf, pos, field_typedef)\n elif field_type == 'endGroup':\n # TODO Should probably match the field_number to START_GROUP\n if not group:\n raise ValueError(\"Found END_GROUP before START_GROUP\")\n # exit out\n return output, typedef, pos\n elif field_type == 'message':\n field_out, pos = self.decode_message_message(\n label, buf, pos, field_typedef, field_number)\n elif field_type == 'group':\n group_typedef = None\n # Check for a anonymous type\n if 'group_typedef' in field_typedef:\n group_typedef = field_typedef['group_typedef']\n field_out, group_typedef, pos = self.decode_group(\n label, buf, group_typedef, pos)\n # Save type definition\n field_typedef['group_typedef'] = group_typedef\n else:\n # Verify wiretype matches\n if self.wiretypes[field_type] != wire_type:\n raise ValueError(\"Invalid wiretype for field number %s. %s is not wiretype %s\"\n % (field_number, field_type, wire_type))\n # Simple type, just look up the decoder\n field_out, pos = self.decoders[field_type](buf, pos)\n field_typedef['type'] = field_type\n if 'name' not in field_typedef:\n field_typedef['name'] = ''\n field_key = field_number\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\n field_key = field_typedef['name']\n # Deal with repeats\n if field_key in output:\n if isinstance(field_out, list):\n if isinstance(output[field_number], list):\n output[field_key] += field_out\n else:\n output[field_key] = field_out.append(output[field_key])\n else:\n if isinstance(output[field_number], list):\n output[field_key].append(field_out)\n else:\n output[field_key] = [output[field_key], field_out]\n else:\n output[field_key] = field_out\n typedef[orig_field_number] = field_typedef\n if self.debug:\n print(str(field_key) + \" field_out:\" + str(field_out))\n if pos > end:\n raise decoder._DecodeError(\"Invalid Message Length, pos=\" +\n str(pos) + \" end=\" + str(end))\n # Should never hit here as a group\n if group:\n raise ValueError(\"Got START_GROUP with no END_GROUP.\")\n print(\"decode_message finish \" + str(pos))\n return output, typedef, pos","def handle_signature(self, sig, signode):\n print(\"handling struct signature: \", sig)\n\n sig_match = rust_struct_sig_re.match(sig)\n name = sig_match.group(\"name\")\n mods = sig_match.group(\"mods\")\n\n formatted_mods = formatter.output_modifiers(mods).build()\n signode += nodes.Text(mods + ' ', mods + ' ')\n signode += nodes.Text('struct ', 'struct ')\n\n signode += addnodes.desc_name(name, name)\n\n return name","def to_struct(self):\n return {\"_class\": self.__class__.__name__,\n \"value\": self.__value, \n \"string\": cuni(self)}","def parsePacket(self, packet):\n \n pcktParts = packet.split()\n \n # needs exactly 4 parts\n if len(pcktParts) != 4:\n raise PacketException(\"Packet malformed.\")\n \n direction = pcktParts[0]\n ip = pcktParts[1]\n port = pcktParts[2]\n flag = pcktParts[3]\n\n try:\n pckt = Packet(direction, ip, port, flag)\n except Exception as ex:\n eprint(\"Corrupt Packet:{0} Ignoring packet:\\n{1}\".format(ex, packet.__str__()))\n return None\n \n return pckt","def device_info(self):\n info = {\n \"identifiers\": {\n (\n DOMAIN,\n \"serial-number\",\n self._ctrl.data[\"routerboard\"][\"serial-number\"],\n \"switch\",\n \"NAT\",\n )\n },\n \"manufacturer\": self._ctrl.data[\"resource\"][\"platform\"],\n \"model\": self._ctrl.data[\"resource\"][\"board-name\"],\n \"name\": f\"{self._inst} NAT\",\n }\n return info","def getSigInfo(hdr):\n \n locale.setlocale(locale.LC_ALL, 'C')\n string = '%|DSAHEADER?{%{DSAHEADER:pgpsig}}:{%|RSAHEADER?{%{RSAHEADER:pgpsig}}:{%|SIGGPG?{%{SIGGPG:pgpsig}}:{%|SIGPGP?{%{SIGPGP:pgpsig}}:{(none)}|}|}|}|'\n siginfo = hdr.sprintf(string)\n if siginfo != '(none)':\n error = 0 \n sigtype, sigdate, sigid = siginfo.split(',')\n else:\n error = 101\n sigtype = 'MD5'\n sigdate = 'None'\n sigid = 'None'\n \n infotuple = (sigtype, sigdate, sigid)\n return error, infotuple","def unpack(usb_packet):\n packet = StenoPacket(\n # Drop sync when unpacking.\n *StenoPacket._STRUCT.unpack(usb_packet[:StenoPacket.HEADER_SIZE])[1:]\n )\n if packet.data_length:\n packet.data, = unpack(\n '%ss' % packet.data_length,\n usb_packet[StenoPacket.HEADER_SIZE:StenoPacket.HEADER_SIZE +\n packet.data_length]\n )\n return packet","def _key(self):\n return (self.name, self.struct_types, self.struct_values)","def dump(): # pragma: no cover\n dods = sys.stdin.read()\n dds, xdrdata = dods.split(b'\\nData:\\n', 1)\n dataset = dds_to_dataset(dds)\n xdr_stream = io.BytesIO(xdrdata)\n data = unpack_dap2_data(xdr_stream, dataset)\n pprint.pprint(data)","def decode_field(cls, fullpath, buf, offset, record):\n cur_offset = offset\n field_id, length = struct.unpack_from('>HH', buf, cur_offset)\n cur_offset += 4\n if field_id != 0xFFFF and length > 0:\n field_name, decoder = cls.named_fields().get(field_id, (None, None))\n if decoder:\n try:\n record[field_name] = decoder(buf, cur_offset, length)\n except Exception as e:\n logger.debug(\"Could not decode field '{}' in file '{}': {}.\", field_name, fullpath, e)\n elif field_name is None:\n logger.warning(\"Unexpected field tag {} in Alias data for {}, please report.\", field_id, fullpath)\n cur_offset += length + length % 2\n return cur_offset","def deserialize(self, str):\n try:\n if self.header is None:\n self.header = std_msgs.msg.Header()\n if self.pan is None:\n self.pan = movo_msgs.msg.PanTiltActuatorFdbk()\n if self.tilt is None:\n self.tilt = movo_msgs.msg.PanTiltActuatorFdbk()\n end = 0\n _x = self\n start = end\n end += 12\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 12\n (_x.pan.header.seq, _x.pan.header.stamp.secs, _x.pan.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.pan.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.pan.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 64\n (_x.pan.current, _x.pan.pos_rad, _x.pan.vel_rps, _x.pan.torque_nm, _x.pan.pwm, _x.pan.encoder_rad, _x.pan.accel.x, _x.pan.accel.y, _x.pan.accel.z, _x.pan.temperature_degC, _x.tilt.header.seq, _x.tilt.header.stamp.secs, _x.tilt.header.stamp.nsecs,) = _struct_6f3df3I.unpack(str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.tilt.header.frame_id = str[start:end].decode('utf-8')\n else:\n self.tilt.header.frame_id = str[start:end]\n _x = self\n start = end\n end += 52\n (_x.tilt.current, _x.tilt.pos_rad, _x.tilt.vel_rps, _x.tilt.torque_nm, _x.tilt.pwm, _x.tilt.encoder_rad, _x.tilt.accel.x, _x.tilt.accel.y, _x.tilt.accel.z, _x.tilt.temperature_degC,) = _struct_6f3df.unpack(str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def parsePkt(pkt):\r\n meta = dict()\r\n headers = dict()\r\n for h,pattern in SIP_PKT_PATTERNS.iteritems():\r\n if h in ['reqfirstline', 'respfirstline']:\r\n continue\r\n headers[h] = None\r\n match = pattern.search(pkt)\r\n if match:\r\n headers[h] = re.sub(h + ': ', '', match.group()).rstrip('\\r\\n')\r\n if h == 'User-Agent' and headers[h]:\r\n headers[h] = re.sub(\"Server: \", \"\", headers[h])\r\n match_1 = SIP_PKT_PATTERNS['respfirstline'].search(pkt)\r\n match_2 = SIP_PKT_PATTERNS['reqfirstline'].search(pkt)\r\n if match_1:\r\n meta['respfirstline'] = match_1.group().rstrip(' \\r\\n')\r\n meta['code'] = int(match_1.group('code'))\r\n elif match_2:\r\n meta['reqfirstline'] = match_2.group().rstrip(' \\r\\n')\r\n meta['code'] = None\r\n else:\r\n print \"can't parse rotten SIP pkt:\\r\\n%s\" %(pkt)\r\n return \r\n if meta['code'] == AUTHREQ \\\r\n or meta['code'] == PROXYAUTHREQ:\r\n meta['auth-header'] = dict()\r\n auth_match = re.search('(?P<www_or_proxy>(?:WWW|Proxy)-Authenticate): Digest (?P<other_meta>.*)\\r\\n', pkt)\r\n if auth_match:\r\n meta['auth-header']['type'] = auth_match.group('www_or_proxy')\r\n if meta['auth-header']['type'] == 'WWW-Auth-Header':\r\n meta['auth-header']['domain'] = re.search('domain=\"([-\\/\\\\:\\.a-zA-Z0-9]+)\"', other_meta).group(1)\r\n meta['auth-header']['qop'] = re.search('qop=\"([-\\/\\\\:\\.a-zA-Z0-9]+)\"', other_meta).group(1)\r\n meta['auth-header']['stale'] = re.search('stale=(?:True|False)', other_meta).group(1)\r\n meta['auth-header']['opaque'] = re.search('opaque=\"([-\\/\\\\:\\.a-zA-Z0-9]+)\"', other_meta).group(1)\r\n other_meta = auth_match.group('other_meta')\r\n algo_match = re.search('algorithm=([a-zA-Z0-9]+)', other_meta)\r\n meta['auth-header']['realm'] = re.search('realm=\"([-\\/\\\\:_\\.a-zA-Z0-9]+)\"', other_meta).group(1)\r\n meta['auth-header']['nonce'] = re.search('nonce=\"([-\\/\\\\+:_\\.a-zA-Z0-9]+)\"', other_meta).group(1)\r\n if algo_match:\r\n meta['auth-header']['algorithm'] = algo_match.group(1)\r\n else:\r\n meta['auth-header']['algorithm'] = 'MD5' \r\n else:\r\n del meta['auth-header']\r\n meta['headers'] = headers\r\n return meta"],"string":"[\n \"def struct_handler(rdr: TextIO) -> str:\\n # What is the indent level?\\n line = rdr.readline()\\n spaces = 0\\n for c in line:\\n if c != ' ':\\n break\\n spaces += 1\\n if spaces < 4: # this would be a false positive exit early\\n return line\\n # define an exit condition\\n end = re.compile(f\\\"^( ){ {spaces - 4} }}}$\\\")\\n # define a regex for fields\\n priv_field = re.compile(f\\\"^( ){ {spaces} }(?!pub )(\\\\w+)\\\\:\\\")\\n result = \\\"\\\"\\n while not end.match(line):\\n field_match = priv_field.match(line)\\n if field_match:\\n line = line[:spaces]+\\\"pub \\\"+line[spaces:]\\n result += line\\n line = rdr.readline()\\n result += line # catch the terminal brace\\n return result\",\n \"def get_info(curf, begin, read, param_of_unpack):\\n curf.seek(begin)\\n info = curf.read(read)\\n info = struct.unpack(param_of_unpack, info)\\n return str(info[0])\",\n \"def Structs():\\n idx = idc.get_first_struc_idx()\\n while idx != ida_idaapi.BADADDR:\\n sid = idc.get_struc_by_idx(idx)\\n yield (idx, sid, idc.get_struc_name(sid))\\n idx = idc.get_next_struc_idx(idx)\",\n \"def getBriefPacket(self):\\n\\n # briefPacket = NamedTuple('Brief Packet',\\n # ['no', 'time', 'source', 'destination',\\n # 'protocol', 'length'])\\n return (self.pktIndex, self.pktTime, self.pktSrc,\\n self.pktDst, self.pktProt, self.pktLen, self.pktStack)\",\n \"def parse_from_dref(self, packet):\\n\\t\\tname = packet[9:].strip(b'\\\\x00').decode('utf-8')\\n\\t\\traw_value = packet[5:9]\\n\\t\\tvalue = struct.unpack('f', raw_value)[0]\\n\\t\\treturn name, value\",\n \"def read_packet(self):\\n\\n\\t\\t#self.debug(\\\"READ BUFFER SIZE: %d\\\" % len(self.buff))\\n\\t\\tbackup = self.buff[:]\\n\\t\\tpacket = Packet()\\n\\t\\ttry:\\n\\t\\t\\tpacket.direction = self.node\\n\\t\\t\\tpacket.ident = self.unpack('ubyte')\\n\\t\\t\\t\\n\\t\\t\\t#Defined structs from huge dict\\n\\t\\t\\tfor datatype, name in self.get_struct(packet):\\n\\t\\t\\t\\t# this populates packet.data with {name: value}\\n\\t\\t\\t\\tpacket.data[name] = self.unpack(datatype)\\n\\n\\t\\t\\t# I believe the following are packet-type specific fixes for variable-length packets.\\n\\n\\t\\t\\t#0x17\\n\\t\\t\\tif packet.ident == 0x17:\\n\\t\\t\\t\\tif packet.data['unknown'] > 0:\\n\\t\\t\\t\\t\\tpacket.data['x2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['y2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['z2'] = self.unpack('short')\\n\\t\\t\\n\\t\\t\\t#0x33\\n\\t\\t\\tif packet.ident in (0x33, 0x34):\\n\\t\\t\\t\\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n#\\t\\t\\t#0x34\\n#\\t\\t\\tif packet.ident == 0x34:\\n#\\t\\t\\t\\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\\n#\\t\\t\\t\\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n#\\t\\t\\t\\tfor i in zip(coords, btype, metadata):\\n#\\t\\t\\t\\t\\tblock = {}\\n#\\t\\t\\t\\t\\tblock[\\\"x\\\"] =\\t\\ti[0] >> 12\\n#\\t\\t\\t\\t\\tblock[\\\"z\\\"] = 0x0F & i[0] >> 8\\n#\\t\\t\\t\\t\\tblock[\\\"y\\\"] = 0xFF & i[0]\\n#\\t\\t\\t\\t\\tblock[\\\"type\\\"] = i[1]\\n#\\t\\t\\t\\t\\tblock[\\\"metadata\\\"] = i[2]\\n#\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(block)\\n#\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x3C\\n\\t\\t\\tif packet.ident == 0x3C:\\n\\t\\t\\t\\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\\n\\t\\t\\t\\ti = 0\\n\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n\\t\\t\\t\\twhile i < packet.data['data_size']*3:\\n\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(dict(zip(('x','y','z'), records[i:i+3])))\\n\\t\\t\\t\\t\\ti+=3\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x68\\n\\t\\t\\tif packet.ident == 0x68:\\n\\t\\t\\t\\tpacket.data[\\\"slots_data\\\"] = self.unpack_array('slot', packet.data[\\\"data_size\\\"])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\t#0x82:\\n\\t\\t\\tif packet.ident == 0x82:\\n\\t\\t\\t\\tpacket.data[\\\"text\\\"] = []\\n\\t\\t\\t\\tfor i in range(4):\\n\\t\\t\\t\\t\\tpacket.data[\\\"text\\\"].append(packet.data[\\\"line_%s\\\" % (i+1)])\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t#0x83\\n\\t\\t\\tif packet.ident == 0x83:\\n\\t\\t\\t\\tpacket.data[\\\"data\\\"] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\n\\t\\t\\t# Sets packet.original to the byte string that the packet was decoded from.\\n\\t\\t\\tpacket.original = backup[:len(backup) - len(self.buff)]\\n\\n\\t\\t\\treturn packet\\n\\n\\t\\texcept IncompleteData:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\treturn None\\n\\t\\texcept Exception, ex:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\tex.args += (self.buff[20:],)\\n\\t\\t\\traise\",\n \"def visit_Struct(self, node):\\n return str_node(node)\",\n \"def extract_packet(_buffer):\\n if len(_buffer)>=5:\\n mtype=_buffer[0]\\n msglen=struct.unpack('!L',_buffer[1:5])[0]\\n if len(_buffer)>=msglen+1:\\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\\n return None,None,_buffer\",\n \"def dumppkt(self):\\n try:\\n return ( (k, getattr(self,k)) for k in self.__pkt_fields__ + self.__dyn_fields__ )\\n except AttributeError:\\n raise KeyError\",\n \"def do_read_struct(self, arg):\\n self._print_func_result(self.phil.read_struct, arg)\",\n \"def decode_struct(self, fmt, buf, pos):\\n new_pos = pos + struct.calcsize(fmt)\\n return struct.unpack(fmt, buf[pos:new_pos])[0], new_pos\",\n \"def test_snmpwalk_return_structure():\\n result = snmpwalk(community='public', ipaddress=SNMP_SRV_ADDR,\\n oid='IF-MIB::ifTable', port=SNMP_SRV_PORT)\\n assert isinstance(result, list)\\n assert isinstance(result[0], tuple)\\n assert isinstance(result[0][0], str) and isinstance(result[0][1], str)\\n assert result[0][0] == '.1.3.6.1.2.1.2.2.1.1.1'\\n assert result[0][1] == '1'\",\n \"def read(iprot):\\r\\n data = {}\\r\\n iprot.readStructBegin()\\r\\n while True:\\r\\n (fname, ftype, fid) = iprot.readFieldBegin()\\r\\n if ftype == TType.STOP:\\r\\n break\\r\\n else:\\r\\n try:\\r\\n val = _read_one_field(iprot, ftype)\\r\\n data[\\\"FIELD_%d\\\" % fid] = (_type_name(ftype), val)\\r\\n except:\\r\\n traceback.print_exc()\\r\\n iprot.readFieldEnd()\\r\\n iprot.readStructEnd()\\r\\n return data\",\n \"def read(iprot):\\n data = {}\\n iprot.readStructBegin()\\n while True:\\n (fname, ftype, fid) = iprot.readFieldBegin()\\n if ftype == TType.STOP:\\n break\\n else:\\n try:\\n val = _read_one_field(iprot, ftype)\\n data[\\\"FIELD_%d\\\" % fid] = (_type_name(ftype), val)\\n except:\\n traceback.print_exc()\\n iprot.readFieldEnd()\\n iprot.readStructEnd()\\n return data\",\n \"def ReceiveMessageFromPacketInfo(self) -> IPPacketInformation:\",\n \"def getfield(self, pkt, s):\\n class_id = getattr(pkt, self._entity_class)\\n entity_class = omci_entities.entity_id_to_class_map.get(class_id)\\n data = {}\\n for attribute in entity_class.attributes:\\n if AttributeAccess.SetByCreate not in attribute.access:\\n continue\\n if attribute.field.name == 'managed_entity_id':\\n continue\\n fld = attribute.field\\n s, value = fld.getfield(pkt, s)\\n data[fld.name] = value\\n return s, data\",\n \"def read_record_head(self):\\n ver_inst, rec_type, rec_size = unpack('<HHL', self.stream.read(8))\\n instance, version = divmod(ver_inst, 2**4)\\n return rec_type, rec_size, (instance, version)\",\n \"def recv(self) -> tuple:\\n (data, c) = self.socket.recvfrom(Rudp.Packet.buffer())\\n # print(data)\\n (packet, validity) = Rudp.Packet.unpack(data)\\n if(validity):\\n print(\\\"Valid Packet Received From: \\\", c)\\n else:\\n raise Rudp.InvalidPacket(\\\"Invalid Packet Received\\\")\\n\\n return (packet, validity, c)\",\n \"def __getHeaderInfo(self, decoded_data):\\n\\t\\tip = decoded_data.child()\\n\\t\\ttcp = ip.child()\\n\\t\\t#src = (ip.get_ip_src(), tcp.get_th_sport())\\n\\t\\ttry:\\tsrc = ip.get_ip_src()\\n\\t\\texcept:\\tsrc = '?'\\n\\t\\t#dst = (ip.get_ip_dst(), tcp.get_th_dport())\\n\\t\\ttry:\\tdst = ip.get_ip_dst()\\n\\t\\texcept:\\tdst = '?'\\n\\t\\t#data = tcp.get_data_as_string()\\n\\t\\tdata = tcp.get_packet()\\n\\t\\treturn (src, dst, data)\",\n \"def get_device_info(ns, device, human_friendly):\\n if device.NumberOfBlocks and device.BlockSize:\\n size = size2str(device.NumberOfBlocks * device.BlockSize, human_friendly)\\n else:\\n size = 'N/A'\\n\\n fslabel = fs.get_device_format_label(ns, device)\\n return (device.DeviceID,\\n device.Name,\\n device.ElementName,\\n size,\\n fslabel)\",\n \"def test_snmpget_return_structure():\\n result = snmpget(community='public', ipaddress=SNMP_SRV_ADDR,\\n oid=SYSDESCR_OID, port=SNMP_SRV_PORT)\\n assert 'Linux' in result\\n assert isinstance(result, str)\",\n \"def _decode_header(self, buf):\\n ord_data = self._decode_vint(buf)\\n f_type = ord_data & 7\\n f_id = ord_data >> 3\\n return f_type, f_id\",\n \"def _structUnpack(fmt, data, offs=0, _depth=0):\\n assert _depth < 10, \\\"Maximum depth exceeded\\\"\\n if type(fmt) is str:\\n r = struct.unpack_from(fmt, data, offs)\\n if len(r) == 1: return r[0] # grumble\\n return r\\n\\n # fmt is ( offset, type, name[, count] ) or a tuple of such\\n res = {}\\n if type(fmt[0]) is not tuple: fmt = (fmt,)\\n for item in fmt:\\n if len(item) > 3:\\n itemOffs, itemType, itemName, itemCount = item\\n else:\\n itemOffs, itemType, itemName = item\\n itemCount = 1\\n size = struct.calcsize(_structTupleToFmt(itemType))\\n val = []\\n for i in range(itemCount):\\n val.append(_structUnpack(itemType, data, offs=offs, _depth=_depth+1))\\n offs += size\\n if len(val) == 1: res[itemName] = val[0]\\n else: res[itemName] = val\\n return res\",\n \"def my_structure_info(self, structure_id):\\n r = requests.get(self.base_url + f'/users/{self.username}/structures/{structure_id}', headers=self.auth_header)\\n return r.text\",\n \"def get_external_struct(self):\\n self.download_structure()\\n parser = MMCIFParser()\\n structure = parser.get_structure('STRUCT_OBJ',\\n os.path.join(self.struct_dir, self.struct_name) + '.cif')\\n return structure\",\n \"def read_raw_packet(self):\\n\\n size = 0\\n\\n # Read our two-byte header from the debugger...\\n while not size:\\n size = (self._get_next_byte() << 16) | self._get_next_byte()\\n\\n # ... and read our packet.\\n packet = bytearray([self._get_next_byte() for _ in range(size)])\\n\\n # Return our packet.\\n # TODO: extract and provide status flags\\n # TODO: generate a timestamp on-device\\n return packet, datetime.now(), None\",\n \"def to_struct(self):\\n return parsers.to_struct(self)\",\n \"def interpret_packet_value_pair(data):\\n if data is None:\\n return None, None\\n packet_type = int.from_bytes(data[3:4], 'little')\\n name = value = None\\n if packet_type == 1:\\n name = str(data[17:], 'utf8') \\n value = float(ustruct.unpack('<i', data[12:16])[0])\\n elif packet_type == 5:\\n name = str(data[21:29], 'ascii').strip()\\n value = ustruct.unpack('<d', data[12:20])[0]\\n else:\\n display.scroll('Packet type {} not recognised'.format(packet_type))\\n return name, value\",\n \"def DNL(fp):\\n length = unpack('>H', fp.read(2))[0]\\n _nl = unpack('>H', fp.read(2))[0]\\n\\n info = {\\n 'Ld' : length,\\n 'NL' : _nl\\n }\\n\\n return info\",\n \"def get_struct (self):\\n return self._intern\",\n \"def structure(self):\\n return self.struct\",\n \"def get_arp_info(pkt):\\n if len(pkt) < 8:\\n raise ARPError(\\\"ARP header too short\\\")\\n ar_hrd, ar_pro, ar_hln, ar_pln, ar_op = struct.unpack(\\\"!HHBBH\\\", pkt[0:8])\\n pkt_len = 8+(2*ar_hln)+(2*ar_pln)\\n if len(pkt) < pkt_len:\\n raise ARPError(\\\"ARP packet too short\\\")\\n ofs = 8\\n ar_sha = pkt[ofs:ofs+ar_hln]\\n ofs += ar_hln\\n ar_spa = pkt[ofs:ofs+ar_pln]\\n ofs += ar_pln\\n ar_tha = pkt[ofs:ofs+ar_hln]\\n ofs += ar_hln\\n ar_tpa = pkt[ofs:ofs+ar_pln]\\n ofs += ar_pln\\n return (ar_hrd, ar_pro, ar_hln, ar_pln,\\n ar_op, ar_sha, ar_spa, ar_tha, ar_tpa)\",\n \"def ProtocolInformation(self) -> _n_0_t_7[_n_0_t_6]:\",\n \"def print_info(self):\\n \\n print \\\"\\\"\\\"version: %d\\\\t header_len: %d\\\\t tos: %s\\\\t total_len: %d\\n id: %s\\\\t flags_reservedbit: %d\\\\t flags_dont_fragment: %d\\\\t flags_more_fragment: %d\\n fragment_offset: %d\\\\t TTL: %d\\\\t protocol: %s\\\\t\\n header_checksum: %s\\\\t\\n src: %s\\\\t dst: %s\\n opt_paddings: %s\\\"\\\"\\\" % (\\n self.version, self.header_len, self.type_of_service, self.total_len, self.id, self.flags_reservedbit, \\n self.flags_dont_fragment, self.flags_more_fragment, \\n self.fragment_offset, self.TTL, self.protocol, self.header_checksum, self.src, self.dst, repr(self.opt_paddings))\",\n \"def decode(self, msg):\\n if len(msg) < 2:\\n raise ValueError(\\\"Message is too short - can't fit a preamble\\\")\\n preamble = msg[:2]\\n \\n (x,) = struct.unpack(\\\"<H\\\", preamble)\\n \\n ID = (x & self.ID_MASK) >> 4\\n LEN = x & self.LEN_MASK\\n\\n if LEN < 0 or LEN > 8:\\n raise ValueError(\\\"Invalid CAN payload length - %d bytes not in [0,8] bytes\\\" % LEN)\\n\\n if LEN != len(msg[2:]):\\n raise ValueError(\\\"Length from preamble %d mismatches actual length %d in packet w/id %#x\\\" %\\n (LEN, len(msg[2:]), ID))\\n\\n TIME = datetime.datetime.utcnow()\\n \\n if ID in self.descriptors:\\n desc = self.descriptors[ID]\\n if \\\"format\\\" not in desc:\\n raise ValueError(\\\"No format specified for %#x:%s\\\" % (ID, desc[\\\"name\\\"]))\\n if LEN != struct.calcsize(\\\"<\\\" + str(desc[\\\"format\\\"])):\\n raise ValueError(\\\"Error in decoding message id=%#x name=%s - length field %d mismatches descriptor %d\\\"\\n % (ID, desc[\\\"name\\\"], LEN, struct.calcsize(\\\"<\\\" + str(desc[\\\"format\\\"]))))\\n\\n DATA = struct.unpack(\\\"<\\\" + str(desc[\\\"format\\\"]), msg[2:2+LEN])\\n \\n return (TIME, ID, desc, DATA)\\n else:\\n raise ValueError(\\\"Unknown message id=%#x, len=%d, data=%r\\\" % (ID, LEN, msg[2:]))\",\n \"def _parse_ctrl_block_attrs(raw):\\n std_mask, _, ext_mask = struct.unpack('HHI', raw[:8])\\n std_attrs = struct.unpack('I' * 16, raw[8:72])\\n ext_attrs = struct.unpack('I' * 32, raw[72:200])\\n return {\\n 'std_mask': std_mask,\\n 'ext_mask': ext_mask,\\n 'std_attrs': std_attrs,\\n 'ext_attrs': ext_attrs\\n }\",\n \"def get_secondary_structure_string(self):\\n d = self.data\\n struc = self.struc\\n \\n n = 0\\n output = \\\"\\\"\\n for i, (ires, inscode, chain, aa, sec_struc) in enumerate(zip(d.resnum, d.inscode, d.chain, d.aa, d.struct)):\\n if aa == \\\"!*\\\":\\n continue\\n S = sec_struc[0]\\n res = self.struc[n]\\n assert res.ires == int(ires)\\n assert res.inscode == inscode\\n assert res.chain == chain\\n output += S\\n n += 1\\n \\n assert len(output) == len(struc)\\n return output\",\n \"def _read_old_header(self, raw):\\n\\n byte_count = 0\\n\\n data_size = 4\\n self.label = struct.unpack('<4s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.version = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.revision = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 26\\n self.date = struct.unpack('<26s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.file_format = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.file_type = struct.unpack('<4s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.original_file_name = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.reference_file_name = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.related_file_name_a = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.related_file_name_b = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.related_file_name_c = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.related_file_name_d = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 82\\n self.annotate = struct.unpack('<82s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 33\\n self.instrument_model = struct.unpack('<33s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 33\\n self.instrument_serial_number = struct.unpack('<33s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 33\\n self.software_version_number = struct.unpack('<33s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 33\\n self.crystal_material = struct.unpack('<33s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.laser_wavelength_microns = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.laser_null_doubling = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.optical_ratio = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.dispersion_constant_xc = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.dispersion_constant_xm = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.dispersion_constant_xb = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.interferogram_size = struct.unpack('<H',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.interferogram_center.append(struct.unpack('<H',\\n raw[byte_count:byte_count+data_size])[0])\\n byte_count += data_size\\n\\n data_size = 2\\n self.interferogram_center.append(struct.unpack('<H',\\n raw[byte_count:byte_count+data_size])[0])\\n byte_count += data_size\\n\\n data_size = 2\\n self.acquire_mode = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.emissivity = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.apodization = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.zero_fill = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.run_time_math = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.fft_size = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.number_of_coadds = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 2\\n self.number_of_igrams = struct.unpack('<h',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.amb_temperature = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.inst_temperature = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.wbb_temperature = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.cbb_temperature = struct.unpack('<f',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 20\\n self.spare_i = struct.unpack('<hhhhhhhhhh',\\n raw[byte_count:byte_count+data_size])\\n byte_count += data_size\\n\\n data_size = 40\\n self.spare_f = struct.unpack('<ffffffffff',\\n raw[byte_count:byte_count+data_size])\\n byte_count += data_size\\n\\n data_size = 40\\n self.spare_l = struct.unpack('<ffffffffff',\\n raw[byte_count:byte_count+data_size])\\n byte_count += data_size\\n\\n data_size = 65\\n self.spare_na = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.spare_nb = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.spare_nc = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.spare_nd = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 65\\n self.spare_ne = struct.unpack('<65s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.header_end = struct.unpack('<4s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\",\n \"def unpack(self, fmt, length=1):\\n return struct.unpack(fmt, self.stream.read(length))[0]\",\n \"def dce_rpc_endianess(pkt):\\n try:\\n endianness = pkt.underlayer.endianness\\n except AttributeError:\\n # handle the case where a PNIO class is\\n # built without its DCE-RPC under-layer\\n # i.e there is no endianness indication\\n return \\\"!\\\"\\n if endianness == 0: # big endian\\n return \\\">\\\"\\n elif endianness == 1: # little endian\\n return \\\"<\\\"\\n else:\\n return \\\"!\\\"\",\n \"def getfield(self, pkt, s):\\n class_id = getattr(pkt, self._entity_class)\\n attribute_mask = getattr(pkt, self._attributes_mask)\\n entity_class = omci_entities.entity_id_to_class_map[class_id]\\n indices = entity_class.attribute_indices_from_mask(attribute_mask)\\n data = {}\\n table_attribute_mask = 0\\n for index in indices:\\n try:\\n fld = entity_class.attributes[index].field\\n except IndexError as e:\\n log.error(\\\"attribute-decode-failure\\\", attribute_index=index,\\n entity_class=entity_class, e=e)\\n continue\\n try:\\n s, value = fld.getfield(pkt, s)\\n except Exception as _e:\\n raise\\n if isinstance(pkt, OmciGetResponse) and isinstance(fld, OmciTableField):\\n data[fld.name + '_size'] = value\\n table_attribute_mask = table_attribute_mask | (1 << (16 - index))\\n else:\\n data[fld.name] = value\\n if table_attribute_mask:\\n data['table_attribute_mask'] = table_attribute_mask\\n return s, data\",\n \"def _decode(self):\\n \\n self.version = int(data_to_hex_str(self.packet[0])[2])\\n self.header_len = int(data_to_hex_str(self.packet[0])[3]) * 4\\n self.type_of_service = data_to_hex_str(self.packet[1:2])\\n self.total_len = int(data_to_hex_str(self.packet[2:4]), 16)\\n self.id = data_to_hex_str(self.packet[4:6])\\n \\n #parse the flags fields(reservedbit, don't fragment, more fragment)\\n if ((ord(self.packet[6]) & (1 << 7)) != 0):\\n self.flags_reservedbit = 1\\n else:\\n self.flags_reservedbit = 0\\n #endof if\\n \\n if ((ord(self.packet[6]) & (1 << 6)) != 0):\\n self.flags_dont_fragment = 1\\n else:\\n self.flags_dont_fragment = 0\\n #endof if\\n \\n if ((ord(self.packet[6]) & (1 << 5)) != 0):\\n self.flags_more_fragment = 1\\n else:\\n self.flags_more_fragment = 0\\n #endof if\\n \\n #parse the offset field(in packet[6:7]): 00011111 & packet[6] (to filter flags) -->> get packet[6:7] in hex_str\\n #tmp = str(31 & ord(self.packet[6]))\\n self.fragment_offset = int(data_to_hex_str(self.packet[6:8]), 16)\\n if (self.fragment_offset >= (1 << 13)):\\n #take away the flags fields: 00011111 11111111 & self.fragment_offset\\n self.fragment_offset = self.fragment_offset & ((1 << 13) - 1) \\n \\n self.TTL = ord(self.packet[8])\\n self.protocol = IPPROTO[ord(self.packet[9])]\\n self.header_checksum = data_to_hex_str(self.packet[10:12])\\n \\n self.src = str(ord(self.packet[12])) + '.' + str(ord(self.packet[13])) + '.' + \\\\\\n str(ord(self.packet[14])) + '.' + str(ord(self.packet[15]))\\n self.dst = str(ord(self.packet[16])) + '.' + str(ord(self.packet[17])) + '.' + \\\\\\n str(ord(self.packet[18])) + '.' + str(ord(self.packet[19]))\\n \\n if (self.header_len > 20):\\n self.opt_paddings = self.packet[20 : (self.header_len)]\",\n \"def get_uploaded_struct(self):\\n parser = PDBParser()\\n structure = parser.get_structure('STRUCT_OBJ',\\n os.path.join(self.struct_dir, self.struct_name))\\n return structure\",\n \"def unpack(self, fmt):\\n try:\\n data = self.get(struct.calcsize(fmt))\\n return struct.unpack(fmt, data)\\n except struct.error as e:\\n raise BufferError(\\n \\\"Error unpacking struct '%s' <%s>\\\" %\\n (fmt, binascii.hexlify(data).decode())\\n )\",\n \"def read_uef_details(chunks):\\n\\n\\tpos, chunk = find_next_chunk(chunks, 0, [0x0])\\n\\n\\tif pos == None:\\n\\n\\t\\toriginator = 'Unknown'\\n\\n\\telif chunk[1] == '':\\n\\n\\t\\toriginator = 'Unknown'\\n\\telse:\\n\\t\\toriginator = chunk[1]\\n\\n\\tpos, chunk = find_next_chunk(chunks, 0, [0x5])\\n\\n\\tif pos == None:\\n\\n\\t\\tmachine, keyboard = 'Unknown', 'Unknown'\\n\\n\\telse:\\n\\n\\t\\tmachines = ('BBC Model A', 'Electron', 'BBC Model B', 'BBC Master')\\n\\t\\tkeyboards = ('Any layout', 'Physical layout', 'Remapped')\\n\\n\\t\\tmachine = ord(chunk[1][0]) & 0x0f\\n\\t\\tkeyboard = (ord(chunk[1][0]) & 0xf0) >> 4\\n\\n\\t\\tif machine < len(machines):\\n\\t\\t\\tmachine = machines[machine]\\n\\t\\telse:\\n\\t\\t\\tmachine = 'Unknown'\\n\\n\\t\\tif keyboard < len(keyboards):\\n\\t\\t\\tkeyboard = keyboards[keyboard]\\n\\t\\telse:\\n\\t\\t\\tkeyboard = 'Unknown'\\n\\n\\tpos, chunk = find_next_chunk(chunks, 0, [0xff00])\\n\\n\\tif pos == None:\\n\\n\\t\\temulator = 'Unknown'\\n\\n\\telif chunk[1] == '':\\n\\n\\t\\temulator = 'Unknown'\\n\\telse:\\n\\t\\temulator = chunk[1]\\n\\n\\n\\t# Remove trailing null bytes\\n\\twhile originator[-1] == '\\\\000':\\n\\n\\t\\toriginator = originator[:-1]\\n\\n\\twhile emulator[-1] == '\\\\000':\\n\\n\\t\\temulator = emulator[:-1]\\n\\n\\tfeatures = ''\\n\\tif find_next_chunk(chunks, 0, [0x1])[0] != None:\\n\\t\\tfeatures = features + '\\\\n' + 'Instructions'\\n\\tif find_next_chunk(chunks, 0, [0x2])[0] != None:\\n\\t\\tfeatures = features + '\\\\n' + 'Credits'\\n\\tif find_next_chunk(chunks, 0, [0x3])[0] != None:\\n\\t\\tfeatures = features + '\\\\n' + 'Inlay'\\n\\n\\treturn originator, machine, keyboard, emulator, features\",\n \"def info(self):\\n return (self.kind, self.value)\",\n \"def deserialize(self, str):\\n try:\\n end = 0\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.name = str[start:end].decode('utf-8')\\n else:\\n self.name = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.red_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.red_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.yellow_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.yellow_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.green_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.green_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.purple_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.purple_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.orange_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.orange_v = struct.unpack(pattern, str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def from_struct(cls, struct):\\n return str(struct)\",\n \"def bytes2obj(buf: bytes) -> StunPacket:\\n\\n type_raw, length, magic_cookie, transaction_id = unpack_from(\\n HEADER_FORMAT, buf, 0)\\n\\n # Convert message type into bits, to parse it as a class and method.\\n type_bits: str = bin(type_raw)[2:].zfill(16)\\n if type_bits[:2] != \\\"00\\\":\\n raise Exception(\\n \\\"STUN packet invalid - most signifigant 2 bits must be zeroes.\\\")\\n type_class = type_bits[7] + type_bits[11]\\n type_method = type_bits[2:7] + type_bits[8:11] + type_bits[12:]\\n\\n message_bytes = unpack_from('!{}s'.format(\\n length), buf, calcsize(HEADER_FORMAT))[0]\\n # if magic_cookie != bytes.fromhex(\\\"2112A442\\\"):\\n # print(\\\"Warning: Request not RFC 8489 compilant.\\\")\\n\\n message_read = 0\\n message: Dict[bytes, bytes] = {}\\n while message_read < length:\\n attribute_type, attribute_length = unpack_from(\\n ATTRIBUTE_HEADER_FORMAT, message_bytes, message_read\\n )\\n attribute_val = unpack_from(\\n \\\"!{}s\\\".format(attribute_length), message_bytes, message_read +\\n calcsize(ATTRIBUTE_HEADER_FORMAT)\\n )[0]\\n message[attribute_type] = attribute_val\\n\\n message_read += calcsize(ATTRIBUTE_HEADER_FORMAT)\\n message_read += attribute_length\\n\\n return StunPacket(type_class, type_method, magic_cookie, transaction_id, message)\",\n \"def dump(self) : \\n mybuffer = []\\n if None not in (self.version, self.operation_id) :\\n mybuffer.append(chr(self.version[0]) + chr(self.version[1]))\\n mybuffer.append(pack(\\\">H\\\", self.operation_id))\\n mybuffer.append(pack(\\\">I\\\", self.request_id or 1))\\n for attrtype in self.attributes_types :\\n for attribute in getattr(self, \\\"_%s_attributes\\\" % attrtype) :\\n if attribute :\\n mybuffer.append(chr(self.tagvalues[\\\"%s-attributes-tag\\\" % attrtype]))\\n for (attrname, value) in attribute :\\n nameprinted = 0\\n for (vtype, val) in value :\\n mybuffer.append(chr(self.tagvalues[vtype]))\\n if not nameprinted :\\n mybuffer.append(pack(\\\">H\\\", len(attrname)))\\n mybuffer.append(attrname)\\n nameprinted = 1\\n else :\\n mybuffer.append(pack(\\\">H\\\", 0))\\n if vtype in (\\\"integer\\\", \\\"enum\\\") :\\n mybuffer.append(pack(\\\">H\\\", 4))\\n mybuffer.append(pack(\\\">I\\\", val))\\n elif vtype == \\\"boolean\\\" :\\n mybuffer.append(pack(\\\">H\\\", 1))\\n mybuffer.append(chr(val))\\n else :\\n mybuffer.append(pack(\\\">H\\\", len(val)))\\n mybuffer.append(val)\\n mybuffer.append(chr(self.tagvalues[\\\"end-of-attributes-tag\\\"]))\\n mybuffer.append(self.data)\\n return \\\"\\\".join(mybuffer)\",\n \"def getRecord(self, rr):\\n\\t\\tif rr.type == 1: return {'type': 'a', 'ipv4': socket.inet_ntoa(rr.rdata), 'hostname': rr.name}\\n\\t\\telif rr.type == 28: return {'type': 'aaaa', 'ipv6': socket.inet_ntop(socket.AF_INET6, rr.rdata), 'hostname': rr.name}\\n\\t\\telif rr.type == 5: return {'type': 'cname', 'hostname': rr.name, 'cname': rr.cname}\\n\\t\\telif rr.type == 13: return {'type': 'hostinfo', 'hostname': rr.name, 'info': rr.rdata}\\n\\t\\telif rr.type == 33: return {'type': 'srv', 'hostname': rr.srvname, 'port': rr.port, 'srv': rr.name.split('.')[-3], 'proto': rr.name.split('.')[-2]}\\n\\t\\telif rr.type == 12: return {'type': 'ptr'}\\n\\t\\telif rr.type == 16: return {'type': 'txt'}\\n\\t\\telif rr.type == 10: return {'type': 'wtf'}\",\n \"def deserialize(self, str):\\n try:\\n if self.accelerometer is None:\\n self.accelerometer = None\\n if self.gyro is None:\\n self.gyro = None\\n if self.orientation is None:\\n self.orientation = None\\n if self.led_color is None:\\n self.led_color = None\\n end = 0\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.name = []\\n for i in range(0, length):\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val1 = str[start:end].decode('utf-8')\\n else:\\n val1 = str[start:end]\\n self.name.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.position = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.velocity = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.effort = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.position_command = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.velocity_command = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.effort_command = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.accelerometer = []\\n for i in range(0, length):\\n val1 = geometry_msgs.msg.Vector3()\\n _x = val1\\n start = end\\n end += 24\\n (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end])\\n self.accelerometer.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.gyro = []\\n for i in range(0, length):\\n val1 = geometry_msgs.msg.Vector3()\\n _x = val1\\n start = end\\n end += 24\\n (_x.x, _x.y, _x.z,) = _get_struct_3d().unpack(str[start:end])\\n self.gyro.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.orientation = []\\n for i in range(0, length):\\n val1 = geometry_msgs.msg.Quaternion()\\n _x = val1\\n start = end\\n end += 32\\n (_x.x, _x.y, _x.z, _x.w,) = _get_struct_4d().unpack(str[start:end])\\n self.orientation.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.deflection = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.deflection_velocity = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.motor_velocity = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.motor_current = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.motor_winding_current = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.motor_sensor_temperature = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.motor_winding_temperature = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.motor_housing_temperature = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.board_temperature = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.processor_temperature = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.voltage = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.led_color = []\\n for i in range(0, length):\\n val1 = std_msgs.msg.ColorRGBA()\\n _x = val1\\n start = end\\n end += 16\\n (_x.r, _x.g, _x.b, _x.a,) = _get_struct_4f().unpack(str[start:end])\\n self.led_color.append(val1)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sQ'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.sequence_number = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sQ'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.receive_time = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sQ'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.transmit_time = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sQ'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.hardware_receive_time = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sQ'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.hardware_transmit_time = struct.unpack(pattern, str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def parse_event_attlog(self):\\n uid = ''\\n ver_type = -1\\n date_str = ''\\n if self.last_event_code == DEFS.EF_ATTLOG:\\n uid = self.last_payload_data[0:9].decode('ascii').\\\\\\n replace('\\\\x00', '')\\n ver_type = struct.unpack('<H', self.last_payload_data[24:26])[0]\\n date_str = \\\"20%i/%i/%i %i:%i:%i\\\" %\\\\\\n tuple(self.last_payload_data[26:32])\\n\\n return [uid, ver_type, date_str]\",\n \"def _read_new_header(self, raw):\\n\\n byte_count = 0\\n\\n data_size = 4\\n self.label = struct.unpack('<4s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.version = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.revision = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 28\\n self.date = struct.unpack('<28s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.file_format = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.file_type = struct.unpack('<4s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.original_file_name = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.reference_file_name = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.related_file_name_a = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.related_file_name_b = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.related_file_name_c = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 84\\n self.annotate = struct.unpack('<84s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 36\\n self.instrument_model = struct.unpack('<36s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 36\\n self.instrument_serial_number = struct.unpack('<36s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 36\\n self.software_version_number = struct.unpack('<36s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 36\\n self.crystal_material = struct.unpack('<36s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.laser_wavelength_microns = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.laser_null_doubling = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.padding = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.dispersion_constant_xc = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.dispersion_constant_xm = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.dispersion_constant_xb = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.num_chan = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.interferogram_size = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.scan_direction = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.acquire_mode = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.emissivity = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.apodization = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.zero_fill = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.run_time_math = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.fft_size = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.number_of_coadds = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.single_sided = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.chan_display = struct.unpack('<l',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.amb_temperature = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.inst_temperature = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.wbb_temperature = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.cbb_temperature = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.temperature_dwr = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.emissivity_dwr = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 8\\n self.laser_temperature = struct.unpack('<d',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 40\\n self.spare_i = struct.unpack('<llllllllll',\\n raw[byte_count:byte_count+data_size])\\n byte_count += data_size\\n\\n data_size = 80\\n self.spare_f = struct.unpack('<dddddddddd',\\n raw[byte_count:byte_count+data_size])\\n byte_count += data_size\\n\\n data_size = 68\\n self.spare_na = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.spare_nb = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.spare_nc = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.spare_nd = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 68\\n self.spare_ne = struct.unpack('<68s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\\n\\n data_size = 4\\n self.header_end = struct.unpack('<4s',\\n raw[byte_count:byte_count+data_size])[0]\\n byte_count += data_size\",\n \"def tcp_pkt_debug_info(pkt: dpkt.ip.IP) -> str:\\n if isinstance(pkt, dpkt.ip.IP):\\n paylod_len = pkt.len - (4 * pkt.hl) - (4 * pkt.data.off)\\n return \\\"{}:{}-> {}:{}, seq: {}, ack:{}, flag:{}, payload len: {}, payload: {}, sum: {}\\\".format(\\n inet_to_str(pkt.src), pkt.data.sport, inet_to_str(pkt.dst), pkt.data.dport, hex(pkt.data.seq),\\n hex(pkt.data.ack), hex(pkt.data.flags), hex(paylod_len), pkt.data.data, hex(pkt.data.sum))\",\n \"def deserialize(self, str):\\n try:\\n end = 0\\n start = end\\n end += 8\\n (self.time,) = _get_struct_d().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.q_target = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.qd_target = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.qdd_target = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.i_target = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.m_target = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.q_actual = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.qd_actual = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.i_actual = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.tool_acc_values = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.tcp_force = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.tool_vector = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.tcp_speed = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 8\\n (self.digital_input_bits,) = _get_struct_d().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.motor_temperatures = struct.unpack(pattern, str[start:end])\\n _x = self\\n start = end\\n end += 24\\n (_x.controller_timer, _x.test_value, _x.robot_mode,) = _get_struct_3d().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.joint_modes = struct.unpack(pattern, str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) # most likely buffer underfill\",\n \"def _determine_integer_format(self) -> Dict[int, struct.Struct]:\\n endianness_byte = self._elf.read(1) # e_ident[EI_DATA] (endianness)\\n if endianness_byte == b'\\\\x01':\\n endianness = '<'\\n elif endianness_byte == b'\\\\x02':\\n endianness = '>'\\n else:\\n raise FileDecodeError(\\n 'Unknown endianness {!r}'.format(endianness_byte))\\n\\n return {\\n 1: struct.Struct(endianness + 'B'),\\n 2: struct.Struct(endianness + 'H'),\\n 4: struct.Struct(endianness + 'I'),\\n 8: struct.Struct(endianness + 'Q'),\\n }\",\n \"def get_structure_from_cif(cifdata):\\n return cifdata.get_structure()\",\n \"def make_out_struct(self):\\n args ={\\n \\\"name\\\": self.python_madz_types + (\\\"OUTSTRUCT\\\" if self.namespace == \\\"\\\" else self._namespace_mangle(self.namespace)),\\n \\\"fields\\\":\\\"\\\"\\n }\\n\\n res = \\\\\\n\\\"\\\"\\\"class {name}(Structure):\\n _fields_ = [{fields}]\\n\\\"\\\"\\\"\\n for node in self.description.definitions():\\n args['fields'] += self.gen_type_tuple_string(node.name, node.type) + \\\", \\\"\\n\\n return res.format(**args)\",\n \"def serialize(self):\\n return (self.handle, self.gramps_id, self.type.serialize(),\\n cuni(self.name),\\n NoteBase.serialize(self),\\n AddressBase.serialize(self),\\n UrlBase.serialize(self),\\n self.change, TagBase.serialize(self), self.private)\",\n \"def get_info(self):\\n\\t\\tret = 'Flash info\\\\n'\\n\\t\\tret += '\\\\tGPNVM bits: ' + str(self.read_gpnvm()) + '\\\\n'\\n\\t\\tret += '\\\\tUnique identifier area: ' + self.read_unique_identifier_area().decode('ascii', 'replace') + '\\\\n'\\n\\t\\tret += '\\\\tDescriptor: ' + str(self.read_descriptor()) + '\\\\n'\\n\\t\\treturn ret\",\n \"def complete_read_struct(self, text, line, begidx, endidx):\\n begidx = begidx\\n endidx = endidx\\n mline = line.partition(' ')[2]\\n offs = len(mline) - len(text)\\n map_records = [*self.phil.mem_map]\\n map_structs = []\\n for record in map_records:\\n first_name = record.split('.')[0]\\n if first_name not in map_structs:\\n map_structs.append(first_name)\\n return [s[offs:] for s in map_structs if s.startswith(mline)]\",\n \"def unpackRecHeader(self):\\n return self.unpack('4s3i',16,'REC_HEAD')\",\n \"def print_device_info(device_info):\\n assert(isinstance(device_info, tuple))\\n assert(len(device_info) == 4)\\n print(\\\" Device Name : %s\\\" % device_info[0])\\n print(\\\" OS Type : %s\\\" % device_info[1])\\n print(\\\" IP Address : %s\\\" % device_info[2])\\n print(\\\" Interfaces : %s\\\" % device_info[3])\",\n \"def read(self, fmt):\\n fmt = '>' + fmt\\n if not PY3:\\n fmt = fmt.encode('utf-8')\\n return struct.unpack(fmt, self.bin.read(format_byte_size(fmt)))\",\n \"def parse_info(s:str) -> dict:\\n d = {}\\n d[\\\"SVTYPE\\\"] = re.search(r'(?<=SVTYPE=)\\\\w+',s).group(0)\\n d[\\\"SUPPORT\\\"] = re.search(r'(?<=SUPPORT=)\\\\d+',s).group(0)\\n if d[\\\"SVTYPE\\\"] in [\\\"BND\\\"]:\\n return d\\n d[\\\"END\\\"] = re.search(r'(?<=END=)\\\\d+',s).group(0)\\n if d[\\\"SVTYPE\\\"] in [\\\"INV\\\"]:\\n return d\\n d[\\\"SVLEN\\\"] = re.search(r'(?<=SVLEN=)(.*?)(?=;)',s).group(0)\\n d[\\\"READS\\\"] = re.search(r'(?<=READS=)(.*?)(?=$)',s).group(0).split(\\\",\\\")\\n if d[\\\"SVTYPE\\\"] == \\\"INS\\\":\\n d[\\\"SEQS\\\"] = re.search(r'(?<=SEQS=)(.*?)(?=;)',s).group(0).split(\\\",\\\")\\n return d\",\n \"def debug_info_struct(fdt):\\n # Traverse node tree in depth first\\n depth = 0\\n path = b''\\n root = fdt.get_root_node()\\n debug_node(fdt, root, depth, path)\",\n \"def read_struct_file(struct_file,return_type=GeoStruct):\\n\\n VARTYPE = {1:SphVario,2:ExpVario,3:GauVario,4:None}\\n assert os.path.exists(struct_file)\\n structures = []\\n variograms = []\\n with open(struct_file,'r') as f:\\n while True:\\n line = f.readline()\\n if line == '':\\n break\\n line = line.strip().lower()\\n if line.startswith(\\\"structure\\\"):\\n name = line.strip().split()[1]\\n nugget,transform,variogram_info = _read_structure_attributes(f)\\n s = return_type(nugget=nugget,transform=transform,name=name)\\n s.variogram_info = variogram_info\\n # not sure what is going on, but if I don't copy s here,\\n # all the structures end up sharing all the variograms later\\n structures.append(copy.deepcopy(s))\\n elif line.startswith(\\\"variogram\\\"):\\n name = line.strip().split()[1].lower()\\n vartype,bearing,a,anisotropy = _read_variogram(f)\\n if name in variogram_info:\\n v = VARTYPE[vartype](variogram_info[name],a,anisotropy=anisotropy,\\n bearing=bearing,name=name)\\n variograms.append(v)\\n\\n for i,st in enumerate(structures):\\n for vname in st.variogram_info:\\n vfound = None\\n for v in variograms:\\n if v.name == vname:\\n vfound = v\\n break\\n if vfound is None:\\n raise Exception(\\\"variogram {0} not found for structure {1}\\\".\\\\\\n format(vname,s.name))\\n\\n st.variograms.append(vfound)\\n if len(structures) == 1:\\n return structures[0]\\n return structures\",\n \"def getStructPb2():\\n return struct_pb2\",\n \"def __parse_tree(self, packet):\\n info = extract_int_data(packet[Ether])\\n logger.info('Processing packet with info [%s]', info)\\n\\n macs = search.findall_by_attr(self.tree, info.get('srcMac'),\\n name='name', maxlevel=2, maxcount=1)\\n\\n mac = None\\n src_ip = None\\n dst_ip = None\\n dst_port = None\\n packet_size = None\\n\\n if len(macs) > 0:\\n mac = macs[0]\\n src_ips = search.findall_by_attr(\\n mac, info.get('srcIP'), name='name', maxlevel=2, maxcount=1)\\n if len(src_ips) is not 0:\\n src_ip = src_ips[0]\\n dst_ips = search.findall_by_attr(\\n src_ip, info.get('dstIP'), name='name', maxlevel=2,\\n maxcount=1)\\n if len(dst_ips) is not 0:\\n dst_ip = dst_ips[0]\\n logger.info('Processing source IPs - %s', src_ips)\\n dst_ports = search.findall_by_attr(\\n dst_ip, info.get('dstPort'), name='name',\\n maxlevel=2, maxcount=1)\\n if len(dst_ports) is not 0:\\n dst_port = dst_ports[0]\\n packet_sizes = search.findall_by_attr(\\n dst_port, info.get('packet_size'),\\n name='name', maxlevel=2, maxcount=1)\\n if len(packet_sizes) is not 0:\\n packet_size = packet_sizes[0]\\n\\n return mac, src_ip, dst_ip, dst_port, packet_size\",\n \"def get_net_message():\\n # TODO: refactor to use a list of events encoded using masgpack?\\n try:\\n message, address = serverSocket.recvfrom(1024)\\n except:\\n return None, None\\n message = message.decode('utf-8')\\n return message, address\",\n \"def _parse_general_info_V4X(par, parfile):\\n line = None\\n while line != '':\\n pos = parfile.tell()\\n line = parfile.readline()\\n #Parse the useful parts of the general info entry on the left and\\n #right of the colon: key and value\\n m = re.search(r'\\\\. ([^<>\\\\(\\\\)\\\\[\\\\]]*[a-zA-Z]).*: *(.*)', line)\\n if not m:\\n parfile.seek(pos)\\n break\\n key, val = m.group(1, 2)\\n key = _sanitize_to_identifer(key).lower()\\n #Try to guess the type of the field by conversion\\n _val_split = val.split()\\n if len(_val_split) > 1:\\n try:\\n val = np.array(tuple(float(x) for x in _val_split))\\n except:\\n pass\\n else:\\n try:\\n val = int(val)\\n except ValueError:\\n pass\\n #logger.debug(\\\"Key = '{0}' Val = '{1}'\\\".format(key, val))\\n setattr(par.gen_info, key, val)\\n return par.gen_info\",\n \"def grab_cmd_info(cmd):\\n r = requests.get(cmd.url)\\n r.raise_for_status()\\n soup_cmd = bs4.BeautifulSoup(r.text, 'lxml')\\n\\n # get body text, sanitise\\n body = soup_cmd.body.text\\n body = re.sub(r'\\\\n\\\\n+', '\\\\n', body) # get rid of extra lines\\n body = re.sub(r'\\\\n[\\\\s\\\\xa0]+', '\\\\n', body) # remove leading spaces\\n body = re.sub(r'[\\\\s\\\\xa0]+\\\\n', '\\\\n', body) # remove trailing spaces\\n\\n info = {}\\n\\n # get brief description\\n p_brief = re.compile(cmd.name+r'\\\\n([\\\\d\\\\w.()-/ \\\\'\\\\n]*)\\\\nSynopsis', re.IGNORECASE)\\n brief_search = p_brief.search(body)\\n if brief_search:\\n info['brief'] = brief_search.group(1).replace('\\\\n', ' ')\\n else:\\n print 'No brief info for', cmd.name\\n info['brief'] = None\\n\\n # get synopsis\\n p_synopsis = re.compile(r'Synopsis\\\\n('+cmd.name+r'.+)[\\\\n ]+Description', re.IGNORECASE | re.DOTALL)\\n synopsis_search = p_synopsis.search(body)\\n if synopsis_search:\\n synopsis_raw = synopsis_search.group(1)\\n info['synopsis'] = [i.replace('\\\\n', ' ').strip() for i in synopsis_raw.split(cmd.name) if i]\\n else:\\n print 'No synopsis info for', cmd.name\\n info['synopsis'] = None\\n\\n # get description\\n# p_desc = re.compile(r'Description\\\\n(.*?)\\\\nOptions', re.IGNORECASE | re.DOTALL)\\n return info\",\n \"def packetDump(packet):\\n hex = ''\\n start = 0\\n size = 16\\n ln = len(packet)\\n while start < ln:\\n # print line number\\n line = '%04x ' % start\\n #print hex representation\\n c = 0\\n asc = packet[start:min(start+size, ln)]\\n for b in asc:\\n if c == 8:\\n line = line + ' '\\n line = line + '%02x ' % ord(b)\\n c = c + 1\\n line = ljust(line, 58) + '\\\"'\\n # print ascii representation, replace unprintable characters with spaces\\n for i in range(len(asc)):\\n if ord(asc[i])<32 or ord(asc[i]) == 209:\\n asc = replace(asc, asc[i], ' ')\\n line = line + asc + '\\\"\\\\n' \\n hex = hex + line\\n start = start + size\\n return hex.rstrip('\\\\n'), ln\",\n \"def __str__(self):\\n return '\\\\n%(source)s > %(type)s (0x%(type_d).2x)\\\\n%(data)s' % \\\\\\n {'type': DGTL.pkt_type_str[self.type], 'type_d': self.type,\\n 'data': str(self.decoded) if self.decoded else 'Unknown raw data.',\\n 'source': self.source}\",\n \"def handle_shoot(data: bytes) -> Tuple[bytes, str]:\\n length = struct.unpack('H', data[:2])[0]\\n name = data[2:length+2]\\n direction = struct.unpack('fff', data[length+2:length+2+12])\\n return data[2+length:], f'Shot {name.decode()} in direction: {direction}'\",\n \"def decode_packet(data):\\n\\n opcodes = [(\\\"AUTH_LOGON_CHALLENGE\\\", \\\"\\\\x00\\\"), (\\\"AUTH_LOGON_PROOF\\\", \\\"\\\\x01\\\")]\\n opcode = data[0] # Opcode of the received packet (First byte)\\n if opcode == opcodes[0][1]: # Auth Logon challenge\\n srp_rcvd = {\\n 'error': data[1], # (you should hope that it is always 0)\\n 'B': data[3:35], # Read B and skip 1 field (Length_g)\\n 'g': data[36:37], # Read g and skip 1 field (Length_n)\\n 'N': data[38:70],\\n 's': data[70:102], # Read salt\\n 'crc': data[102:] # (useless for private servers)\\n }\\n return srp_rcvd\\n if opcode == opcodes[1][1]:\\n # Auth logon proof\\n if data[1] == \\\"\\\\x00\\\": # Code error: 0\\n srp_rcvd = {'login': 1}\\n else:\\n srp_rcvd = {'login': 0}\\n return srp_rcvd\",\n \"def info(self, name):\\n if isinstance(self._state[name], dict):\\n attrs = self._state[name]['attrs']\\n return '{} {}({}), {} records: {}'.format(\\n attrs['type_str'], name, ','.join(attrs['domain']),\\n attrs['records'], attrs['description'])\\n else:\\n return repr(self[name])\",\n \"def deserialize(self, str):\\n try:\\n if self.header is None:\\n self.header = std_msgs.msg.Header()\\n if self.robot_id is None:\\n self.robot_id = opil_v2.msg.Id()\\n if self.agv_msg is None:\\n self.agv_msg = opil_v2.msg.RobotDescriptionAGV()\\n end = 0\\n _x = self\\n start = end\\n end += 12\\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.header.frame_id = str[start:end]\\n start = end\\n end += 4\\n (self.robot_id.id,) = _get_struct_I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.robot_id.description = str[start:end].decode('utf-8')\\n else:\\n self.robot_id.description = str[start:end]\\n _x = self\\n start = end\\n end += 12\\n (_x.agv_msg.header.seq, _x.agv_msg.header.stamp.secs, _x.agv_msg.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.agv_msg.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.agv_msg.header.frame_id = str[start:end]\\n start = end\\n end += 4\\n (self.agv_msg.vehicle_id.id,) = _get_struct_I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.agv_msg.vehicle_id.description = str[start:end].decode('utf-8')\\n else:\\n self.agv_msg.vehicle_id.description = str[start:end]\\n _x = self\\n start = end\\n end += 84\\n (_x.agv_msg.left_size, _x.agv_msg.right_size, _x.agv_msg.front_size, _x.agv_msg.rear_size, _x.agv_msg.min_height, _x.agv_msg.max_height, _x.agv_msg.payload, _x.agv_msg.max_pos_x_vel, _x.agv_msg.max_neg_x_vel, _x.agv_msg.max_pos_x_acc, _x.agv_msg.max_neg_x_acc, _x.agv_msg.max_pos_y_vel, _x.agv_msg.max_neg_y_vel, _x.agv_msg.max_pos_y_acc, _x.agv_msg.max_neg_y_acc, _x.agv_msg.max_pos_ang_vel, _x.agv_msg.max_neg_ang_vel, _x.agv_msg.velocity_control_sensitivity, _x.agv_msg.min_turning_radius, _x.agv_msg.batt_capacity, _x.agv_msg.batt_max_voltage,) = _get_struct_21f().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.agv_msg.vehicle_type = str[start:end].decode('utf-8')\\n else:\\n self.agv_msg.vehicle_type = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.agv_msg.vendor = str[start:end].decode('utf-8')\\n else:\\n self.agv_msg.vendor = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.agv_msg.action_capability = []\\n for i in range(0, length):\\n val1 = opil_v2.msg.RobotAction()\\n _x = val1\\n start = end\\n end += 2\\n (_x.category, _x.action,) = _get_struct_2B().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n val1.attributes = []\\n for i in range(0, length):\\n val2 = opil_v2.msg.Tuple()\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val2.type = str[start:end].decode('utf-8')\\n else:\\n val2.type = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val2.name = str[start:end].decode('utf-8')\\n else:\\n val2.name = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val2.value = str[start:end].decode('utf-8')\\n else:\\n val2.value = str[start:end]\\n val1.attributes.append(val2)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val1.description = str[start:end].decode('utf-8')\\n else:\\n val1.description = str[start:end]\\n self.agv_msg.action_capability.append(val1)\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def _read_packet_from_device(self, adb_info):\\n msg = self._read_bytes_from_device(constants.MESSAGE_SIZE, adb_info)\\n cmd, arg0, arg1, data_length, data_checksum = unpack(msg)\\n command = constants.WIRE_TO_ID.get(cmd)\\n\\n if not command:\\n raise exceptions.InvalidCommandError(\\\"Unknown command: %d = '%s' (arg0 = %d, arg1 = %d, msg = '%s')\\\" % (cmd, int_to_cmd(cmd), arg0, arg1, msg))\\n\\n if data_length == 0:\\n return command, arg0, arg1, b\\\"\\\"\\n\\n data = self._read_bytes_from_device(data_length, adb_info)\\n actual_checksum = checksum(data)\\n if actual_checksum != data_checksum:\\n raise exceptions.InvalidChecksumError(\\\"Received checksum {} != {}\\\".format(actual_checksum, data_checksum))\\n\\n return command, arg0, arg1, data\",\n \"def unpack(self, data_type):\\n\\t\\tif data_type in data_types:\\n\\t\\t\\tformat = data_types[data_type]\\n\\t\\t\\treturn self.unpack_real(format[0], format[1])\\n\\t\\t\\n\\t\\tif data_type == \\\"string8\\\":\\n\\t\\t\\tlength = self.unpack('short')\\n\\t\\t\\tif length < 0:\\n\\t\\t\\t\\traise Exception(\\\"Negative length for string\\\")\\n\\t\\t\\tif len(self.buff) < length:\\n\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\tstring = self.buff[:length]\\n\\t\\t\\tself.buff = self.buff[length:]\\n\\t\\t\\treturn string\\n\\t\\tif data_type == \\\"string16\\\":\\n\\t\\t\\tlength = self.unpack('short')\\n\\t\\t\\tif length < 0:\\n\\t\\t\\t\\traise Exception(\\\"Negative length for string\\\")\\n\\t\\t\\tif len(self.buff) < 2*length:\\n\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\tstring = self.buff[:2*length].decode('utf-16be')\\n\\t\\t\\tself.buff = self.buff[2*length:]\\n\\t\\t\\treturn string\\n\\t\\tif data_type == \\\"slot\\\":\\n\\t\\t\\to = {}\\n\\t\\t\\to[\\\"id\\\"] = self.unpack('short')\\n\\t\\t\\tif o[\\\"id\\\"] > 0:\\n\\t\\t\\t\\to[\\\"amount\\\"] = self.unpack('byte')\\n\\t\\t\\t\\to[\\\"damage\\\"] = self.unpack('short')\\n\\t\\t\\tif o[\\\"id\\\"] in SLOT_EXTRA_DATA_IDS:\\n\\t\\t\\t\\textra_len = self.unpack('short')\\n\\t\\t\\t\\tif extra_len <= 0:\\n\\t\\t\\t\\t\\to[\\\"extra\\\"] = None\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif len(self.buff) < extra_len:\\n\\t\\t\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\t\\t\\textra_buff = self.buff[:extra_len]\\n\\t\\t\\t\\t\\tself.buff = self.buff[extra_len:]\\n\\t\\t\\t\\t\\to[\\\"extra\\\"] = extra_buff\\n\\t\\t\\treturn o\\n\\t\\tif data_type == \\\"metadata\\\":\\n\\t\\t\\t#[(17, 0), (0, 0), (16, -1)]\\n\\t\\t\\to = []\\n\\t\\t\\tmtype = self.unpack('byte')\\n\\t\\t\\twhile mtype != 127:\\n\\t\\t\\t\\tmtype2 = mtype >> 5\\n\\t\\t\\t\\tt = 0\\n\\t\\t\\t\\tif mtype2 == 0: t = self.unpack('byte') \\n\\t\\t\\t\\tif mtype2 == 1: t = self.unpack('short') \\n\\t\\t\\t\\tif mtype2 == 2: t = self.unpack('int') \\n\\t\\t\\t\\tif mtype2 == 3: t = self.unpack('float') \\n\\t\\t\\t\\tif mtype2 == 4: t = self.unpack('string16')\\n\\t\\t\\t\\tif mtype2 == 5:\\n\\t\\t\\t\\t\\tt = {}\\n\\t\\t\\t\\t\\tt[\\\"id\\\"] = self.unpack('short')\\n\\t\\t\\t\\t\\tt[\\\"count\\\"] = self.unpack('byte')\\n\\t\\t\\t\\t\\tt[\\\"damage\\\"] = self.unpack('short')\\n\\t\\t\\t\\tif mtype2 == 6:\\n\\t\\t\\t\\t\\tt = []\\n\\t\\t\\t\\t\\tfor i in range(3):\\n\\t\\t\\t\\t\\t\\ts = self.unpack('int')\\n\\t\\t\\t\\t\\t\\tt.append(s)\\n\\t\\t\\t\\tt = (mtype, t)\\n\\t\\t\\t\\to.append(t)\\n\\t\\t\\t\\tmtype = self.unpack('byte')\\n\\t\\t\\treturn o\",\n \"def device_get_information_about(pnd, buf):\\n return _nfc.device_get_information_about(pnd, buf)\",\n \"def struct_dict(struct):\\n get_pair = lambda field_type: (\\n field_type[0], getattr(struct, field_type[0]))\\n return dict(list(map(get_pair, struct._fields_)))\",\n \"def get_general(soup):\\n \\n general_info = {}\\n general_info.update(get_route_name(soup))\\n general_info.update(get_box_data(soup))\\n general_info.update(get_description(soup))\\n general_info.update(get_hierarchy(soup))\\n general_info.update(get_first_img_source(soup))\\n\\n return general_info\",\n \"def get_rsp_ud2(self):\\n resp_bytes = []\\n resp_bytes.append(0x68) # start\\n resp_bytes.append(0xFF) # length\\n resp_bytes.append(0xFF) # length\\n resp_bytes.append(0x68) # start\\n resp_bytes.append(0x08) # C\\n resp_bytes.append(self._primary_address) # A\\n resp_bytes.append(0x72) # CI\\n resp_bytes.extend(self.get_address_bytes())\\n resp_bytes.extend(self.get_manufacturer_bytes())\\n resp_bytes.append(0x01) # version\\n resp_bytes.append(self._type) # medium (heat)\\n resp_bytes.append(self._access_number) # access no\\n resp_bytes.append(0x00) # status\\n resp_bytes.append(0x00) # configuration 1\\n resp_bytes.append(0x00) # configuration 2\\n\\tfor record in self._records:\\n\\t\\tresp_bytes.extend(record.get_bytes())\\n resp_bytes.append(self.calculate_checksum(resp_bytes[4:]))\\n resp_bytes.append(0x16) # stop\\n length = len(resp_bytes) - 9 + 3\\n resp_bytes[1] = length\\n resp_bytes[2] = length\\n ret = [\\\"{:>2}\\\".format(hex(x)[2:]).replace(' ', '0') if type(x) == int else x for x in resp_bytes]\\n\\tif self._access_number < 255:\\n\\t\\tself._access_number = self._access_number + 1\\n\\telse:\\n\\t\\tself._access_number = 1\\n return ''.join(ret).upper()\",\n \"def deserialize(self, str):\\n try:\\n if self.header is None:\\n self.header = std_msgs.msg.Header()\\n if self.vehicle_id is None:\\n self.vehicle_id = opil_v2.msg.Id()\\n if self.action_capability is None:\\n self.action_capability = None\\n end = 0\\n _x = self\\n start = end\\n end += 12\\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _get_struct_3I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.header.frame_id = str[start:end]\\n start = end\\n end += 4\\n (self.vehicle_id.id,) = _get_struct_I().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.vehicle_id.description = str[start:end].decode('utf-8')\\n else:\\n self.vehicle_id.description = str[start:end]\\n _x = self\\n start = end\\n end += 84\\n (_x.left_size, _x.right_size, _x.front_size, _x.rear_size, _x.min_height, _x.max_height, _x.payload, _x.max_pos_x_vel, _x.max_neg_x_vel, _x.max_pos_x_acc, _x.max_neg_x_acc, _x.max_pos_y_vel, _x.max_neg_y_vel, _x.max_pos_y_acc, _x.max_neg_y_acc, _x.max_pos_ang_vel, _x.max_neg_ang_vel, _x.velocity_control_sensitivity, _x.min_turning_radius, _x.batt_capacity, _x.batt_max_voltage,) = _get_struct_21f().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.vehicle_type = str[start:end].decode('utf-8')\\n else:\\n self.vehicle_type = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.vendor = str[start:end].decode('utf-8')\\n else:\\n self.vendor = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n self.action_capability = []\\n for i in range(0, length):\\n val1 = opil_v2.msg.RobotAction()\\n _x = val1\\n start = end\\n end += 2\\n (_x.category, _x.action,) = _get_struct_2B().unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n val1.attributes = []\\n for i in range(0, length):\\n val2 = opil_v2.msg.Tuple()\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val2.type = str[start:end].decode('utf-8')\\n else:\\n val2.type = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val2.name = str[start:end].decode('utf-8')\\n else:\\n val2.name = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val2.value = str[start:end].decode('utf-8')\\n else:\\n val2.value = str[start:end]\\n val1.attributes.append(val2)\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n val1.description = str[start:end].decode('utf-8')\\n else:\\n val1.description = str[start:end]\\n self.action_capability.append(val1)\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def get_table_info(line):\\n\\n COMMENT_EXPR = '-- Name: '\\n TYPE_EXPR = '; Type: '\\n SCHEMA_EXPR = '; Schema: '\\n OWNER_EXPR = '; Owner: '\\n TABLESPACE_EXPR = '; Tablespace: '\\n\\n temp = line.strip('\\\\n')\\n type_start = get_all_occurrences(TYPE_EXPR, temp)\\n schema_start = get_all_occurrences(SCHEMA_EXPR, temp)\\n owner_start = get_all_occurrences(OWNER_EXPR, temp)\\n tblspace_start = get_all_occurrences(TABLESPACE_EXPR, temp)\\n if len(type_start) != 1 or len(schema_start) != 1 or len(owner_start) != 1:\\n return (None, None, None, None)\\n name = temp[len(COMMENT_EXPR) : type_start[0]]\\n type = temp[type_start[0] + len(TYPE_EXPR) : schema_start[0]]\\n schema = temp[schema_start[0] + len(SCHEMA_EXPR) : owner_start[0]]\\n if not tblspace_start:\\n tblspace_start.append(None)\\n owner = temp[owner_start[0] + len(OWNER_EXPR) : tblspace_start[0]]\\n return (name, type, schema, owner)\",\n \"def tcp_pkt_options_debug_info(pkt: dpkt.tcp.TCP) -> str:\\n str_repr_list = []\\n if isinstance(pkt, dpkt.tcp.TCP) and pkt.opts:\\n opts_dict = tcp_pkt_parse_options(pkt.opts)\\n for opt_kind in opts_dict.keys():\\n str_repr = \\\"\\\"\\n if type(opt_kind) is str and opt_kind.startswith(UNKNOWN_OPTION_PREFIX):\\n str_repr += \\\"Kind: {}, name: {}, len: {}, data: {}\\\".format(\\n hex(int(opt_kind.split(UNKNOWN_OPTION_PREFIX)[1])), opt_kind, opts_dict[opt_kind][0],\\n binascii.hexlify(opts_dict[opt_kind][1]).decode('utf-8'))\\n else:\\n str_repr += \\\"Kind: {}, name: {} \\\".format(hex(opt_kind.value), opt_kind.name)\\n if opt_kind == TCPOptions.TCP_OPT_SACK:\\n _len = opts_dict[opt_kind][0]\\n str_repr += \\\"length: {} \\\".format(_len)\\n _len -= 2\\n s_acks = opts_dict[opt_kind][1]\\n for i in range(0, _len, 8):\\n str_repr += \\\"left edge of block: {}, right edge of block: {}, \\\".format(\\n binascii.hexlify(s_acks[i:i+4]).decode('utf-8'),\\n binascii.hexlify(s_acks[i+4:i+8]).decode('utf-8'))\\n elif opt_kind == TCPOptions.TCP_OPT_TIMESTAMP:\\n str_repr += \\\"length: {}, timestamp value: {}, timestamp echo reply: {}\\\".format(\\n opts_dict[opt_kind][0], binascii.hexlify(opts_dict[opt_kind][1][:4]).decode('utf-8'),\\n binascii.hexlify(opts_dict[opt_kind][1][4:]).decode('utf-8'))\\n elif not (type(opt_kind) == str or opt_kind == TCPOptions.TCP_OPT_NOP or\\n opt_kind == TCPOptions.TCP_OPT_EOL):\\n str_repr += \\\"length: {}, data: {}\\\".format(opts_dict[opt_kind][0],\\n binascii.hexlify(opts_dict[opt_kind][1]).decode('utf-8'))\\n str_repr_list.append(str_repr)\\n return \\\"Options: \\\" + str(str_repr_list)\",\n \"def _decode_message(self, label: str, buf, typedef=None, pos=0, end=None, group=False):\\n print(str(pos) + \\\" decode_message \\\" + label)\\n if end is None:\\n end = len(buf)\\n\\n if typedef is None:\\n typedef = {}\\n else:\\n # Don't want to accidentally modify the original\\n typedef = copy.deepcopy(typedef)\\n output = {}\\n\\n while pos < end:\\n oldpos = pos\\n tag, pos = decoder._DecodeVarint(buf, pos)\\n try:\\n field_number, wire_type = wire_format.UnpackTag(tag)\\n except Exception as exc:\\n raise (ValueError,\\n 'Could not read valid tag at pos %d. Ensure it is a valid protobuf message: %s'\\n % (pos-len(tag), exc), sys.exc_info()[2])\\n # Convert to str\\n field_number = str(field_number)\\n orig_field_number = field_number\\n \\n field_typedef = None\\n if field_number in typedef:\\n field_typedef = typedef[field_number]\\n else:\\n field_typedef = {}\\n field_typedef['type'] = self.wire_type_defaults[wire_type]\\n field_type = field_typedef['type']\\n if self.debug:\\n ft = field_type\\n if ft == None:\\n ft = \\\"None\\\"\\n print(\\\"@\\\" + str(oldpos) + \\\"-\\\" + str(pos-1) + \\\":\\\" + label + \\\" field_number \\\" +\\n str(field_number) +\\n \\\" wire_type \\\" + str(wire_type) +\\n \\\" field_type \\\" + str(ft))\\n # If field_type is None, its either an unsupported wire type, length delim or group\\n # length delim we have to try and decode first\\n field_out = None\\n if field_type == 'LD':\\n field_out, pos = self.decode_message_LD(label, buf, pos, field_typedef)\\n elif field_type == 'endGroup':\\n # TODO Should probably match the field_number to START_GROUP\\n if not group:\\n raise ValueError(\\\"Found END_GROUP before START_GROUP\\\")\\n # exit out\\n return output, typedef, pos\\n elif field_type == 'message':\\n field_out, pos = self.decode_message_message(\\n label, buf, pos, field_typedef, field_number)\\n elif field_type == 'group':\\n group_typedef = None\\n # Check for a anonymous type\\n if 'group_typedef' in field_typedef:\\n group_typedef = field_typedef['group_typedef']\\n field_out, group_typedef, pos = self.decode_group(\\n label, buf, group_typedef, pos)\\n # Save type definition\\n field_typedef['group_typedef'] = group_typedef\\n else:\\n # Verify wiretype matches\\n if self.wiretypes[field_type] != wire_type:\\n raise ValueError(\\\"Invalid wiretype for field number %s. %s is not wiretype %s\\\"\\n % (field_number, field_type, wire_type))\\n # Simple type, just look up the decoder\\n field_out, pos = self.decoders[field_type](buf, pos)\\n field_typedef['type'] = field_type\\n if 'name' not in field_typedef:\\n field_typedef['name'] = ''\\n field_key = field_number\\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\\n field_key = field_typedef['name']\\n # Deal with repeats\\n if field_key in output:\\n if isinstance(field_out, list):\\n if isinstance(output[field_number], list):\\n output[field_key] += field_out\\n else:\\n output[field_key] = field_out.append(output[field_key])\\n else:\\n if isinstance(output[field_number], list):\\n output[field_key].append(field_out)\\n else:\\n output[field_key] = [output[field_key], field_out]\\n else:\\n output[field_key] = field_out\\n typedef[orig_field_number] = field_typedef\\n if self.debug:\\n print(str(field_key) + \\\" field_out:\\\" + str(field_out))\\n if pos > end:\\n raise decoder._DecodeError(\\\"Invalid Message Length, pos=\\\" +\\n str(pos) + \\\" end=\\\" + str(end))\\n # Should never hit here as a group\\n if group:\\n raise ValueError(\\\"Got START_GROUP with no END_GROUP.\\\")\\n print(\\\"decode_message finish \\\" + str(pos))\\n return output, typedef, pos\",\n \"def handle_signature(self, sig, signode):\\n print(\\\"handling struct signature: \\\", sig)\\n\\n sig_match = rust_struct_sig_re.match(sig)\\n name = sig_match.group(\\\"name\\\")\\n mods = sig_match.group(\\\"mods\\\")\\n\\n formatted_mods = formatter.output_modifiers(mods).build()\\n signode += nodes.Text(mods + ' ', mods + ' ')\\n signode += nodes.Text('struct ', 'struct ')\\n\\n signode += addnodes.desc_name(name, name)\\n\\n return name\",\n \"def to_struct(self):\\n return {\\\"_class\\\": self.__class__.__name__,\\n \\\"value\\\": self.__value, \\n \\\"string\\\": cuni(self)}\",\n \"def parsePacket(self, packet):\\n \\n pcktParts = packet.split()\\n \\n # needs exactly 4 parts\\n if len(pcktParts) != 4:\\n raise PacketException(\\\"Packet malformed.\\\")\\n \\n direction = pcktParts[0]\\n ip = pcktParts[1]\\n port = pcktParts[2]\\n flag = pcktParts[3]\\n\\n try:\\n pckt = Packet(direction, ip, port, flag)\\n except Exception as ex:\\n eprint(\\\"Corrupt Packet:{0} Ignoring packet:\\\\n{1}\\\".format(ex, packet.__str__()))\\n return None\\n \\n return pckt\",\n \"def device_info(self):\\n info = {\\n \\\"identifiers\\\": {\\n (\\n DOMAIN,\\n \\\"serial-number\\\",\\n self._ctrl.data[\\\"routerboard\\\"][\\\"serial-number\\\"],\\n \\\"switch\\\",\\n \\\"NAT\\\",\\n )\\n },\\n \\\"manufacturer\\\": self._ctrl.data[\\\"resource\\\"][\\\"platform\\\"],\\n \\\"model\\\": self._ctrl.data[\\\"resource\\\"][\\\"board-name\\\"],\\n \\\"name\\\": f\\\"{self._inst} NAT\\\",\\n }\\n return info\",\n \"def getSigInfo(hdr):\\n \\n locale.setlocale(locale.LC_ALL, 'C')\\n string = '%|DSAHEADER?{%{DSAHEADER:pgpsig}}:{%|RSAHEADER?{%{RSAHEADER:pgpsig}}:{%|SIGGPG?{%{SIGGPG:pgpsig}}:{%|SIGPGP?{%{SIGPGP:pgpsig}}:{(none)}|}|}|}|'\\n siginfo = hdr.sprintf(string)\\n if siginfo != '(none)':\\n error = 0 \\n sigtype, sigdate, sigid = siginfo.split(',')\\n else:\\n error = 101\\n sigtype = 'MD5'\\n sigdate = 'None'\\n sigid = 'None'\\n \\n infotuple = (sigtype, sigdate, sigid)\\n return error, infotuple\",\n \"def unpack(usb_packet):\\n packet = StenoPacket(\\n # Drop sync when unpacking.\\n *StenoPacket._STRUCT.unpack(usb_packet[:StenoPacket.HEADER_SIZE])[1:]\\n )\\n if packet.data_length:\\n packet.data, = unpack(\\n '%ss' % packet.data_length,\\n usb_packet[StenoPacket.HEADER_SIZE:StenoPacket.HEADER_SIZE +\\n packet.data_length]\\n )\\n return packet\",\n \"def _key(self):\\n return (self.name, self.struct_types, self.struct_values)\",\n \"def dump(): # pragma: no cover\\n dods = sys.stdin.read()\\n dds, xdrdata = dods.split(b'\\\\nData:\\\\n', 1)\\n dataset = dds_to_dataset(dds)\\n xdr_stream = io.BytesIO(xdrdata)\\n data = unpack_dap2_data(xdr_stream, dataset)\\n pprint.pprint(data)\",\n \"def decode_field(cls, fullpath, buf, offset, record):\\n cur_offset = offset\\n field_id, length = struct.unpack_from('>HH', buf, cur_offset)\\n cur_offset += 4\\n if field_id != 0xFFFF and length > 0:\\n field_name, decoder = cls.named_fields().get(field_id, (None, None))\\n if decoder:\\n try:\\n record[field_name] = decoder(buf, cur_offset, length)\\n except Exception as e:\\n logger.debug(\\\"Could not decode field '{}' in file '{}': {}.\\\", field_name, fullpath, e)\\n elif field_name is None:\\n logger.warning(\\\"Unexpected field tag {} in Alias data for {}, please report.\\\", field_id, fullpath)\\n cur_offset += length + length % 2\\n return cur_offset\",\n \"def deserialize(self, str):\\n try:\\n if self.header is None:\\n self.header = std_msgs.msg.Header()\\n if self.pan is None:\\n self.pan = movo_msgs.msg.PanTiltActuatorFdbk()\\n if self.tilt is None:\\n self.tilt = movo_msgs.msg.PanTiltActuatorFdbk()\\n end = 0\\n _x = self\\n start = end\\n end += 12\\n (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.header.frame_id = str[start:end]\\n _x = self\\n start = end\\n end += 12\\n (_x.pan.header.seq, _x.pan.header.stamp.secs, _x.pan.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.pan.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.pan.header.frame_id = str[start:end]\\n _x = self\\n start = end\\n end += 64\\n (_x.pan.current, _x.pan.pos_rad, _x.pan.vel_rps, _x.pan.torque_nm, _x.pan.pwm, _x.pan.encoder_rad, _x.pan.accel.x, _x.pan.accel.y, _x.pan.accel.z, _x.pan.temperature_degC, _x.tilt.header.seq, _x.tilt.header.stamp.secs, _x.tilt.header.stamp.nsecs,) = _struct_6f3df3I.unpack(str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.tilt.header.frame_id = str[start:end].decode('utf-8')\\n else:\\n self.tilt.header.frame_id = str[start:end]\\n _x = self\\n start = end\\n end += 52\\n (_x.tilt.current, _x.tilt.pos_rad, _x.tilt.vel_rps, _x.tilt.torque_nm, _x.tilt.pwm, _x.tilt.encoder_rad, _x.tilt.accel.x, _x.tilt.accel.y, _x.tilt.accel.z, _x.tilt.temperature_degC,) = _struct_6f3df.unpack(str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def parsePkt(pkt):\\r\\n meta = dict()\\r\\n headers = dict()\\r\\n for h,pattern in SIP_PKT_PATTERNS.iteritems():\\r\\n if h in ['reqfirstline', 'respfirstline']:\\r\\n continue\\r\\n headers[h] = None\\r\\n match = pattern.search(pkt)\\r\\n if match:\\r\\n headers[h] = re.sub(h + ': ', '', match.group()).rstrip('\\\\r\\\\n')\\r\\n if h == 'User-Agent' and headers[h]:\\r\\n headers[h] = re.sub(\\\"Server: \\\", \\\"\\\", headers[h])\\r\\n match_1 = SIP_PKT_PATTERNS['respfirstline'].search(pkt)\\r\\n match_2 = SIP_PKT_PATTERNS['reqfirstline'].search(pkt)\\r\\n if match_1:\\r\\n meta['respfirstline'] = match_1.group().rstrip(' \\\\r\\\\n')\\r\\n meta['code'] = int(match_1.group('code'))\\r\\n elif match_2:\\r\\n meta['reqfirstline'] = match_2.group().rstrip(' \\\\r\\\\n')\\r\\n meta['code'] = None\\r\\n else:\\r\\n print \\\"can't parse rotten SIP pkt:\\\\r\\\\n%s\\\" %(pkt)\\r\\n return \\r\\n if meta['code'] == AUTHREQ \\\\\\r\\n or meta['code'] == PROXYAUTHREQ:\\r\\n meta['auth-header'] = dict()\\r\\n auth_match = re.search('(?P<www_or_proxy>(?:WWW|Proxy)-Authenticate): Digest (?P<other_meta>.*)\\\\r\\\\n', pkt)\\r\\n if auth_match:\\r\\n meta['auth-header']['type'] = auth_match.group('www_or_proxy')\\r\\n if meta['auth-header']['type'] == 'WWW-Auth-Header':\\r\\n meta['auth-header']['domain'] = re.search('domain=\\\"([-\\\\/\\\\\\\\:\\\\.a-zA-Z0-9]+)\\\"', other_meta).group(1)\\r\\n meta['auth-header']['qop'] = re.search('qop=\\\"([-\\\\/\\\\\\\\:\\\\.a-zA-Z0-9]+)\\\"', other_meta).group(1)\\r\\n meta['auth-header']['stale'] = re.search('stale=(?:True|False)', other_meta).group(1)\\r\\n meta['auth-header']['opaque'] = re.search('opaque=\\\"([-\\\\/\\\\\\\\:\\\\.a-zA-Z0-9]+)\\\"', other_meta).group(1)\\r\\n other_meta = auth_match.group('other_meta')\\r\\n algo_match = re.search('algorithm=([a-zA-Z0-9]+)', other_meta)\\r\\n meta['auth-header']['realm'] = re.search('realm=\\\"([-\\\\/\\\\\\\\:_\\\\.a-zA-Z0-9]+)\\\"', other_meta).group(1)\\r\\n meta['auth-header']['nonce'] = re.search('nonce=\\\"([-\\\\/\\\\\\\\+:_\\\\.a-zA-Z0-9]+)\\\"', other_meta).group(1)\\r\\n if algo_match:\\r\\n meta['auth-header']['algorithm'] = algo_match.group(1)\\r\\n else:\\r\\n meta['auth-header']['algorithm'] = 'MD5' \\r\\n else:\\r\\n del meta['auth-header']\\r\\n meta['headers'] = headers\\r\\n return meta\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60142964","0.5952989","0.5886524","0.55371803","0.5497203","0.5459148","0.5436307","0.53541756","0.529343","0.5292839","0.5251687","0.5219966","0.5216221","0.5205466","0.51578975","0.50616544","0.5050829","0.50503224","0.5029179","0.50224257","0.5017213","0.5003608","0.49879918","0.4986187","0.49847457","0.49767748","0.49694955","0.4961567","0.49551892","0.49538162","0.49498892","0.49412742","0.4928006","0.49241868","0.491495","0.4900703","0.48906183","0.48887172","0.4887497","0.48851642","0.4881304","0.48729303","0.48712757","0.48679787","0.48648828","0.48611674","0.48537698","0.4849963","0.4845468","0.48409104","0.48393002","0.48386344","0.48334023","0.48266032","0.48142302","0.4809846","0.480155","0.4801068","0.48005474","0.47964","0.47932655","0.47876567","0.47706184","0.47684407","0.47591653","0.47533432","0.4751992","0.47483346","0.47471166","0.4747088","0.47469753","0.47454238","0.47416508","0.47413126","0.4732077","0.47308564","0.4725712","0.472339","0.47192731","0.4717373","0.4713315","0.47085404","0.46990216","0.46947178","0.46931958","0.4690421","0.4685912","0.46756062","0.46745563","0.46705812","0.4665358","0.4660978","0.4656046","0.46503174","0.46380758","0.46361312","0.46316382","0.4630967","0.46271157","0.46267435"],"string":"[\n \"0.60142964\",\n \"0.5952989\",\n \"0.5886524\",\n \"0.55371803\",\n \"0.5497203\",\n \"0.5459148\",\n \"0.5436307\",\n \"0.53541756\",\n \"0.529343\",\n \"0.5292839\",\n \"0.5251687\",\n \"0.5219966\",\n \"0.5216221\",\n \"0.5205466\",\n \"0.51578975\",\n \"0.50616544\",\n \"0.5050829\",\n \"0.50503224\",\n \"0.5029179\",\n \"0.50224257\",\n \"0.5017213\",\n \"0.5003608\",\n \"0.49879918\",\n \"0.4986187\",\n \"0.49847457\",\n \"0.49767748\",\n \"0.49694955\",\n \"0.4961567\",\n \"0.49551892\",\n \"0.49538162\",\n \"0.49498892\",\n \"0.49412742\",\n \"0.4928006\",\n \"0.49241868\",\n \"0.491495\",\n \"0.4900703\",\n \"0.48906183\",\n \"0.48887172\",\n \"0.4887497\",\n \"0.48851642\",\n \"0.4881304\",\n \"0.48729303\",\n \"0.48712757\",\n \"0.48679787\",\n \"0.48648828\",\n \"0.48611674\",\n \"0.48537698\",\n \"0.4849963\",\n \"0.4845468\",\n \"0.48409104\",\n \"0.48393002\",\n \"0.48386344\",\n \"0.48334023\",\n \"0.48266032\",\n \"0.48142302\",\n \"0.4809846\",\n \"0.480155\",\n \"0.4801068\",\n \"0.48005474\",\n \"0.47964\",\n \"0.47932655\",\n \"0.47876567\",\n \"0.47706184\",\n \"0.47684407\",\n \"0.47591653\",\n \"0.47533432\",\n \"0.4751992\",\n \"0.47483346\",\n \"0.47471166\",\n \"0.4747088\",\n \"0.47469753\",\n \"0.47454238\",\n \"0.47416508\",\n \"0.47413126\",\n \"0.4732077\",\n \"0.47308564\",\n \"0.4725712\",\n \"0.472339\",\n \"0.47192731\",\n \"0.4717373\",\n \"0.4713315\",\n \"0.47085404\",\n \"0.46990216\",\n \"0.46947178\",\n \"0.46931958\",\n \"0.4690421\",\n \"0.4685912\",\n \"0.46756062\",\n \"0.46745563\",\n \"0.46705812\",\n \"0.4665358\",\n \"0.4660978\",\n \"0.4656046\",\n \"0.46503174\",\n \"0.46380758\",\n \"0.46361312\",\n \"0.46316382\",\n \"0.4630967\",\n \"0.46271157\",\n \"0.46267435\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71432406"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90585,"cells":{"query":{"kind":"string","value":"Reads buff (consuming bytes) and returns the unpacked value according to the given type."},"document":{"kind":"string","value":"def unpack(self, data_type):\n\t\tif data_type in data_types:\n\t\t\tformat = data_types[data_type]\n\t\t\treturn self.unpack_real(format[0], format[1])\n\t\t\n\t\tif data_type == \"string8\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:length]\n\t\t\tself.buff = self.buff[length:]\n\t\t\treturn string\n\t\tif data_type == \"string16\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < 2*length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:2*length].decode('utf-16be')\n\t\t\tself.buff = self.buff[2*length:]\n\t\t\treturn string\n\t\tif data_type == \"slot\":\n\t\t\to = {}\n\t\t\to[\"id\"] = self.unpack('short')\n\t\t\tif o[\"id\"] > 0:\n\t\t\t\to[\"amount\"] = self.unpack('byte')\n\t\t\t\to[\"damage\"] = self.unpack('short')\n\t\t\tif o[\"id\"] in SLOT_EXTRA_DATA_IDS:\n\t\t\t\textra_len = self.unpack('short')\n\t\t\t\tif extra_len <= 0:\n\t\t\t\t\to[\"extra\"] = None\n\t\t\t\telse:\n\t\t\t\t\tif len(self.buff) < extra_len:\n\t\t\t\t\t\traise IncompleteData()\n\t\t\t\t\textra_buff = self.buff[:extra_len]\n\t\t\t\t\tself.buff = self.buff[extra_len:]\n\t\t\t\t\to[\"extra\"] = extra_buff\n\t\t\treturn o\n\t\tif data_type == \"metadata\":\n\t\t\t#[(17, 0), (0, 0), (16, -1)]\n\t\t\to = []\n\t\t\tmtype = self.unpack('byte')\n\t\t\twhile mtype != 127:\n\t\t\t\tmtype2 = mtype >> 5\n\t\t\t\tt = 0\n\t\t\t\tif mtype2 == 0: t = self.unpack('byte') \n\t\t\t\tif mtype2 == 1: t = self.unpack('short') \n\t\t\t\tif mtype2 == 2: t = self.unpack('int') \n\t\t\t\tif mtype2 == 3: t = self.unpack('float') \n\t\t\t\tif mtype2 == 4: t = self.unpack('string16')\n\t\t\t\tif mtype2 == 5:\n\t\t\t\t\tt = {}\n\t\t\t\t\tt[\"id\"] = self.unpack('short')\n\t\t\t\t\tt[\"count\"] = self.unpack('byte')\n\t\t\t\t\tt[\"damage\"] = self.unpack('short')\n\t\t\t\tif mtype2 == 6:\n\t\t\t\t\tt = []\n\t\t\t\t\tfor i in range(3):\n\t\t\t\t\t\ts = self.unpack('int')\n\t\t\t\t\t\tt.append(s)\n\t\t\t\tt = (mtype, t)\n\t\t\t\to.append(t)\n\t\t\t\tmtype = self.unpack('byte')\n\t\t\treturn o"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def unpack_real(self, data_type, length):\n\t\tif len(self.buff) < length:\n\t\t\traise IncompleteData()\n\t\to = struct.unpack_from('!'+data_type, self.buff)[0]\n\t\tself.buff = self.buff[length:]\n\t\treturn o","def recv_type(self, type_):\n msg = self.recv()\n assert msg and msg['type'] == type_, msg\n return msg","def read_type(adr, tyname):\n data = Rsp.read_mem(adr,tyname2size(tyname))\n data = bytes.fromhex(data)\n res, = struct.unpack(tyname2fmt(tyname), data)\n return(res)","def get(self, given_type: t.Type, read_until: t.Union[str, None] = None, strip: bool = True) -> t.Union[None, bytes, str]:\n\n call_time = time.time() # time that the function was called\n\n if (given_type != str and given_type != bytes):\n raise TypeError(\"given_type must be literal 'str' or 'bytes'\")\n\n if (given_type == str):\n return self._get_str(call_time, read_until=read_until, strip=strip)\n else:\n return self._get_bytes(call_time)","def read_and_unpack(self, fmt):\n try:\n return unpack(\n self.byte_order + fmt,\n self.read(calcsize(self.byte_order + fmt)))\n except Exception as e:\n if e.args[0].startswith('unpack requires a buffer of'):\n raise EOFError(e)\n else:\n raise","def get_buf(self, data_type = \"void\"):\n if self.buf is not None:\n return ffi.cast(data_type + \"*\", self.buf)\n else:\n raise RuntimeError(\"Buffer not created.\")","def read(self, fmt):\n fmt = '>' + fmt\n if not PY3:\n fmt = fmt.encode('utf-8')\n return struct.unpack(fmt, self.bin.read(format_byte_size(fmt)))","def ReadProcessMemory(\n process_handle: int,\n address: int,\n pytype: Type[T],\n bufflength: int\n) -> T:\n if pytype not in [bool, int, float, str, bytes]:\n raise ValueError(\"The type must be bool, int, float, str or bytes.\")\n\n data = get_c_type_of(pytype, bufflength)\n kernel32.ReadProcessMemory(process_handle, ctypes.c_void_p(address), ctypes.byref(data), bufflength, None)\n\n return str(data.value) if pytype is str else data.value","def parse(cls, buf: memoryview, params: Params) \\\n -> tuple[AnyParseable, memoryview]:\n for data_type in params.expected:\n try:\n return data_type.parse(buf, params)\n except NotParseable:\n pass\n raise UnexpectedType(buf)","async def get(self, kind=None):\n if kind is None:\n kind = self.data_type\n\n data = await self.read()\n if kind == DataType.TEXT:\n return data.decode()\n elif kind == DataType.BINARY:\n return data","def Read(buf: IO[bytes]) -> Optional[bytes]:\n count_bytes = buf.read(_UINT64.size)\n if not count_bytes:\n return None\n\n try:\n (count,) = _UINT64.unpack(count_bytes)\n except struct.error as error:\n raise ValueError(f\"Incorrect size tag {count_bytes}: {error}\")\n\n # It might happen that we are given file with incorrect format. If the size\n # tag is interpreted as a huge number, reading the buffer will lead to raising\n # an exception, because Python will try to allocate a buffer to read into. If\n # possible, we try to check guard against such situations and provide more\n # informative exception message.\n\n def Error(left: int) -> ValueError:\n message = f\"Malformed input (reading {count} bytes out of {left} available)\"\n return ValueError(message)\n\n if buf.seekable():\n position = buf.tell()\n\n buf.seek(0, os.SEEK_END)\n size = buf.tell()\n\n if count > size - position:\n raise Error(size - position)\n\n buf.seek(position, os.SEEK_SET)\n\n chunk = buf.read(count)\n if len(chunk) != count:\n raise Error(len(chunk))\n\n return chunk","def decode_buffer(buf):\n return buf.getvalue().decode('utf-8')","def readinto(self, buf: bytes, /) -> Optional[int]:","def get_data(self, ptr, unbuffered=False):\n return _decode(self.get_raw_data(ptr, unbuffered),\n reading_format[self.data_format])","def read(self, tag): # type: (Number) -> (Tag, any)\n if tag.type != Types.Primitive:\n raise ASN1Error('Only primitive types can be read.')\n\n nr = tag.number\n length = tag.length\n\n bytes_data = self._read_bytes(0, length)\n self._buffer = self._buffer[length:]\n if tag.cls != Classes.Universal:\n value = bytes_data\n elif nr == Numbers.Boolean:\n value = self._decode_boolean(bytes_data)\n elif nr in (Numbers.Integer, Numbers.Enumerated):\n value = self._decode_integer(bytes_data)\n elif nr == Numbers.Null:\n value = self._decode_null(bytes_data)\n elif nr == Numbers.ObjectIdentifier:\n value = self._decode_object_identifier(bytes_data)\n elif nr in (\n Numbers.PrintableString, Numbers.IA5String, Numbers.UTCTime\n ):\n value = bytes_data.decode('utf-8')\n else:\n value = bytes_data\n\n self._resetTag()\n return value","def unpack(self,format,size,recType='-----'):\n endPos = self.ins.tell() + size\n if endPos > self.size:\n raise Tes3ReadError(self.inName, recType,endPos,self.size)\n return struct.unpack(format,self.ins.read(size))","def get(typ, **kw):\n\t\treturn crypto.hexlify(getattr(Payload, \"type%d\" % typ)(**kw))","def get_type_unpack(self, arg, option):\n pass","def parse_type(fobj, data_type):\n if data_type == \"Boolean\": ## False if 0x00 else True\n return bool(fobj.read(1))\n elif data_type == \"Byte\": ## 1 byte int\n return fobj.read(1)[0]\n elif data_type == \"DateTime\": ## 8 bytes signed int\n return struct.unpack(\"<q\", fobj.read(8))[0]\n elif data_type == \"Double\": ## 8 bytes floating point\n return struct.unpack(\"<d\", fobj.read(8))[0]\n elif data_type == \"Int\": ## 4 bytes unsigned int\n return struct.unpack(\"<I\", fobj.read(4))[0]\n elif data_type == \"Int-Double pair\": ## 0x08-Int-0x0d-Double with AssertionError\n bb = fobj.read(1)[0]\n if bb != 0x08:\n raise AssertionError('parse_type(fobj, data_type): '\n '1st byte(%s) of \"Int-Double pair\" != 0x08' % bb)\n first_int = parse_type(fobj, \"Int\")\n bb = fobj.read(1)[0]\n if bb != 0x0d:\n raise AssertionError('parse_type(fobj, data_type): '\n '6th byte(%s) of \"Int-Double pair\" != 0x0d' % bb)\n return [first_int, parse_type(fobj, \"Double\")]\n elif data_type == \"Int-Double pair*\": ## int(n) - \"Int-Double pair\"*n\n return [parse_type(fobj, \"Int-Double pair\") for i in range(parse_type(fobj, \"Int\"))]\n elif data_type == \"Long\": ## 8 bytes unsigned int\n return struct.unpack(\"<Q\", fobj.read(8))[0]\n elif data_type == \"Short\": ## 2 bytes unsigned int\n return struct.unpack(\"<H\", fobj.read(2))[0]\n elif data_type == \"Single\": ## 4 bytes floating point\n return struct.unpack(\"<f\", fobj.read(4))[0]\n elif data_type == \"String\": ## 0x00 or 0x0b - ULE128(n) - UTF-8(length=n)\n bb = fobj.read(1)[0]\n if bb == 0x00:\n return None\n elif bb != 0x0b:\n ## TODO: show integers in assertion error in hexadecimal and decimal\n ## to make debug more convenient (cause I may inspect the file in a byte reader.\n raise AssertionError('parse_type(fobj, data_type): '\n '1st byte(%s) of \"String\" not in {0x00, 0x0b}' % bb)\n strlen = parse_type(fobj, \"ULEB128\")\n return fobj.read(strlen).decode(\"utf-8\")\n elif data_type == \"ULEB128\": ## https://en.wikipedia.org/wiki/LEB128#Decode_unsigned_integer\n i = 0 ## derived from the wiki psuedo code\n res = 0\n shift = 0\n while True:\n bb = fobj.read(1)[0]\n i += 1\n res |= ((bb & 0b1111111) << shift)\n if (bb & 0b10000000) == 0:\n break\n shift += 7\n return res\n elif data_type == \"Timing point\": ## Double - Double - Boolean\n return parse_types(fobj, [\"Double\", \"Double\", \"Boolean\"])\n elif data_type == \"Timing point+\": ## int(n) - \"Timing point\"*n\n return [parse_type(fobj, \"Timing point\") for i in range(parse_type(fobj, \"Int\"))]\n else:\n raise NotImplementedError('parse_type(fobj, data_type): Unknown data type: \"%s\".' % data_type)","def dataRipFrom8583(text,typ) :\n\ttyp1,length1,varlength = DataTypeDetail(typ)\n\tif typ1 == 'z' :\n\t\treturn (text,len(text))\n\n\tif length1=='' :\n\t\traise Exception('type definition miss length(%s)' % typ)\n\tif typ1=='' :\n\t\traise Exception('type definition miss type(%s)' % typ)\n\tif varlength :\n\t\tl = len(length1)\n\t\tmaxlength = 0\n\t\ttry :\n\t\t\tmaxlength = int(length1)\n\t\texcept :\n\t\t\traise \n\t\ts1 = text[:l]\n\t\tdatalen = 0 \n\t\ttry :\n\t\t\tdatalen = int(s1)\n\t\texcept :\n\t\t\traise Exception('need int but not,(%s)' % s1)\n\t\tif datalen > maxlength :\n\t\t\traise Exception('%d extend maxlen(%d)' % (datalen,maxlength))\n\t\tvalue = text[l:l+datalen]\n\t\treturn (value,l + datalen)\n\tdatalen = int(length1)\n\tif typ1=='b' :\n\t\tdatalen,v = divmod(datalen,8)\n\t\tif v :\n\t\t\tdatalen += 1\n\n\tvalue = text[:datalen]\n\t#for i in value :\n\t#\tif not checkCharType(typ1,i) :\n\t#\t\ts = 'typ1= %s' % typ1 + 'i=%s' % i\n\t#\t\traise s,text\n\treturn (value,datalen)","def unmarshal(cls, buf):\n umfunc = getattr(lib, f\"Tss2_MU_{cls.__name__}_Unmarshal\", None)\n if umfunc is None:\n raise RuntimeError(f\"No unmarshal function found for {cls.__name__}\")\n _cdata = ffi.new(f\"{cls.__name__} *\")\n offset = ffi.new(\"size_t *\")\n _chkrc(umfunc(buf, len(buf), offset, _cdata))\n return cls(_cdata=_cdata), offset[0]","def _unpack(self, _format: str, size: int) -> Any:\n return unpack(_format, self.read(size))[0]","def stateless_unpack(buff, to_server):\n\tdecoder = PacketDecoder(to_server)\n\tdecoder.buff = buff\n\tpacket = decoder.read_packet()\n\treturn packet, decoder.buff","def unpack(self, fmt):\n try:\n data = self.get(struct.calcsize(fmt))\n return struct.unpack(fmt, data)\n except struct.error as e:\n raise BufferError(\n \"Error unpacking struct '%s' <%s>\" %\n (fmt, binascii.hexlify(data).decode())\n )","def unpack_type_spec_from(\n buffer: bytes, offset: int = 0\n) -> tuple[computation_types.Type, int]:\n length, length_size = _unpack_length_from(buffer, offset=offset)\n offset += length_size\n type_spec_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\n proto = computation_pb2.Type.FromString(type_spec_bytes)\n type_spec = type_serialization.deserialize_type(proto)\n return type_spec, length_size + length # pytype: disable=bad-return-type","def unpack (self, buffer):\n\t\timport struct\n\t\tvalues = struct.unpack (self.struct, buffer)\n\t\tj = 0\n\t\tfor i in self.structref:\n\t\t\tself.value[i[self.NAME]] = values[j]\n\t\t\tj = j + 1","def read_packet(self):\n\n\t\t#self.debug(\"READ BUFFER SIZE: %d\" % len(self.buff))\n\t\tbackup = self.buff[:]\n\t\tpacket = Packet()\n\t\ttry:\n\t\t\tpacket.direction = self.node\n\t\t\tpacket.ident = self.unpack('ubyte')\n\t\t\t\n\t\t\t#Defined structs from huge dict\n\t\t\tfor datatype, name in self.get_struct(packet):\n\t\t\t\t# this populates packet.data with {name: value}\n\t\t\t\tpacket.data[name] = self.unpack(datatype)\n\n\t\t\t# I believe the following are packet-type specific fixes for variable-length packets.\n\n\t\t\t#0x17\n\t\t\tif packet.ident == 0x17:\n\t\t\t\tif packet.data['unknown'] > 0:\n\t\t\t\t\tpacket.data['x2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['y2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['z2'] = self.unpack('short')\n\t\t\n\t\t\t#0x33\n\t\t\tif packet.ident in (0x33, 0x34):\n\t\t\t\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n#\t\t\t#0x34\n#\t\t\tif packet.ident == 0x34:\n#\t\t\t\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\n#\t\t\t\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tpacket.data[\"blocks\"] = []\n#\t\t\t\tfor i in zip(coords, btype, metadata):\n#\t\t\t\t\tblock = {}\n#\t\t\t\t\tblock[\"x\"] =\t\ti[0] >> 12\n#\t\t\t\t\tblock[\"z\"] = 0x0F & i[0] >> 8\n#\t\t\t\t\tblock[\"y\"] = 0xFF & i[0]\n#\t\t\t\t\tblock[\"type\"] = i[1]\n#\t\t\t\t\tblock[\"metadata\"] = i[2]\n#\t\t\t\t\tpacket.data[\"blocks\"].append(block)\n#\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x3C\n\t\t\tif packet.ident == 0x3C:\n\t\t\t\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\n\t\t\t\ti = 0\n\t\t\t\tpacket.data[\"blocks\"] = []\n\t\t\t\twhile i < packet.data['data_size']*3:\n\t\t\t\t\tpacket.data[\"blocks\"].append(dict(zip(('x','y','z'), records[i:i+3])))\n\t\t\t\t\ti+=3\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x68\n\t\t\tif packet.ident == 0x68:\n\t\t\t\tpacket.data[\"slots_data\"] = self.unpack_array('slot', packet.data[\"data_size\"])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\t#0x82:\n\t\t\tif packet.ident == 0x82:\n\t\t\t\tpacket.data[\"text\"] = []\n\t\t\t\tfor i in range(4):\n\t\t\t\t\tpacket.data[\"text\"].append(packet.data[\"line_%s\" % (i+1)])\n\t\t\t\t\t\n\t\t\t#0x83\n\t\t\tif packet.ident == 0x83:\n\t\t\t\tpacket.data[\"data\"] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\n\t\t\t# Sets packet.original to the byte string that the packet was decoded from.\n\t\t\tpacket.original = backup[:len(backup) - len(self.buff)]\n\n\t\t\treturn packet\n\n\t\texcept IncompleteData:\n\t\t\tself.buff = backup\n\t\t\treturn None\n\t\texcept Exception, ex:\n\t\t\tself.buff = backup\n\t\t\tex.args += (self.buff[20:],)\n\t\t\traise","def read(self, buf):\n contents = dict()\n for element in self.elements:\n if element.offset + element.size > len(buf):\n logger.trace(\"cannot unpack {} for {}.{} buffer too small {}\",\n element.name, element.block_name, element.block_version, len(buf))\n contents[element.name] = None\n continue\n s, = struct.unpack_from(element.structure, buf, element.offset)\n if element.decode:\n s = element.decode(s)\n contents[element.name] = s\n return contents","def get_value(self, addr, type_, is_global=False):\n # print(f\"Get value at {addr} of {type_}. Global {is_global}\")\n # Las listas están guardadas en su tipo primitivo, por eso se quitan los '[]'\n if type_.startswith('['):\n type_ = type_.strip('[]')\n if is_global:\n search_memory = self.memory_stack[0]\n else:\n search_memory = self.memory\n if type_ == \"Int\":\n return search_memory[self.INT_BASE + addr]\n elif type_ == \"Float\":\n return search_memory[self.FLOAT_BASE + addr]\n elif type_ == \"Bool\":\n return search_memory[self.BOOL_BASE + addr]\n elif type_ == \"String\":\n return search_memory[self.STRING_BASE + addr]\n elif type_ == \"Any\":\n return search_memory[self.EMPTY_ARR + addr]","def _extract_bytes(l):\n # input should consist of a list of strings similar to ['123456', 'bytes', 'read']\n if len(l) != 3 or l[1] != 'bytes' or l[2] != 'read':\n raise UBootError('received unexpected reply when reading file')\n\n try:\n return int(l[0])\n except ValueError:\n raise UBootError('received unexpected bytes value when reading file')","def unpackb(value):\n return load(io.BytesIO(value))","def parseDbValue(buffer, vtype=str): \n m = _dbParserRe.match(buffer.strip())\n if not m: \n raise RuntimeError(\"cannot parse value from dbBuffer %r\"%buffer) \n vltType, svalue = m.groups() \n try:\n value = vtype(svalue)\n except (TypeError, ValueError):\n raise RuntimeError(\"cannot convert value from dbBuffer %r into a %r\"%(buffer, vtype))\n\n return vltType, value","def loads(value):\n return unpackb(value)","def _unpack_tuple(self, buff):\n cardinality = struct_L.unpack_from(buff)[0]\n _tuple = ['']*cardinality\n offset = 4 # The first 4 bytes in the response body is the <count> we have already read\n for i in xrange(cardinality):\n field_size, offset = self._unpack_int_base128(buff, offset)\n field_data = struct.unpack_from(\"<%ds\" % field_size, buff, offset)[0]\n _tuple[i] = field(field_data)\n offset += field_size\n\n return tuple(_tuple)","def _getvaluefrombuffer(buf, loc):\n if len(loc) > 1:\n return _getvaluefrombuffer(buf.__dict__[loc[0]], loc[1:])\n if not hasattr(buf, loc[0]):\n raise RuntimeError(\"Requested <field> does not exist.\")\n return buf.__dict__[loc[0]]","def read(cls, buf):\n has_bytes = buf.remaining()\n if has_bytes < 1:\n raise NeedBytes, 1\n\n first = buf.read_uchar()\n\n size = (((first & 0xc0) >> 6) ^ 0x3) << 2\n if size == 0:\n size = 1\n\n if has_bytes < size:\n raise NeedBytes, size-has_bytes\n\n object_id = first & 0x3f\n timestamp = length = type = stream_id = None\n\n if size != 1:\n timestamp = buf.read_24bit_uint()\n\n if size >= 8:\n length = buf.read_24bit_uint()\n type = buf.read_uchar()\n\n if size == 12:\n stream_id = buf.read_ulong()\n\n return RTMPHeader(object_id, timestamp, length, type, stream_id)","def deserialize(self, data: bytes) -> Tuple[str, Any]:\n if self.cache_config['CACHE_CONTENT_TYPE_JSON_ONLY']:\n return data\n else:\n return msgpack.unpackb(data, raw=False)","def decode_network_values(ptype, plen, buf):\n nvalues = short.unpack_from(buf, header.size)[0]\n off = header.size + short.size + nvalues\n valskip = double.size\n\n # Check whether our expected packet size is the reported one\n assert ((valskip + 1) * nvalues + short.size + header.size) == plen\n assert double.size == number.size\n\n result = []\n\n for dstype in buf[header.size + short.size:off]:\n if type(dstype) is type(\"foo\"): ## Python 2 handles dsType as a string!\n dstype = int(dstype.encode('hex'))\n \n if dstype == DS_TYPE_COUNTER:\n result.append((dstype, number.unpack_from(buf, off)[0]))\n off += valskip\n elif dstype == DS_TYPE_GAUGE:\n result.append((dstype, double.unpack_from(buf, off)[0]))\n off += valskip\n elif dstype == DS_TYPE_DERIVE:\n result.append((dstype, number.unpack_from(buf, off)[0]))\n off += valskip\n elif dstype == DS_TYPE_ABSOLUTE:\n pprint(\"DS_TYPE_ABSOLUTE\")\n result.append((dstype, number.unpack_from(buf, off)[0]))\n off += valskip\n else:\n raise ValueError(\"DS type %i unsupported\" % dstype)\n\n return result","def readinto(self, buf: bytes, nbytes: int, /) -> Optional[int]:","def get_rom_data(self, address, data_type=protocol.EEPROM_DATA_TYPE_BYTE):\n cmd = protocol.GET_EEPROM.format(address, data_type)\n response = self.__send_and_receive(cmd)\n value = self.__gen_response_value(response)\n if value:\n # print(\"val: {}\".format(type)))\n val = \"\".join(value)[1:]\n\n if data_type == protocol.EEPROM_DATA_TYPE_FLOAT:\n return float(val)\n elif data_type == protocol.EEPROM_DATA_TYPE_INTEGER:\n return int(val)\n elif data_type == protocol.EEPROM_DATA_TYPE_BYTE:\n return int(val)\n else:\n return False","def type(self):\n return struct.unpack('<B', self.raw_data[0])[0]","def from_buffer(cls, buf, **kwargs):\n cls._initialize(**kwargs)\n # perform processing\n try:\n filetype = cls.cookie.buffer(buf)\n if cls.old_api:\n cls.cookie.close()\n except magic.MagicException:\n # should never enter here, but in case of\n filetype = None\n return filetype","def decode(type_info: CLType, as_bytes: typing.List[int]) -> typing.List[int]:\n if isinstance(type_info, CLType_Simple):\n entity = _SIMPLE_TYPE_DECODERS[type_info.typeof](as_bytes)\n elif isinstance(type_info, CLType_ByteArray):\n entity = decode_byte_array(as_bytes)\n elif isinstance(type_info, CLType_Option):\n entity = decode_option(as_bytes, type_info.inner_type)\n else:\n entity = None\n\n return entity","def readinto(self, buf: AnyWritableBuf, /) -> int | None:","def readinto(self, buf: AnyWritableBuf, /) -> int | None:","def read_value(stream):\n strip_whitespace(stream)\n\n if stream.eof():\n raise VeryUnexpectedEndException(stream, \"Encountered EOF while scanning for a value\")\n\n char = stream.peek()\n if '\"' == char:\n value = read_string(stream)\n value_type = SUCH_STRING\n\n elif char in VALID_TOKEN_CHARS:\n value = read_token(stream)\n value_type = SUCH_CONST\n if \"yes\" == value:\n value = True\n elif \"no\" == value:\n value = False\n elif \"empty\" == value:\n value = None\n else:\n # It's a token Bob!\n value_type = SUCH_TOKEN\n\n elif char in \"1234567890\":\n value = read_number(stream)\n value_type = SUCH_NUMBER\n\n else:\n raise ManyParseException(stream, \"Invalid value start character: {!r}\".format(char))\n\n return value, value_type","def _break_down(self, buf, type_override=None, id_override=None):\n assert (id_override is not None and type_override is not None) or\\\n (id_override is None and type_override is None),\\\n 'Field ID and type must be both specified in headerless mode'\n\n while 1:\n field = {}\n if type_override is not None:\n f_type = type_override\n f_id = id_override\n else:\n # if no more data, stop and return\n try:\n f_type, f_id = self._decode_header(buf)\n except EOFError:\n break\n\n self.logger.debug(\n \"_break_down():field #%d pbtype #%d\", f_id, f_type\n )\n try:\n if f_type == 0: # vint\n field['data'] = self._decode_vint(buf)\n elif f_type == 1: # 64-bit\n field['data'] = self._read_fixed(buf, 8)\n elif f_type == 2: # str\n field['data'] = self._decode_str(buf)\n elif f_type == 5: # 32-bit\n field['data'] = self._read_fixed(buf, 4)\n else:\n self.logger.warning(\n \"_break_down():Ignore unknown type #%d\", f_type\n )\n continue\n except EndOfMessage as e:\n if type_override is None or e.partial:\n raise CodecError('Unexpected end of message while decoding field {0}'.format(f_id))\n else:\n break\n field['id'] = f_id\n field['wire_type'] = f_type\n yield field","def read_raw(self, offset, size, return_raw = False):\n raw_data = self.reader(offset, size)\n if raw_data is None:\n return None\n if return_raw:\n return raw_data\n else:\n if size == 1:\n data = struct.unpack(\"%dB\" %size, raw_data)[0]\n else:\n data = struct.unpack(\"%dB\" %size, raw_data)\n return data","def unpack(self, fmt, length=1):\n return struct.unpack(fmt, self.stream.read(length))[0]","def read(cls, proto):\n pass","def _decode_str(self, buf):\n length = self._decode_vint(buf)\n result = buf.read(length)\n if len(result) != length:\n raise EndOfMessage(True)\n return result","def _lowLevelRecv(self,buffer):\n import socket\n\n try: data = self.socket_reference.recv(buffer)\n except socket.error as error: raise CommClientException(str(error))\n\n return data","def _read(self):\n \n try:\n d = self._get_byte()\n ts = time.time()\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n ts = time.time()\n packet = [d]\n d = self._get_byte()\n if d == self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n ts = time.time()\n else:\n packet.append(d)\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n packet.append(d)\n if self._debug == True:\n print \"Serial:_read: unescaped\", packet\n packet = self._unescape(packet)\n \n crc = self._crc16(0, packet[1:-3])\n packet_crc = self._decode(packet[-3:-1])\n \n if crc != packet_crc:\n print \"Warning: wrong CRC! %x != %x %s\" % (crc, packet_crc, [\"%2x\" % i for i in packet])\n if self._debug:\n if self._ts == None:\n self._ts = ts\n else:\n print \"Serial:_read: %.4f (%.4f) Recv:\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\n self._ts = ts\n return RawPacket(ts, packet[1:-3], crc == packet_crc)\n except socket.timeout:\n return None","def read_type(self):\n return self.node.get_attr(Type).read()","def extract_packet(_buffer):\n if len(_buffer)>=5:\n mtype=_buffer[0]\n msglen=struct.unpack('!L',_buffer[1:5])[0]\n if len(_buffer)>=msglen+1:\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\n return None,None,_buffer","def decode_message(self, buf, message_type=None):\n self.debugStack = 0\n value, typedef, _ = self._decode_message(\"\", buf, message_type)\n return value, typedef","def read_elem(self):\n read_str = self.redis_client.lpop(self.buffer_name)\n return self.deserialize_elem(read_str)","def parse(self, buf: memoryview, params: Params) \\\n -> tuple[ParseableTypeT_co, memoryview]:\n ...","def get_data_from_body(_type, body, addressbook, mid):\n data = None\n if is_group_call(_type):\n data = get_group_call_data(decode_body(body), addressbook, mid)\n elif is_group_ctrl(_type):\n if is_group_v2_data(_type):\n data = get_group_update_data_v2(\n decode_body(body), addressbook, mid\n )\n else:\n data = get_group_update_data_v1(\n decode_body(body), addressbook, mid\n )\n\n return data","def readData(self, rawstring, datatype):\n data = rawstring[:-1] #remove last NULL byte\n\n if datatype == ERROR:\n if is_python3():\n data2 = data.tobytes()\n data = data2.decode('utf-8')\n return data\n elif datatype == STRING or datatype == DOUBLE:\n # try to convert data to a more appropriate type\n if is_python3():\n data2 = data.tobytes()\n data = data2.decode('utf-8')\n\n try:\n data = int(data)\n except:\n try:\n data = float(data)\n except:\n pass\n\n return data\n elif datatype == ASSOC:\n return rawtodictonary(rawstring)\n elif SpecArray.isArrayType(datatype):\n #Here we read cols and rows... which are *supposed* to be received in the header!!!\n #better approach: data contains this information (since it is particular to that data type)\n return SpecArray.SpecArray(rawstring, datatype, self.rows, self.cols)\n else:\n raise TypeError","def decode_message(buf, typedef=None, pos=0, end=None, group=False, depth=0, path=None):\n if end is None:\n end = len(buf)\n\n if typedef is None:\n typedef = {}\n else:\n # Don't want to accidentally modify the original\n typedef = copy.deepcopy(typedef)\n\n if path is None:\n path = []\n\n output = {}\n\n while pos < end:\n # Read in a field\n try:\n if six.PY2:\n tag, pos = decoder._DecodeVarint(str(buf), pos)\n else:\n tag, pos = decoder._DecodeVarint(buf, pos)\n except (IndexError, decoder._DecodeError) as exc:\n six.raise_from(DecoderException(\n \"Error decoding length from buffer: %r...\" %\n (binascii.hexlify(buf[pos : pos+8]))), exc)\n\n field_number, wire_type = wire_format.UnpackTag(tag)\n\n # Convert to str\n field_number = str(field_number)\n orig_field_number = field_number\n\n field_path = path[:]\n field_path.append(field_number)\n\n if wire_type not in blackboxprotobuf.lib.types.wire_type_defaults:\n raise DecoderException('%d is not a valid wire type at pos %d.' % (wire_type, pos), field_path)\n\n field_typedef = None\n if field_number in typedef:\n field_typedef = typedef[field_number]\n else:\n field_typedef = {}\n field_typedef['type'] = blackboxprotobuf.lib.types.wire_type_defaults[wire_type]\n\n field_type = field_typedef['type']\n\n # If field_type is None, its either an unsupported wire type, length delim or group\n # length delim we have to try and decode first\n field_out = None\n if field_type is None:\n if wire_type == wire_format.WIRETYPE_LENGTH_DELIMITED:\n out, field_type = decode_guess(buf, pos, depth=depth, path=field_path)\n if field_type == 'message':\n field_out, message_typedef, pos = out\n field_typedef['message_typedef'] = message_typedef\n else:\n field_out, pos = out\n elif wire_type == wire_format.WIRETYPE_END_GROUP:\n # TODO Should probably match the field_number to START_GROUP\n if not group:\n raise DecoderException( \"Found END_GROUP before START_GROUP\", field_path)\n # exit out\n return output, typedef, pos\n else:\n raise DecoderException(\"Could not find default type for wiretype: %d\" % wire_type, field_path)\n else:\n if field_type == 'message':\n #TODO probably big enough to factor out\n message_typedef = None\n # Check for a anonymous type\n if 'message_typedef' in field_typedef:\n message_typedef = field_typedef['message_typedef']\n # Check for type defined by message type name\n elif 'message_type_name' in field_typedef:\n message_typedef = blackboxprotobuf.lib.known_messages[\n field_typedef['message_type_name']]\n\n try:\n field_out, message_typedef, pos = decode_lendelim_message(\n buf, message_typedef, pos, path=field_path)\n # Save type definition\n field_typedef['message_typedef'] = message_typedef\n except DecoderException as exc:\n # If this is the root message just fail\n if pos == 0:\n six.reraise(*sys.exc_info())\n logging.debug(\n (\"Encountered exception when decoding message at %s \"\n \"with known typdef. Trying alt typedefs and then \"\n \"anonymous. Exception: \\n%s\"),\n \"->\".join(map(str, field_path)), str(exc))\n\n if field_out is None and 'alt_typedefs' in field_typedef:\n # check for an alternative type definition\n for alt_field_number, alt_typedef in field_typedef['alt_typedefs'].items():\n try:\n field_out, message_typedef, pos = decode_lendelim_message(\n buf, alt_typedef, pos, path=field_path)\n except DecoderException as exc:\n logging.debug(\n (\"Encountered exception when decoding message at %s with alt_typedef %s. Trying anonymous decoding next. Exception:\\n%s\"),\n \"->\".join(map(str, field_path)),\n str(alt_field_number),\n str(exc))\n\n if field_out is not None:\n # Found working typedef\n field_typedef['alt_typedefs'][alt_field_number] = message_typedef\n field_number = field_number + \"-\" + alt_field_number\n break\n\n if field_out is None:\n # Still no typedef, try anonymous, and let the error propogate if it fails\n field_out, message_typedef, pos = \\\n decode_lendelim_message(buf, {}, pos, path=field_path)\n\n if 'alt_typedefs' in field_typedef:\n # get the next higher alt field number\n alt_field_number = str(\n max(map(int, field_typedef['alt_typedefs'].keys()))\n + 1)\n else:\n field_typedef['alt_typedefs'] = {}\n alt_field_number = '1'\n\n field_typedef['alt_typedefs'][alt_field_number] = message_typedef\n field_number = field_number + \"-\" + alt_field_number\n elif field_type == 'group':\n group_typedef = None\n # Check for a anonymous type\n if 'group_typedef' in field_typedef:\n group_typedef = field_typedef['group_typedef']\n field_out, group_typedef, pos = \\\n decode_group(buf, group_typedef, pos, depth=depth, path=field_path)\n # Save type definition\n field_typedef['group_typedef'] = group_typedef\n else:\n # Verify wiretype matches\n if blackboxprotobuf.lib.types.wiretypes[field_type] != wire_type:\n raise DecoderException(\n \"Invalid wiretype for field number %s. %s is not wiretype %s\"\n % (field_number, field_type, wire_type), field_path)\n\n # Simple type, just look up the decoder\n try:\n field_out, pos = blackboxprotobuf.lib.types.decoders[field_type](buf, pos)\n except DecoderException as exc:\n exc.set_path(field_path)\n six.reraise(*sys.exc_info())\n field_typedef['type'] = field_type\n if 'name' not in field_typedef:\n field_typedef['name'] = ''\n\n field_key = field_number\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\n field_key = field_typedef['name']\n # Deal with repeats\n if field_key in output:\n if isinstance(field_out, list):\n if isinstance(output[field_key], list):\n output[field_key] += field_out\n else:\n output[field_key] = field_out.append(output[field_key])\n else:\n if isinstance(output[field_key], list):\n output[field_key].append(field_out)\n else:\n output[field_key] = [output[field_key], field_out]\n else:\n output[field_key] = field_out\n typedef[orig_field_number] = field_typedef\n if pos > end:\n raise DecoderException(\n \"Field sizes are greater than designated length. pos: %d end_pos: %d\" % (pos, end))\n # Should never hit here as a group\n if group:\n raise DecoderException(\"Got START_GROUP with no END_GROUP.\")\n return output, typedef, pos","def parse(self, val):\n # type: (bytes) -> Any\n return val.decode()","def _get_data(self, read_size):\n return self._character_device.read(read_size)","def Read(self):\n if not self._mem: return self.data\n\n logger.info(\"Read %s\" % self)\n self.data = self.hostmemmgr.read(self._mem, self.size)\n\n logger.info(\"=\" * 30, \"READ BUFFER\", \"=\" * 30)\n scapyfactory.Parse(self.data).Show()\n logger.info(\"=\" * 30, \"END READ BUFFER\", \"=\" * 30)\n\n return self.data","def decode_uvarint(buf, pos):\n # Convert buffer to string\n if six.PY2:\n buf = str(buf)\n try:\n value, pos = decoder._DecodeVarint(buf, pos)\n except (TypeError, IndexError, decoder._DecodeError) as exc:\n six.raise_from(\n DecoderException(\n \"Error decoding uvarint from %s...\"\n % binascii.hexlify(buf[pos : pos + 8])\n ),\n exc,\n )\n return (value, pos)","def read(type='hex', inc=False):\n bitstring = ''\n for i in [D7,D6,D5,D4,D3,D2,D1,D0]:\n bitstring += str(GPIO.input(i))\n if type == 'hex':\n rval = \"Ox%02x\" % (int(bitstring,2))\n elif type == \"int\":\n rval = int(bitstring,2)\n elif type == \"bin\":\n rval = \"{0:b}\".format(int(bitstring,2))\n else:\n rval = chr(int(bitstring,2))\n if inc:\n incr()\n return rval","def _parse_value(self, data, flags):\n\n\t\tif flags & Client._FLAG_COMPRESSED:\n\t\t\tdata = decompress(data)\n\n\t\tif flags == 0 or flags == Client._FLAG_COMPRESSED:\n\t\t\t# Either a bare string or a compressed string now decompressed...\n\t\t\tvalue = data\n\t\telif flags & Client._FLAG_INTEGER:\n\t\t\tvalue = int(data)\n\t\telif flags & Client._FLAG_LONG:\n\t\t\tvalue = long(data)\n\t\telif flags & Client._FLAG_PICKLE:\n\t\t\ttry:\n\t\t\t\tvalue = pickle.loads(data)\n\t\t\texcept Exception:\n\t\t\t\tself._debuglog('Pickle error...\\n')\n\t\t\t\tvalue = None\n\t\telse:\n\t\t\tself._debuglog(\"unknown flags on get: %x\\n\" % flags)\n\n\t\treturn value","def read_specific_message(self, msg_type):\n\n if not issubclass(msg_type, sirf_messages._SirfReceivedMessageBase):\n raise TypeError(\"msg_type must be a message type.\")\n\n msg = None\n\n while not isinstance(msg, msg_type):\n msg = self.read_message()\n #print(msg)\n\n return msg","def _read_fixed(buf, length):\n result = buf.read(length)\n actual = len(result)\n if actual != length:\n raise EndOfMessage(False if actual == 0 else True)\n return result","def data(self, overrun=0):\n data_type = self.data_type()\n data_length = self.raw_data_length()\n d = self.raw_data(overrun=overrun)\n\n if data_type == RegSZ or data_type == RegExpandSZ:\n if overrun > 0:\n # decode_utf16le() only returns the first string, but if we explicitly\n # ask for overrun, let's make a best-effort to decode as much as possible.\n return d.decode('utf16')\n else:\n return decode_utf16le(d)\n elif data_type == RegBin or data_type == RegNone:\n return d\n elif data_type == RegDWord:\n return struct.unpack_from(str(\"<I\"), d, 0)[0]\n elif data_type == RegMultiSZ:\n s = d.decode(\"utf16\")\n return s.split(\"\\x00\")\n elif data_type == RegQWord:\n return struct.unpack_from(str(\"<Q\"), d, 0)[0]\n elif data_type == RegBigEndian:\n return struct.unpack_from(str(\">I\"), d, 0)[0]\n elif data_type == RegLink or \\\n data_type == RegResourceList or \\\n data_type == RegFullResourceDescriptor or \\\n data_type == RegResourceRequirementsList:\n # we don't really support these types, but can at least\n # return raw binary for someone else to work with.\n return d\n elif data_type in (RegUint8, RegInt16, RegUint16, RegInt32, RegUint32, \n RegInt64, RegUint64, RegFloat, RegDouble, RegUnicodeChar, \n RegBoolean, RegUnicodeString, RegCompositeValue,RegDateTimeOffset, \n RegTimeSpan, RegGUID, RegUnk111, RegUnk112, RegUnk113, RegBytesArray, \n RegInt16Array, RegUint16Array, RegInt32Array, RegUInt32Array, \n RegInt64Array, RegUInt64Array, RegFloatArray, RegDoubleArray, \n RegUnicodeCharArray, RegBooleanArray, RegUnicodeStringArray):\n d = d[0:-8] # remove timestamp from end\n comp_type = data_type & 0xEFF # Apply mask for composite types\n return SettingsParse.ParseAppDataCompositeValue(comp_type, d, len(d))\n elif data_type == RegFileTime:\n return parse_windows_timestamp(struct.unpack_from(str(\"<Q\"), d, 0)[0])\n elif data_length < 5 or data_length >= 0x80000000:\n return struct.unpack_from(str(\"<I\"), d, 0)[0]\n else:\n raise UnknownTypeException(\"Unknown VK Record type 0x%x at 0x%x\" % (data_type, self.offset()))","def readinto(self, buf: bytes, write: int = 0x00, /) -> Optional[int]:","def readinto(self, buf: bytes, write: int = 0x00, /) -> Optional[int]:","def unpack_str_from(buffer: bytes, offset: int = 0) -> tuple[str, int]:\n length, length_size = _unpack_length_from(buffer, offset=offset)\n offset += length_size\n str_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\n value = str_bytes.decode('utf-8')\n return value, length_size + length","def _load_value(self, lvalue, ctyp):\n\n if ctyp.is_array:\n value = lvalue\n else:\n # TODO: inject evil bitfield manipulation code here:\n # self.logger.debug('Non-Array type is indexed %s', expr)\n ir_typ = self.get_ir_type(ctyp)\n if isinstance(ir_typ, ir.BlobDataTyp):\n # If we have a blob pointer and want its content\n # We must get the source of the address of:\n if isinstance(lvalue, ir.AddressOf):\n value = lvalue.src\n else:\n # This code is debatable, allocate new storage and copy\n # the data over there?\n value = self.emit(\n ir.Alloc(\"load_blob\", ir_typ.size, ir_typ.alignment)\n )\n value_ptr = self.emit(ir.AddressOf(value, \"value_ptr\"))\n self.gen_copy_struct(value_ptr, lvalue, ir_typ.size)\n elif isinstance(lvalue, BitFieldAccess):\n value = self._load_bitfield(lvalue, ir_typ)\n else:\n value = self.builder.emit_load(lvalue, ir_typ)\n return value","def _unpack(formatstring, packed):\n _checkString(formatstring, description='formatstring', minlength=1)\n _checkString(packed, description='packed string', minlength=1)\n\n if sys.version_info[0] > 2:\n packed = bytes(packed, encoding='latin1') # Convert types to make it Python3 compatible\n\n try:\n value = struct.unpack(formatstring, packed)[0]\n except:\n errortext = 'The received bytestring is probably wrong, as the bytestring-to-num conversion failed.'\n errortext += ' Bytestring: {0!r} Struct format code is: {1}'\n raise ValueError(errortext.format(packed, formatstring))\n\n return value","def decode_data(self, data, sophia_type):\n try:\n reply = self.client.cli.decode_data(body={\n \"data\": data,\n \"sophia-type\": sophia_type,\n })\n return reply.data.get('value'), reply.data.get('type', 'word')\n except OpenAPIClientException as e:\n raise ContractError(e)","def getType (self) :\n if self.buffer == None :\n self.buffer = self.fetch ()\n return self.buffer.classifi7","def _readobj(self, sock):\n buff = b\"\"\n while True:\n n_to_read = max(2048, len(buff))\n chunk = sock.recv(n_to_read)\n buff += chunk\n if len(chunk) != n_to_read:\n print(\"Got: {}\", buff)\n return json.loads(buff)","def get(self, key, value_type=ByteString):\n value_type = Value.ensure_value_type(value_type,\n parameter='value_type')\n return value_type.load_value(self, key)","def read_data(x, y, address, length, data_format, transceiver):\n\n # turn byte array into str for unpack to work\n data = buffer(transceiver.read_memory(x, y, address, length))\n result = struct.unpack_from(data_format, data)[0]\n return result","def _unpackb3(s, **options):\n if not isinstance(s, (bytes, bytearray)):\n raise TypeError(\"packed data must be type 'bytes' or 'bytearray'\")\n return _unpack(io.BytesIO(s), options)","def recv_data(self, maxbuffer=4096):\n try:\n buff = self.s.recv(maxbuffer)\n except OSError as e:\n print(e)\n return buff.decode()","def deserialize(self, str):\n try:\n end = 0\n start = end\n end += 1\n (self.result,) = _struct_B.unpack(str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def _image_data(buff):\n code = buff.getvalue()\n m = _size(code)\n if m:\n size = int(m.group(1))\n else:\n raise Exception('Internal error: PPM header not found')\n return code[m.end():], size","def loads_value(type_key, binary_data, version, vectors):\n # pylint: disable=too-many-return-statements\n\n if isinstance(type_key, bytes):\n type_key = type_keys.Value(type_key)\n\n if type_key == type_keys.Value.INTEGER:\n return struct.unpack(\"!q\", binary_data)[0]\n if type_key == type_keys.Value.FLOAT:\n return struct.unpack(\"!d\", binary_data)[0]\n if type_key == type_keys.Value.COMPLEX:\n return complex(*struct.unpack(formats.COMPLEX_PACK, binary_data))\n if type_key == type_keys.Value.NUMPY_OBJ:\n return common.data_from_binary(binary_data, np.load)\n if type_key == type_keys.Value.STRING:\n return binary_data.decode(common.ENCODE)\n if type_key == type_keys.Value.NULL:\n return None\n if type_key == type_keys.Value.CASE_DEFAULT:\n return CASE_DEFAULT\n if type_key == type_keys.Value.PARAMETER_VECTOR:\n return common.data_from_binary(binary_data, _read_parameter_vec, vectors=vectors)\n if type_key == type_keys.Value.PARAMETER:\n return common.data_from_binary(binary_data, _read_parameter)\n if type_key == type_keys.Value.PARAMETER_EXPRESSION:\n if version < 3:\n return common.data_from_binary(binary_data, _read_parameter_expression)\n else:\n return common.data_from_binary(\n binary_data, _read_parameter_expression_v3, vectors=vectors\n )\n\n raise exceptions.QpyError(f\"Serialization for {type_key} is not implemented in value I/O.\")","def _unpack_body(self, buff):\n\n # Unpack <return_code> and <count> (how many records affected or selected)\n self._return_code = struct_L.unpack_from(buff, offset=0)[0]\n\n # Separate return_code and completion_code\n self._completion_status = self._return_code & 0x00ff\n self._return_code >>= 8\n\n # In case of an error unpack the body as an error message\n if self._return_code != 0:\n self._return_message = unicode(buff[4:-1], self.charset, self.errors)\n if self._completion_status == 2:\n raise TarantoolError(self._return_code, self._return_message)\n\n # Unpack <count> (how many records affected or selected)\n self._rowcount = struct_L.unpack_from(buff, offset=4)[0]\n\n # If the response doesn't contain any tuple - there is nothing to unpack\n if self._body_length == 8:\n return\n\n # Parse response tuples (<fq_tuple>)\n if self._rowcount > 0:\n offset = 8 # The first 4 bytes in the response body is the <count> we have already read\n while offset < self._body_length:\n # In resonse tuples have the form <size><tuple> (<fq_tuple> ::= <size><tuple>).\n # Attribute <size> takes into account only size of tuple's <field> payload,\n # but does not include 4-byte of <cardinality> field.\n #Therefore the actual size of the <tuple> is greater to 4 bytes.\n tuple_size = struct.unpack_from(\"<L\", buff, offset)[0] + 4\n tuple_data = struct.unpack_from(\"<%ds\" % (tuple_size), buff, offset+4)[0]\n tuple_value = self._unpack_tuple(tuple_data)\n if self.field_types:\n self.append(self._cast_tuple(tuple_value))\n else:\n self.append(tuple_value)\n\n offset = offset + tuple_size + 4 # This '4' is a size of <size> attribute","def read(self, bytes):\r\n return int.from_bytes(self.__input__.read(bytes), byteorder='big')","def _get_data(self, read_size):\n return self._pipe.recv_bytes()","def _getVal(self, mask, size):\n\t\tif (int(self.header['flags']) & mask) > 0:\n\t\t\t# First unsigned short is the length of the string\n\t\t\ttxt = self.fpLnk.read(2)\n\t\t\tlength = struct.unpack(\"<H\", txt)[0]\n\t\t\t# Adjust for unicode\n\t\t\tlength = length * size\n\t\t\treturn self.fpLnk.read(length)","def _unpackb2(s, **options):\n if not isinstance(s, (str, bytearray)):\n raise TypeError(\"packed data must be type 'str' or 'bytearray'\")\n return _unpack(io.BytesIO(s), options)","def _receive(self, length):\n \n return self.device.read(length)","def _read_var(self, time_idx, pressure_idx, var_idx, lat_idx, lng_idx):\n offset = self.item_size * (\n time_idx * self.t_idx + pressure_idx * self.p_idx +\n var_idx * self.v_idx + lat_idx * self.l_idx + lng_idx)\n self.mm.seek(offset)\n return self.unpacker.unpack(self.mm.read(self.item_size))[0]","def read(self):\n self.close()\n return self._buffer.getvalue()","def convert_from_bytes(output: ResponseOutput, ty: Optional[Type]) -> Any:\n if ty == str:\n return bytearray(output.data).decode(\"UTF-8\")\n else:\n py_str = bytearray(output.data).decode(\"UTF-8\")\n from ast import literal_eval\n\n return literal_eval(py_str)","def decode_varint(buf, pos):\n # Convert buffer to string\n if six.PY2:\n buf = str(buf)\n try:\n value, pos = decoder._DecodeSignedVarint(buf, pos)\n except (TypeError, IndexError, decoder._DecodeError) as exc:\n six.raise_from(\n DecoderException(\n \"Error decoding varint from %s...\"\n % binascii.hexlify(buf[pos : pos + 8])\n ),\n exc,\n )\n return (value, pos)","def bdecode(f):\n\tbtype = TYPES[f.read(1)]\n\tif btype is not None:\n\t\tf.seek(-1, SEEK_CUR)\n\t\treturn DECODERS[btype](f)\n\telse: #Used in dicts and lists to designate an end\n\t\treturn None","def _unpack(chid, data, count=None, ftype=None, as_numpy=True):\n\n def array_cast(data, count, ntype, use_numpy):\n \"cast ctypes array to numpy array (if using numpy)\"\n if use_numpy:\n dtype = dbr.NP_Map.get(ntype, None)\n if dtype is not None:\n out = numpy.empty(shape=(count,), dtype=dbr.NP_Map[ntype])\n ctypes.memmove(out.ctypes.data, data, out.nbytes)\n else:\n out = numpy.ctypeslib.as_array(copy(data))\n else:\n out = copy(data)\n return out\n\n def unpack_simple(data, count, ntype, use_numpy):\n \"simple, native data type\"\n if count == 1 and ntype != dbr.STRING:\n return data[0]\n if ntype == dbr.STRING:\n out = []\n for elem in range(min(count, len(data))):\n this = strjoin('', data[elem]).rstrip()\n if NULLCHAR_2 in this:\n this = this[:this.index(NULLCHAR_2)]\n out.append(this)\n if len(out) == 1:\n out = out[0]\n return out\n if count > 1:\n data = array_cast(data, count, ntype, use_numpy)\n return data\n\n def unpack_ctrltime(data, count, ntype, use_numpy):\n \"ctrl and time data types\"\n if count == 1 or ntype == dbr.STRING:\n data = data[0].value\n if ntype == dbr.STRING and NULLCHAR in data:\n data = data[:data.index(NULLCHAR)]\n return data\n # fix for CTRL / TIME array data:Thanks to Glen Wright !\n data = (count*dbr.Map[ntype]).from_address(ctypes.addressof(data) +\n dbr.value_offset[ftype])\n if count > 1:\n data = array_cast(data, count, ntype, use_numpy)\n return data\n\n unpack = unpack_simple\n if ftype >= dbr.TIME_STRING:\n unpack = unpack_ctrltime\n\n if count is None and chid is not None:\n count = element_count(chid)\n if count is None:\n count = 1\n\n if ftype is None and chid is not None:\n ftype = field_type(chid)\n if ftype is None:\n ftype = dbr.INT\n ntype = native_type(ftype)\n use_numpy = (HAS_NUMPY and as_numpy and ntype != dbr.STRING and count > 1)\n return unpack(data, count, ntype, use_numpy)","def readinto(self, buf: bytes, nack: bool = True, /) -> None:","def readinto(self, buf: bytes, nack: bool = True, /) -> None:","def read(self, num=1):\n contents = self.stream.read(num)\n self.bitsRead += len(contents)\n self.observerRead(contents)\n return contents"],"string":"[\n \"def unpack_real(self, data_type, length):\\n\\t\\tif len(self.buff) < length:\\n\\t\\t\\traise IncompleteData()\\n\\t\\to = struct.unpack_from('!'+data_type, self.buff)[0]\\n\\t\\tself.buff = self.buff[length:]\\n\\t\\treturn o\",\n \"def recv_type(self, type_):\\n msg = self.recv()\\n assert msg and msg['type'] == type_, msg\\n return msg\",\n \"def read_type(adr, tyname):\\n data = Rsp.read_mem(adr,tyname2size(tyname))\\n data = bytes.fromhex(data)\\n res, = struct.unpack(tyname2fmt(tyname), data)\\n return(res)\",\n \"def get(self, given_type: t.Type, read_until: t.Union[str, None] = None, strip: bool = True) -> t.Union[None, bytes, str]:\\n\\n call_time = time.time() # time that the function was called\\n\\n if (given_type != str and given_type != bytes):\\n raise TypeError(\\\"given_type must be literal 'str' or 'bytes'\\\")\\n\\n if (given_type == str):\\n return self._get_str(call_time, read_until=read_until, strip=strip)\\n else:\\n return self._get_bytes(call_time)\",\n \"def read_and_unpack(self, fmt):\\n try:\\n return unpack(\\n self.byte_order + fmt,\\n self.read(calcsize(self.byte_order + fmt)))\\n except Exception as e:\\n if e.args[0].startswith('unpack requires a buffer of'):\\n raise EOFError(e)\\n else:\\n raise\",\n \"def get_buf(self, data_type = \\\"void\\\"):\\n if self.buf is not None:\\n return ffi.cast(data_type + \\\"*\\\", self.buf)\\n else:\\n raise RuntimeError(\\\"Buffer not created.\\\")\",\n \"def read(self, fmt):\\n fmt = '>' + fmt\\n if not PY3:\\n fmt = fmt.encode('utf-8')\\n return struct.unpack(fmt, self.bin.read(format_byte_size(fmt)))\",\n \"def ReadProcessMemory(\\n process_handle: int,\\n address: int,\\n pytype: Type[T],\\n bufflength: int\\n) -> T:\\n if pytype not in [bool, int, float, str, bytes]:\\n raise ValueError(\\\"The type must be bool, int, float, str or bytes.\\\")\\n\\n data = get_c_type_of(pytype, bufflength)\\n kernel32.ReadProcessMemory(process_handle, ctypes.c_void_p(address), ctypes.byref(data), bufflength, None)\\n\\n return str(data.value) if pytype is str else data.value\",\n \"def parse(cls, buf: memoryview, params: Params) \\\\\\n -> tuple[AnyParseable, memoryview]:\\n for data_type in params.expected:\\n try:\\n return data_type.parse(buf, params)\\n except NotParseable:\\n pass\\n raise UnexpectedType(buf)\",\n \"async def get(self, kind=None):\\n if kind is None:\\n kind = self.data_type\\n\\n data = await self.read()\\n if kind == DataType.TEXT:\\n return data.decode()\\n elif kind == DataType.BINARY:\\n return data\",\n \"def Read(buf: IO[bytes]) -> Optional[bytes]:\\n count_bytes = buf.read(_UINT64.size)\\n if not count_bytes:\\n return None\\n\\n try:\\n (count,) = _UINT64.unpack(count_bytes)\\n except struct.error as error:\\n raise ValueError(f\\\"Incorrect size tag {count_bytes}: {error}\\\")\\n\\n # It might happen that we are given file with incorrect format. If the size\\n # tag is interpreted as a huge number, reading the buffer will lead to raising\\n # an exception, because Python will try to allocate a buffer to read into. If\\n # possible, we try to check guard against such situations and provide more\\n # informative exception message.\\n\\n def Error(left: int) -> ValueError:\\n message = f\\\"Malformed input (reading {count} bytes out of {left} available)\\\"\\n return ValueError(message)\\n\\n if buf.seekable():\\n position = buf.tell()\\n\\n buf.seek(0, os.SEEK_END)\\n size = buf.tell()\\n\\n if count > size - position:\\n raise Error(size - position)\\n\\n buf.seek(position, os.SEEK_SET)\\n\\n chunk = buf.read(count)\\n if len(chunk) != count:\\n raise Error(len(chunk))\\n\\n return chunk\",\n \"def decode_buffer(buf):\\n return buf.getvalue().decode('utf-8')\",\n \"def readinto(self, buf: bytes, /) -> Optional[int]:\",\n \"def get_data(self, ptr, unbuffered=False):\\n return _decode(self.get_raw_data(ptr, unbuffered),\\n reading_format[self.data_format])\",\n \"def read(self, tag): # type: (Number) -> (Tag, any)\\n if tag.type != Types.Primitive:\\n raise ASN1Error('Only primitive types can be read.')\\n\\n nr = tag.number\\n length = tag.length\\n\\n bytes_data = self._read_bytes(0, length)\\n self._buffer = self._buffer[length:]\\n if tag.cls != Classes.Universal:\\n value = bytes_data\\n elif nr == Numbers.Boolean:\\n value = self._decode_boolean(bytes_data)\\n elif nr in (Numbers.Integer, Numbers.Enumerated):\\n value = self._decode_integer(bytes_data)\\n elif nr == Numbers.Null:\\n value = self._decode_null(bytes_data)\\n elif nr == Numbers.ObjectIdentifier:\\n value = self._decode_object_identifier(bytes_data)\\n elif nr in (\\n Numbers.PrintableString, Numbers.IA5String, Numbers.UTCTime\\n ):\\n value = bytes_data.decode('utf-8')\\n else:\\n value = bytes_data\\n\\n self._resetTag()\\n return value\",\n \"def unpack(self,format,size,recType='-----'):\\n endPos = self.ins.tell() + size\\n if endPos > self.size:\\n raise Tes3ReadError(self.inName, recType,endPos,self.size)\\n return struct.unpack(format,self.ins.read(size))\",\n \"def get(typ, **kw):\\n\\t\\treturn crypto.hexlify(getattr(Payload, \\\"type%d\\\" % typ)(**kw))\",\n \"def get_type_unpack(self, arg, option):\\n pass\",\n \"def parse_type(fobj, data_type):\\n if data_type == \\\"Boolean\\\": ## False if 0x00 else True\\n return bool(fobj.read(1))\\n elif data_type == \\\"Byte\\\": ## 1 byte int\\n return fobj.read(1)[0]\\n elif data_type == \\\"DateTime\\\": ## 8 bytes signed int\\n return struct.unpack(\\\"<q\\\", fobj.read(8))[0]\\n elif data_type == \\\"Double\\\": ## 8 bytes floating point\\n return struct.unpack(\\\"<d\\\", fobj.read(8))[0]\\n elif data_type == \\\"Int\\\": ## 4 bytes unsigned int\\n return struct.unpack(\\\"<I\\\", fobj.read(4))[0]\\n elif data_type == \\\"Int-Double pair\\\": ## 0x08-Int-0x0d-Double with AssertionError\\n bb = fobj.read(1)[0]\\n if bb != 0x08:\\n raise AssertionError('parse_type(fobj, data_type): '\\n '1st byte(%s) of \\\"Int-Double pair\\\" != 0x08' % bb)\\n first_int = parse_type(fobj, \\\"Int\\\")\\n bb = fobj.read(1)[0]\\n if bb != 0x0d:\\n raise AssertionError('parse_type(fobj, data_type): '\\n '6th byte(%s) of \\\"Int-Double pair\\\" != 0x0d' % bb)\\n return [first_int, parse_type(fobj, \\\"Double\\\")]\\n elif data_type == \\\"Int-Double pair*\\\": ## int(n) - \\\"Int-Double pair\\\"*n\\n return [parse_type(fobj, \\\"Int-Double pair\\\") for i in range(parse_type(fobj, \\\"Int\\\"))]\\n elif data_type == \\\"Long\\\": ## 8 bytes unsigned int\\n return struct.unpack(\\\"<Q\\\", fobj.read(8))[0]\\n elif data_type == \\\"Short\\\": ## 2 bytes unsigned int\\n return struct.unpack(\\\"<H\\\", fobj.read(2))[0]\\n elif data_type == \\\"Single\\\": ## 4 bytes floating point\\n return struct.unpack(\\\"<f\\\", fobj.read(4))[0]\\n elif data_type == \\\"String\\\": ## 0x00 or 0x0b - ULE128(n) - UTF-8(length=n)\\n bb = fobj.read(1)[0]\\n if bb == 0x00:\\n return None\\n elif bb != 0x0b:\\n ## TODO: show integers in assertion error in hexadecimal and decimal\\n ## to make debug more convenient (cause I may inspect the file in a byte reader.\\n raise AssertionError('parse_type(fobj, data_type): '\\n '1st byte(%s) of \\\"String\\\" not in {0x00, 0x0b}' % bb)\\n strlen = parse_type(fobj, \\\"ULEB128\\\")\\n return fobj.read(strlen).decode(\\\"utf-8\\\")\\n elif data_type == \\\"ULEB128\\\": ## https://en.wikipedia.org/wiki/LEB128#Decode_unsigned_integer\\n i = 0 ## derived from the wiki psuedo code\\n res = 0\\n shift = 0\\n while True:\\n bb = fobj.read(1)[0]\\n i += 1\\n res |= ((bb & 0b1111111) << shift)\\n if (bb & 0b10000000) == 0:\\n break\\n shift += 7\\n return res\\n elif data_type == \\\"Timing point\\\": ## Double - Double - Boolean\\n return parse_types(fobj, [\\\"Double\\\", \\\"Double\\\", \\\"Boolean\\\"])\\n elif data_type == \\\"Timing point+\\\": ## int(n) - \\\"Timing point\\\"*n\\n return [parse_type(fobj, \\\"Timing point\\\") for i in range(parse_type(fobj, \\\"Int\\\"))]\\n else:\\n raise NotImplementedError('parse_type(fobj, data_type): Unknown data type: \\\"%s\\\".' % data_type)\",\n \"def dataRipFrom8583(text,typ) :\\n\\ttyp1,length1,varlength = DataTypeDetail(typ)\\n\\tif typ1 == 'z' :\\n\\t\\treturn (text,len(text))\\n\\n\\tif length1=='' :\\n\\t\\traise Exception('type definition miss length(%s)' % typ)\\n\\tif typ1=='' :\\n\\t\\traise Exception('type definition miss type(%s)' % typ)\\n\\tif varlength :\\n\\t\\tl = len(length1)\\n\\t\\tmaxlength = 0\\n\\t\\ttry :\\n\\t\\t\\tmaxlength = int(length1)\\n\\t\\texcept :\\n\\t\\t\\traise \\n\\t\\ts1 = text[:l]\\n\\t\\tdatalen = 0 \\n\\t\\ttry :\\n\\t\\t\\tdatalen = int(s1)\\n\\t\\texcept :\\n\\t\\t\\traise Exception('need int but not,(%s)' % s1)\\n\\t\\tif datalen > maxlength :\\n\\t\\t\\traise Exception('%d extend maxlen(%d)' % (datalen,maxlength))\\n\\t\\tvalue = text[l:l+datalen]\\n\\t\\treturn (value,l + datalen)\\n\\tdatalen = int(length1)\\n\\tif typ1=='b' :\\n\\t\\tdatalen,v = divmod(datalen,8)\\n\\t\\tif v :\\n\\t\\t\\tdatalen += 1\\n\\n\\tvalue = text[:datalen]\\n\\t#for i in value :\\n\\t#\\tif not checkCharType(typ1,i) :\\n\\t#\\t\\ts = 'typ1= %s' % typ1 + 'i=%s' % i\\n\\t#\\t\\traise s,text\\n\\treturn (value,datalen)\",\n \"def unmarshal(cls, buf):\\n umfunc = getattr(lib, f\\\"Tss2_MU_{cls.__name__}_Unmarshal\\\", None)\\n if umfunc is None:\\n raise RuntimeError(f\\\"No unmarshal function found for {cls.__name__}\\\")\\n _cdata = ffi.new(f\\\"{cls.__name__} *\\\")\\n offset = ffi.new(\\\"size_t *\\\")\\n _chkrc(umfunc(buf, len(buf), offset, _cdata))\\n return cls(_cdata=_cdata), offset[0]\",\n \"def _unpack(self, _format: str, size: int) -> Any:\\n return unpack(_format, self.read(size))[0]\",\n \"def stateless_unpack(buff, to_server):\\n\\tdecoder = PacketDecoder(to_server)\\n\\tdecoder.buff = buff\\n\\tpacket = decoder.read_packet()\\n\\treturn packet, decoder.buff\",\n \"def unpack(self, fmt):\\n try:\\n data = self.get(struct.calcsize(fmt))\\n return struct.unpack(fmt, data)\\n except struct.error as e:\\n raise BufferError(\\n \\\"Error unpacking struct '%s' <%s>\\\" %\\n (fmt, binascii.hexlify(data).decode())\\n )\",\n \"def unpack_type_spec_from(\\n buffer: bytes, offset: int = 0\\n) -> tuple[computation_types.Type, int]:\\n length, length_size = _unpack_length_from(buffer, offset=offset)\\n offset += length_size\\n type_spec_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\\n proto = computation_pb2.Type.FromString(type_spec_bytes)\\n type_spec = type_serialization.deserialize_type(proto)\\n return type_spec, length_size + length # pytype: disable=bad-return-type\",\n \"def unpack (self, buffer):\\n\\t\\timport struct\\n\\t\\tvalues = struct.unpack (self.struct, buffer)\\n\\t\\tj = 0\\n\\t\\tfor i in self.structref:\\n\\t\\t\\tself.value[i[self.NAME]] = values[j]\\n\\t\\t\\tj = j + 1\",\n \"def read_packet(self):\\n\\n\\t\\t#self.debug(\\\"READ BUFFER SIZE: %d\\\" % len(self.buff))\\n\\t\\tbackup = self.buff[:]\\n\\t\\tpacket = Packet()\\n\\t\\ttry:\\n\\t\\t\\tpacket.direction = self.node\\n\\t\\t\\tpacket.ident = self.unpack('ubyte')\\n\\t\\t\\t\\n\\t\\t\\t#Defined structs from huge dict\\n\\t\\t\\tfor datatype, name in self.get_struct(packet):\\n\\t\\t\\t\\t# this populates packet.data with {name: value}\\n\\t\\t\\t\\tpacket.data[name] = self.unpack(datatype)\\n\\n\\t\\t\\t# I believe the following are packet-type specific fixes for variable-length packets.\\n\\n\\t\\t\\t#0x17\\n\\t\\t\\tif packet.ident == 0x17:\\n\\t\\t\\t\\tif packet.data['unknown'] > 0:\\n\\t\\t\\t\\t\\tpacket.data['x2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['y2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['z2'] = self.unpack('short')\\n\\t\\t\\n\\t\\t\\t#0x33\\n\\t\\t\\tif packet.ident in (0x33, 0x34):\\n\\t\\t\\t\\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n#\\t\\t\\t#0x34\\n#\\t\\t\\tif packet.ident == 0x34:\\n#\\t\\t\\t\\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\\n#\\t\\t\\t\\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n#\\t\\t\\t\\tfor i in zip(coords, btype, metadata):\\n#\\t\\t\\t\\t\\tblock = {}\\n#\\t\\t\\t\\t\\tblock[\\\"x\\\"] =\\t\\ti[0] >> 12\\n#\\t\\t\\t\\t\\tblock[\\\"z\\\"] = 0x0F & i[0] >> 8\\n#\\t\\t\\t\\t\\tblock[\\\"y\\\"] = 0xFF & i[0]\\n#\\t\\t\\t\\t\\tblock[\\\"type\\\"] = i[1]\\n#\\t\\t\\t\\t\\tblock[\\\"metadata\\\"] = i[2]\\n#\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(block)\\n#\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x3C\\n\\t\\t\\tif packet.ident == 0x3C:\\n\\t\\t\\t\\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\\n\\t\\t\\t\\ti = 0\\n\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n\\t\\t\\t\\twhile i < packet.data['data_size']*3:\\n\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(dict(zip(('x','y','z'), records[i:i+3])))\\n\\t\\t\\t\\t\\ti+=3\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x68\\n\\t\\t\\tif packet.ident == 0x68:\\n\\t\\t\\t\\tpacket.data[\\\"slots_data\\\"] = self.unpack_array('slot', packet.data[\\\"data_size\\\"])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\t#0x82:\\n\\t\\t\\tif packet.ident == 0x82:\\n\\t\\t\\t\\tpacket.data[\\\"text\\\"] = []\\n\\t\\t\\t\\tfor i in range(4):\\n\\t\\t\\t\\t\\tpacket.data[\\\"text\\\"].append(packet.data[\\\"line_%s\\\" % (i+1)])\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t#0x83\\n\\t\\t\\tif packet.ident == 0x83:\\n\\t\\t\\t\\tpacket.data[\\\"data\\\"] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\n\\t\\t\\t# Sets packet.original to the byte string that the packet was decoded from.\\n\\t\\t\\tpacket.original = backup[:len(backup) - len(self.buff)]\\n\\n\\t\\t\\treturn packet\\n\\n\\t\\texcept IncompleteData:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\treturn None\\n\\t\\texcept Exception, ex:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\tex.args += (self.buff[20:],)\\n\\t\\t\\traise\",\n \"def read(self, buf):\\n contents = dict()\\n for element in self.elements:\\n if element.offset + element.size > len(buf):\\n logger.trace(\\\"cannot unpack {} for {}.{} buffer too small {}\\\",\\n element.name, element.block_name, element.block_version, len(buf))\\n contents[element.name] = None\\n continue\\n s, = struct.unpack_from(element.structure, buf, element.offset)\\n if element.decode:\\n s = element.decode(s)\\n contents[element.name] = s\\n return contents\",\n \"def get_value(self, addr, type_, is_global=False):\\n # print(f\\\"Get value at {addr} of {type_}. Global {is_global}\\\")\\n # Las listas están guardadas en su tipo primitivo, por eso se quitan los '[]'\\n if type_.startswith('['):\\n type_ = type_.strip('[]')\\n if is_global:\\n search_memory = self.memory_stack[0]\\n else:\\n search_memory = self.memory\\n if type_ == \\\"Int\\\":\\n return search_memory[self.INT_BASE + addr]\\n elif type_ == \\\"Float\\\":\\n return search_memory[self.FLOAT_BASE + addr]\\n elif type_ == \\\"Bool\\\":\\n return search_memory[self.BOOL_BASE + addr]\\n elif type_ == \\\"String\\\":\\n return search_memory[self.STRING_BASE + addr]\\n elif type_ == \\\"Any\\\":\\n return search_memory[self.EMPTY_ARR + addr]\",\n \"def _extract_bytes(l):\\n # input should consist of a list of strings similar to ['123456', 'bytes', 'read']\\n if len(l) != 3 or l[1] != 'bytes' or l[2] != 'read':\\n raise UBootError('received unexpected reply when reading file')\\n\\n try:\\n return int(l[0])\\n except ValueError:\\n raise UBootError('received unexpected bytes value when reading file')\",\n \"def unpackb(value):\\n return load(io.BytesIO(value))\",\n \"def parseDbValue(buffer, vtype=str): \\n m = _dbParserRe.match(buffer.strip())\\n if not m: \\n raise RuntimeError(\\\"cannot parse value from dbBuffer %r\\\"%buffer) \\n vltType, svalue = m.groups() \\n try:\\n value = vtype(svalue)\\n except (TypeError, ValueError):\\n raise RuntimeError(\\\"cannot convert value from dbBuffer %r into a %r\\\"%(buffer, vtype))\\n\\n return vltType, value\",\n \"def loads(value):\\n return unpackb(value)\",\n \"def _unpack_tuple(self, buff):\\n cardinality = struct_L.unpack_from(buff)[0]\\n _tuple = ['']*cardinality\\n offset = 4 # The first 4 bytes in the response body is the <count> we have already read\\n for i in xrange(cardinality):\\n field_size, offset = self._unpack_int_base128(buff, offset)\\n field_data = struct.unpack_from(\\\"<%ds\\\" % field_size, buff, offset)[0]\\n _tuple[i] = field(field_data)\\n offset += field_size\\n\\n return tuple(_tuple)\",\n \"def _getvaluefrombuffer(buf, loc):\\n if len(loc) > 1:\\n return _getvaluefrombuffer(buf.__dict__[loc[0]], loc[1:])\\n if not hasattr(buf, loc[0]):\\n raise RuntimeError(\\\"Requested <field> does not exist.\\\")\\n return buf.__dict__[loc[0]]\",\n \"def read(cls, buf):\\n has_bytes = buf.remaining()\\n if has_bytes < 1:\\n raise NeedBytes, 1\\n\\n first = buf.read_uchar()\\n\\n size = (((first & 0xc0) >> 6) ^ 0x3) << 2\\n if size == 0:\\n size = 1\\n\\n if has_bytes < size:\\n raise NeedBytes, size-has_bytes\\n\\n object_id = first & 0x3f\\n timestamp = length = type = stream_id = None\\n\\n if size != 1:\\n timestamp = buf.read_24bit_uint()\\n\\n if size >= 8:\\n length = buf.read_24bit_uint()\\n type = buf.read_uchar()\\n\\n if size == 12:\\n stream_id = buf.read_ulong()\\n\\n return RTMPHeader(object_id, timestamp, length, type, stream_id)\",\n \"def deserialize(self, data: bytes) -> Tuple[str, Any]:\\n if self.cache_config['CACHE_CONTENT_TYPE_JSON_ONLY']:\\n return data\\n else:\\n return msgpack.unpackb(data, raw=False)\",\n \"def decode_network_values(ptype, plen, buf):\\n nvalues = short.unpack_from(buf, header.size)[0]\\n off = header.size + short.size + nvalues\\n valskip = double.size\\n\\n # Check whether our expected packet size is the reported one\\n assert ((valskip + 1) * nvalues + short.size + header.size) == plen\\n assert double.size == number.size\\n\\n result = []\\n\\n for dstype in buf[header.size + short.size:off]:\\n if type(dstype) is type(\\\"foo\\\"): ## Python 2 handles dsType as a string!\\n dstype = int(dstype.encode('hex'))\\n \\n if dstype == DS_TYPE_COUNTER:\\n result.append((dstype, number.unpack_from(buf, off)[0]))\\n off += valskip\\n elif dstype == DS_TYPE_GAUGE:\\n result.append((dstype, double.unpack_from(buf, off)[0]))\\n off += valskip\\n elif dstype == DS_TYPE_DERIVE:\\n result.append((dstype, number.unpack_from(buf, off)[0]))\\n off += valskip\\n elif dstype == DS_TYPE_ABSOLUTE:\\n pprint(\\\"DS_TYPE_ABSOLUTE\\\")\\n result.append((dstype, number.unpack_from(buf, off)[0]))\\n off += valskip\\n else:\\n raise ValueError(\\\"DS type %i unsupported\\\" % dstype)\\n\\n return result\",\n \"def readinto(self, buf: bytes, nbytes: int, /) -> Optional[int]:\",\n \"def get_rom_data(self, address, data_type=protocol.EEPROM_DATA_TYPE_BYTE):\\n cmd = protocol.GET_EEPROM.format(address, data_type)\\n response = self.__send_and_receive(cmd)\\n value = self.__gen_response_value(response)\\n if value:\\n # print(\\\"val: {}\\\".format(type)))\\n val = \\\"\\\".join(value)[1:]\\n\\n if data_type == protocol.EEPROM_DATA_TYPE_FLOAT:\\n return float(val)\\n elif data_type == protocol.EEPROM_DATA_TYPE_INTEGER:\\n return int(val)\\n elif data_type == protocol.EEPROM_DATA_TYPE_BYTE:\\n return int(val)\\n else:\\n return False\",\n \"def type(self):\\n return struct.unpack('<B', self.raw_data[0])[0]\",\n \"def from_buffer(cls, buf, **kwargs):\\n cls._initialize(**kwargs)\\n # perform processing\\n try:\\n filetype = cls.cookie.buffer(buf)\\n if cls.old_api:\\n cls.cookie.close()\\n except magic.MagicException:\\n # should never enter here, but in case of\\n filetype = None\\n return filetype\",\n \"def decode(type_info: CLType, as_bytes: typing.List[int]) -> typing.List[int]:\\n if isinstance(type_info, CLType_Simple):\\n entity = _SIMPLE_TYPE_DECODERS[type_info.typeof](as_bytes)\\n elif isinstance(type_info, CLType_ByteArray):\\n entity = decode_byte_array(as_bytes)\\n elif isinstance(type_info, CLType_Option):\\n entity = decode_option(as_bytes, type_info.inner_type)\\n else:\\n entity = None\\n\\n return entity\",\n \"def readinto(self, buf: AnyWritableBuf, /) -> int | None:\",\n \"def readinto(self, buf: AnyWritableBuf, /) -> int | None:\",\n \"def read_value(stream):\\n strip_whitespace(stream)\\n\\n if stream.eof():\\n raise VeryUnexpectedEndException(stream, \\\"Encountered EOF while scanning for a value\\\")\\n\\n char = stream.peek()\\n if '\\\"' == char:\\n value = read_string(stream)\\n value_type = SUCH_STRING\\n\\n elif char in VALID_TOKEN_CHARS:\\n value = read_token(stream)\\n value_type = SUCH_CONST\\n if \\\"yes\\\" == value:\\n value = True\\n elif \\\"no\\\" == value:\\n value = False\\n elif \\\"empty\\\" == value:\\n value = None\\n else:\\n # It's a token Bob!\\n value_type = SUCH_TOKEN\\n\\n elif char in \\\"1234567890\\\":\\n value = read_number(stream)\\n value_type = SUCH_NUMBER\\n\\n else:\\n raise ManyParseException(stream, \\\"Invalid value start character: {!r}\\\".format(char))\\n\\n return value, value_type\",\n \"def _break_down(self, buf, type_override=None, id_override=None):\\n assert (id_override is not None and type_override is not None) or\\\\\\n (id_override is None and type_override is None),\\\\\\n 'Field ID and type must be both specified in headerless mode'\\n\\n while 1:\\n field = {}\\n if type_override is not None:\\n f_type = type_override\\n f_id = id_override\\n else:\\n # if no more data, stop and return\\n try:\\n f_type, f_id = self._decode_header(buf)\\n except EOFError:\\n break\\n\\n self.logger.debug(\\n \\\"_break_down():field #%d pbtype #%d\\\", f_id, f_type\\n )\\n try:\\n if f_type == 0: # vint\\n field['data'] = self._decode_vint(buf)\\n elif f_type == 1: # 64-bit\\n field['data'] = self._read_fixed(buf, 8)\\n elif f_type == 2: # str\\n field['data'] = self._decode_str(buf)\\n elif f_type == 5: # 32-bit\\n field['data'] = self._read_fixed(buf, 4)\\n else:\\n self.logger.warning(\\n \\\"_break_down():Ignore unknown type #%d\\\", f_type\\n )\\n continue\\n except EndOfMessage as e:\\n if type_override is None or e.partial:\\n raise CodecError('Unexpected end of message while decoding field {0}'.format(f_id))\\n else:\\n break\\n field['id'] = f_id\\n field['wire_type'] = f_type\\n yield field\",\n \"def read_raw(self, offset, size, return_raw = False):\\n raw_data = self.reader(offset, size)\\n if raw_data is None:\\n return None\\n if return_raw:\\n return raw_data\\n else:\\n if size == 1:\\n data = struct.unpack(\\\"%dB\\\" %size, raw_data)[0]\\n else:\\n data = struct.unpack(\\\"%dB\\\" %size, raw_data)\\n return data\",\n \"def unpack(self, fmt, length=1):\\n return struct.unpack(fmt, self.stream.read(length))[0]\",\n \"def read(cls, proto):\\n pass\",\n \"def _decode_str(self, buf):\\n length = self._decode_vint(buf)\\n result = buf.read(length)\\n if len(result) != length:\\n raise EndOfMessage(True)\\n return result\",\n \"def _lowLevelRecv(self,buffer):\\n import socket\\n\\n try: data = self.socket_reference.recv(buffer)\\n except socket.error as error: raise CommClientException(str(error))\\n\\n return data\",\n \"def _read(self):\\n \\n try:\\n d = self._get_byte()\\n ts = time.time()\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n ts = time.time()\\n packet = [d]\\n d = self._get_byte()\\n if d == self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n ts = time.time()\\n else:\\n packet.append(d)\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n packet.append(d)\\n if self._debug == True:\\n print \\\"Serial:_read: unescaped\\\", packet\\n packet = self._unescape(packet)\\n \\n crc = self._crc16(0, packet[1:-3])\\n packet_crc = self._decode(packet[-3:-1])\\n \\n if crc != packet_crc:\\n print \\\"Warning: wrong CRC! %x != %x %s\\\" % (crc, packet_crc, [\\\"%2x\\\" % i for i in packet])\\n if self._debug:\\n if self._ts == None:\\n self._ts = ts\\n else:\\n print \\\"Serial:_read: %.4f (%.4f) Recv:\\\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\\n self._ts = ts\\n return RawPacket(ts, packet[1:-3], crc == packet_crc)\\n except socket.timeout:\\n return None\",\n \"def read_type(self):\\n return self.node.get_attr(Type).read()\",\n \"def extract_packet(_buffer):\\n if len(_buffer)>=5:\\n mtype=_buffer[0]\\n msglen=struct.unpack('!L',_buffer[1:5])[0]\\n if len(_buffer)>=msglen+1:\\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\\n return None,None,_buffer\",\n \"def decode_message(self, buf, message_type=None):\\n self.debugStack = 0\\n value, typedef, _ = self._decode_message(\\\"\\\", buf, message_type)\\n return value, typedef\",\n \"def read_elem(self):\\n read_str = self.redis_client.lpop(self.buffer_name)\\n return self.deserialize_elem(read_str)\",\n \"def parse(self, buf: memoryview, params: Params) \\\\\\n -> tuple[ParseableTypeT_co, memoryview]:\\n ...\",\n \"def get_data_from_body(_type, body, addressbook, mid):\\n data = None\\n if is_group_call(_type):\\n data = get_group_call_data(decode_body(body), addressbook, mid)\\n elif is_group_ctrl(_type):\\n if is_group_v2_data(_type):\\n data = get_group_update_data_v2(\\n decode_body(body), addressbook, mid\\n )\\n else:\\n data = get_group_update_data_v1(\\n decode_body(body), addressbook, mid\\n )\\n\\n return data\",\n \"def readData(self, rawstring, datatype):\\n data = rawstring[:-1] #remove last NULL byte\\n\\n if datatype == ERROR:\\n if is_python3():\\n data2 = data.tobytes()\\n data = data2.decode('utf-8')\\n return data\\n elif datatype == STRING or datatype == DOUBLE:\\n # try to convert data to a more appropriate type\\n if is_python3():\\n data2 = data.tobytes()\\n data = data2.decode('utf-8')\\n\\n try:\\n data = int(data)\\n except:\\n try:\\n data = float(data)\\n except:\\n pass\\n\\n return data\\n elif datatype == ASSOC:\\n return rawtodictonary(rawstring)\\n elif SpecArray.isArrayType(datatype):\\n #Here we read cols and rows... which are *supposed* to be received in the header!!!\\n #better approach: data contains this information (since it is particular to that data type)\\n return SpecArray.SpecArray(rawstring, datatype, self.rows, self.cols)\\n else:\\n raise TypeError\",\n \"def decode_message(buf, typedef=None, pos=0, end=None, group=False, depth=0, path=None):\\n if end is None:\\n end = len(buf)\\n\\n if typedef is None:\\n typedef = {}\\n else:\\n # Don't want to accidentally modify the original\\n typedef = copy.deepcopy(typedef)\\n\\n if path is None:\\n path = []\\n\\n output = {}\\n\\n while pos < end:\\n # Read in a field\\n try:\\n if six.PY2:\\n tag, pos = decoder._DecodeVarint(str(buf), pos)\\n else:\\n tag, pos = decoder._DecodeVarint(buf, pos)\\n except (IndexError, decoder._DecodeError) as exc:\\n six.raise_from(DecoderException(\\n \\\"Error decoding length from buffer: %r...\\\" %\\n (binascii.hexlify(buf[pos : pos+8]))), exc)\\n\\n field_number, wire_type = wire_format.UnpackTag(tag)\\n\\n # Convert to str\\n field_number = str(field_number)\\n orig_field_number = field_number\\n\\n field_path = path[:]\\n field_path.append(field_number)\\n\\n if wire_type not in blackboxprotobuf.lib.types.wire_type_defaults:\\n raise DecoderException('%d is not a valid wire type at pos %d.' % (wire_type, pos), field_path)\\n\\n field_typedef = None\\n if field_number in typedef:\\n field_typedef = typedef[field_number]\\n else:\\n field_typedef = {}\\n field_typedef['type'] = blackboxprotobuf.lib.types.wire_type_defaults[wire_type]\\n\\n field_type = field_typedef['type']\\n\\n # If field_type is None, its either an unsupported wire type, length delim or group\\n # length delim we have to try and decode first\\n field_out = None\\n if field_type is None:\\n if wire_type == wire_format.WIRETYPE_LENGTH_DELIMITED:\\n out, field_type = decode_guess(buf, pos, depth=depth, path=field_path)\\n if field_type == 'message':\\n field_out, message_typedef, pos = out\\n field_typedef['message_typedef'] = message_typedef\\n else:\\n field_out, pos = out\\n elif wire_type == wire_format.WIRETYPE_END_GROUP:\\n # TODO Should probably match the field_number to START_GROUP\\n if not group:\\n raise DecoderException( \\\"Found END_GROUP before START_GROUP\\\", field_path)\\n # exit out\\n return output, typedef, pos\\n else:\\n raise DecoderException(\\\"Could not find default type for wiretype: %d\\\" % wire_type, field_path)\\n else:\\n if field_type == 'message':\\n #TODO probably big enough to factor out\\n message_typedef = None\\n # Check for a anonymous type\\n if 'message_typedef' in field_typedef:\\n message_typedef = field_typedef['message_typedef']\\n # Check for type defined by message type name\\n elif 'message_type_name' in field_typedef:\\n message_typedef = blackboxprotobuf.lib.known_messages[\\n field_typedef['message_type_name']]\\n\\n try:\\n field_out, message_typedef, pos = decode_lendelim_message(\\n buf, message_typedef, pos, path=field_path)\\n # Save type definition\\n field_typedef['message_typedef'] = message_typedef\\n except DecoderException as exc:\\n # If this is the root message just fail\\n if pos == 0:\\n six.reraise(*sys.exc_info())\\n logging.debug(\\n (\\\"Encountered exception when decoding message at %s \\\"\\n \\\"with known typdef. Trying alt typedefs and then \\\"\\n \\\"anonymous. Exception: \\\\n%s\\\"),\\n \\\"->\\\".join(map(str, field_path)), str(exc))\\n\\n if field_out is None and 'alt_typedefs' in field_typedef:\\n # check for an alternative type definition\\n for alt_field_number, alt_typedef in field_typedef['alt_typedefs'].items():\\n try:\\n field_out, message_typedef, pos = decode_lendelim_message(\\n buf, alt_typedef, pos, path=field_path)\\n except DecoderException as exc:\\n logging.debug(\\n (\\\"Encountered exception when decoding message at %s with alt_typedef %s. Trying anonymous decoding next. Exception:\\\\n%s\\\"),\\n \\\"->\\\".join(map(str, field_path)),\\n str(alt_field_number),\\n str(exc))\\n\\n if field_out is not None:\\n # Found working typedef\\n field_typedef['alt_typedefs'][alt_field_number] = message_typedef\\n field_number = field_number + \\\"-\\\" + alt_field_number\\n break\\n\\n if field_out is None:\\n # Still no typedef, try anonymous, and let the error propogate if it fails\\n field_out, message_typedef, pos = \\\\\\n decode_lendelim_message(buf, {}, pos, path=field_path)\\n\\n if 'alt_typedefs' in field_typedef:\\n # get the next higher alt field number\\n alt_field_number = str(\\n max(map(int, field_typedef['alt_typedefs'].keys()))\\n + 1)\\n else:\\n field_typedef['alt_typedefs'] = {}\\n alt_field_number = '1'\\n\\n field_typedef['alt_typedefs'][alt_field_number] = message_typedef\\n field_number = field_number + \\\"-\\\" + alt_field_number\\n elif field_type == 'group':\\n group_typedef = None\\n # Check for a anonymous type\\n if 'group_typedef' in field_typedef:\\n group_typedef = field_typedef['group_typedef']\\n field_out, group_typedef, pos = \\\\\\n decode_group(buf, group_typedef, pos, depth=depth, path=field_path)\\n # Save type definition\\n field_typedef['group_typedef'] = group_typedef\\n else:\\n # Verify wiretype matches\\n if blackboxprotobuf.lib.types.wiretypes[field_type] != wire_type:\\n raise DecoderException(\\n \\\"Invalid wiretype for field number %s. %s is not wiretype %s\\\"\\n % (field_number, field_type, wire_type), field_path)\\n\\n # Simple type, just look up the decoder\\n try:\\n field_out, pos = blackboxprotobuf.lib.types.decoders[field_type](buf, pos)\\n except DecoderException as exc:\\n exc.set_path(field_path)\\n six.reraise(*sys.exc_info())\\n field_typedef['type'] = field_type\\n if 'name' not in field_typedef:\\n field_typedef['name'] = ''\\n\\n field_key = field_number\\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\\n field_key = field_typedef['name']\\n # Deal with repeats\\n if field_key in output:\\n if isinstance(field_out, list):\\n if isinstance(output[field_key], list):\\n output[field_key] += field_out\\n else:\\n output[field_key] = field_out.append(output[field_key])\\n else:\\n if isinstance(output[field_key], list):\\n output[field_key].append(field_out)\\n else:\\n output[field_key] = [output[field_key], field_out]\\n else:\\n output[field_key] = field_out\\n typedef[orig_field_number] = field_typedef\\n if pos > end:\\n raise DecoderException(\\n \\\"Field sizes are greater than designated length. pos: %d end_pos: %d\\\" % (pos, end))\\n # Should never hit here as a group\\n if group:\\n raise DecoderException(\\\"Got START_GROUP with no END_GROUP.\\\")\\n return output, typedef, pos\",\n \"def parse(self, val):\\n # type: (bytes) -> Any\\n return val.decode()\",\n \"def _get_data(self, read_size):\\n return self._character_device.read(read_size)\",\n \"def Read(self):\\n if not self._mem: return self.data\\n\\n logger.info(\\\"Read %s\\\" % self)\\n self.data = self.hostmemmgr.read(self._mem, self.size)\\n\\n logger.info(\\\"=\\\" * 30, \\\"READ BUFFER\\\", \\\"=\\\" * 30)\\n scapyfactory.Parse(self.data).Show()\\n logger.info(\\\"=\\\" * 30, \\\"END READ BUFFER\\\", \\\"=\\\" * 30)\\n\\n return self.data\",\n \"def decode_uvarint(buf, pos):\\n # Convert buffer to string\\n if six.PY2:\\n buf = str(buf)\\n try:\\n value, pos = decoder._DecodeVarint(buf, pos)\\n except (TypeError, IndexError, decoder._DecodeError) as exc:\\n six.raise_from(\\n DecoderException(\\n \\\"Error decoding uvarint from %s...\\\"\\n % binascii.hexlify(buf[pos : pos + 8])\\n ),\\n exc,\\n )\\n return (value, pos)\",\n \"def read(type='hex', inc=False):\\n bitstring = ''\\n for i in [D7,D6,D5,D4,D3,D2,D1,D0]:\\n bitstring += str(GPIO.input(i))\\n if type == 'hex':\\n rval = \\\"Ox%02x\\\" % (int(bitstring,2))\\n elif type == \\\"int\\\":\\n rval = int(bitstring,2)\\n elif type == \\\"bin\\\":\\n rval = \\\"{0:b}\\\".format(int(bitstring,2))\\n else:\\n rval = chr(int(bitstring,2))\\n if inc:\\n incr()\\n return rval\",\n \"def _parse_value(self, data, flags):\\n\\n\\t\\tif flags & Client._FLAG_COMPRESSED:\\n\\t\\t\\tdata = decompress(data)\\n\\n\\t\\tif flags == 0 or flags == Client._FLAG_COMPRESSED:\\n\\t\\t\\t# Either a bare string or a compressed string now decompressed...\\n\\t\\t\\tvalue = data\\n\\t\\telif flags & Client._FLAG_INTEGER:\\n\\t\\t\\tvalue = int(data)\\n\\t\\telif flags & Client._FLAG_LONG:\\n\\t\\t\\tvalue = long(data)\\n\\t\\telif flags & Client._FLAG_PICKLE:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tvalue = pickle.loads(data)\\n\\t\\t\\texcept Exception:\\n\\t\\t\\t\\tself._debuglog('Pickle error...\\\\n')\\n\\t\\t\\t\\tvalue = None\\n\\t\\telse:\\n\\t\\t\\tself._debuglog(\\\"unknown flags on get: %x\\\\n\\\" % flags)\\n\\n\\t\\treturn value\",\n \"def read_specific_message(self, msg_type):\\n\\n if not issubclass(msg_type, sirf_messages._SirfReceivedMessageBase):\\n raise TypeError(\\\"msg_type must be a message type.\\\")\\n\\n msg = None\\n\\n while not isinstance(msg, msg_type):\\n msg = self.read_message()\\n #print(msg)\\n\\n return msg\",\n \"def _read_fixed(buf, length):\\n result = buf.read(length)\\n actual = len(result)\\n if actual != length:\\n raise EndOfMessage(False if actual == 0 else True)\\n return result\",\n \"def data(self, overrun=0):\\n data_type = self.data_type()\\n data_length = self.raw_data_length()\\n d = self.raw_data(overrun=overrun)\\n\\n if data_type == RegSZ or data_type == RegExpandSZ:\\n if overrun > 0:\\n # decode_utf16le() only returns the first string, but if we explicitly\\n # ask for overrun, let's make a best-effort to decode as much as possible.\\n return d.decode('utf16')\\n else:\\n return decode_utf16le(d)\\n elif data_type == RegBin or data_type == RegNone:\\n return d\\n elif data_type == RegDWord:\\n return struct.unpack_from(str(\\\"<I\\\"), d, 0)[0]\\n elif data_type == RegMultiSZ:\\n s = d.decode(\\\"utf16\\\")\\n return s.split(\\\"\\\\x00\\\")\\n elif data_type == RegQWord:\\n return struct.unpack_from(str(\\\"<Q\\\"), d, 0)[0]\\n elif data_type == RegBigEndian:\\n return struct.unpack_from(str(\\\">I\\\"), d, 0)[0]\\n elif data_type == RegLink or \\\\\\n data_type == RegResourceList or \\\\\\n data_type == RegFullResourceDescriptor or \\\\\\n data_type == RegResourceRequirementsList:\\n # we don't really support these types, but can at least\\n # return raw binary for someone else to work with.\\n return d\\n elif data_type in (RegUint8, RegInt16, RegUint16, RegInt32, RegUint32, \\n RegInt64, RegUint64, RegFloat, RegDouble, RegUnicodeChar, \\n RegBoolean, RegUnicodeString, RegCompositeValue,RegDateTimeOffset, \\n RegTimeSpan, RegGUID, RegUnk111, RegUnk112, RegUnk113, RegBytesArray, \\n RegInt16Array, RegUint16Array, RegInt32Array, RegUInt32Array, \\n RegInt64Array, RegUInt64Array, RegFloatArray, RegDoubleArray, \\n RegUnicodeCharArray, RegBooleanArray, RegUnicodeStringArray):\\n d = d[0:-8] # remove timestamp from end\\n comp_type = data_type & 0xEFF # Apply mask for composite types\\n return SettingsParse.ParseAppDataCompositeValue(comp_type, d, len(d))\\n elif data_type == RegFileTime:\\n return parse_windows_timestamp(struct.unpack_from(str(\\\"<Q\\\"), d, 0)[0])\\n elif data_length < 5 or data_length >= 0x80000000:\\n return struct.unpack_from(str(\\\"<I\\\"), d, 0)[0]\\n else:\\n raise UnknownTypeException(\\\"Unknown VK Record type 0x%x at 0x%x\\\" % (data_type, self.offset()))\",\n \"def readinto(self, buf: bytes, write: int = 0x00, /) -> Optional[int]:\",\n \"def readinto(self, buf: bytes, write: int = 0x00, /) -> Optional[int]:\",\n \"def unpack_str_from(buffer: bytes, offset: int = 0) -> tuple[str, int]:\\n length, length_size = _unpack_length_from(buffer, offset=offset)\\n offset += length_size\\n str_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\\n value = str_bytes.decode('utf-8')\\n return value, length_size + length\",\n \"def _load_value(self, lvalue, ctyp):\\n\\n if ctyp.is_array:\\n value = lvalue\\n else:\\n # TODO: inject evil bitfield manipulation code here:\\n # self.logger.debug('Non-Array type is indexed %s', expr)\\n ir_typ = self.get_ir_type(ctyp)\\n if isinstance(ir_typ, ir.BlobDataTyp):\\n # If we have a blob pointer and want its content\\n # We must get the source of the address of:\\n if isinstance(lvalue, ir.AddressOf):\\n value = lvalue.src\\n else:\\n # This code is debatable, allocate new storage and copy\\n # the data over there?\\n value = self.emit(\\n ir.Alloc(\\\"load_blob\\\", ir_typ.size, ir_typ.alignment)\\n )\\n value_ptr = self.emit(ir.AddressOf(value, \\\"value_ptr\\\"))\\n self.gen_copy_struct(value_ptr, lvalue, ir_typ.size)\\n elif isinstance(lvalue, BitFieldAccess):\\n value = self._load_bitfield(lvalue, ir_typ)\\n else:\\n value = self.builder.emit_load(lvalue, ir_typ)\\n return value\",\n \"def _unpack(formatstring, packed):\\n _checkString(formatstring, description='formatstring', minlength=1)\\n _checkString(packed, description='packed string', minlength=1)\\n\\n if sys.version_info[0] > 2:\\n packed = bytes(packed, encoding='latin1') # Convert types to make it Python3 compatible\\n\\n try:\\n value = struct.unpack(formatstring, packed)[0]\\n except:\\n errortext = 'The received bytestring is probably wrong, as the bytestring-to-num conversion failed.'\\n errortext += ' Bytestring: {0!r} Struct format code is: {1}'\\n raise ValueError(errortext.format(packed, formatstring))\\n\\n return value\",\n \"def decode_data(self, data, sophia_type):\\n try:\\n reply = self.client.cli.decode_data(body={\\n \\\"data\\\": data,\\n \\\"sophia-type\\\": sophia_type,\\n })\\n return reply.data.get('value'), reply.data.get('type', 'word')\\n except OpenAPIClientException as e:\\n raise ContractError(e)\",\n \"def getType (self) :\\n if self.buffer == None :\\n self.buffer = self.fetch ()\\n return self.buffer.classifi7\",\n \"def _readobj(self, sock):\\n buff = b\\\"\\\"\\n while True:\\n n_to_read = max(2048, len(buff))\\n chunk = sock.recv(n_to_read)\\n buff += chunk\\n if len(chunk) != n_to_read:\\n print(\\\"Got: {}\\\", buff)\\n return json.loads(buff)\",\n \"def get(self, key, value_type=ByteString):\\n value_type = Value.ensure_value_type(value_type,\\n parameter='value_type')\\n return value_type.load_value(self, key)\",\n \"def read_data(x, y, address, length, data_format, transceiver):\\n\\n # turn byte array into str for unpack to work\\n data = buffer(transceiver.read_memory(x, y, address, length))\\n result = struct.unpack_from(data_format, data)[0]\\n return result\",\n \"def _unpackb3(s, **options):\\n if not isinstance(s, (bytes, bytearray)):\\n raise TypeError(\\\"packed data must be type 'bytes' or 'bytearray'\\\")\\n return _unpack(io.BytesIO(s), options)\",\n \"def recv_data(self, maxbuffer=4096):\\n try:\\n buff = self.s.recv(maxbuffer)\\n except OSError as e:\\n print(e)\\n return buff.decode()\",\n \"def deserialize(self, str):\\n try:\\n end = 0\\n start = end\\n end += 1\\n (self.result,) = _struct_B.unpack(str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def _image_data(buff):\\n code = buff.getvalue()\\n m = _size(code)\\n if m:\\n size = int(m.group(1))\\n else:\\n raise Exception('Internal error: PPM header not found')\\n return code[m.end():], size\",\n \"def loads_value(type_key, binary_data, version, vectors):\\n # pylint: disable=too-many-return-statements\\n\\n if isinstance(type_key, bytes):\\n type_key = type_keys.Value(type_key)\\n\\n if type_key == type_keys.Value.INTEGER:\\n return struct.unpack(\\\"!q\\\", binary_data)[0]\\n if type_key == type_keys.Value.FLOAT:\\n return struct.unpack(\\\"!d\\\", binary_data)[0]\\n if type_key == type_keys.Value.COMPLEX:\\n return complex(*struct.unpack(formats.COMPLEX_PACK, binary_data))\\n if type_key == type_keys.Value.NUMPY_OBJ:\\n return common.data_from_binary(binary_data, np.load)\\n if type_key == type_keys.Value.STRING:\\n return binary_data.decode(common.ENCODE)\\n if type_key == type_keys.Value.NULL:\\n return None\\n if type_key == type_keys.Value.CASE_DEFAULT:\\n return CASE_DEFAULT\\n if type_key == type_keys.Value.PARAMETER_VECTOR:\\n return common.data_from_binary(binary_data, _read_parameter_vec, vectors=vectors)\\n if type_key == type_keys.Value.PARAMETER:\\n return common.data_from_binary(binary_data, _read_parameter)\\n if type_key == type_keys.Value.PARAMETER_EXPRESSION:\\n if version < 3:\\n return common.data_from_binary(binary_data, _read_parameter_expression)\\n else:\\n return common.data_from_binary(\\n binary_data, _read_parameter_expression_v3, vectors=vectors\\n )\\n\\n raise exceptions.QpyError(f\\\"Serialization for {type_key} is not implemented in value I/O.\\\")\",\n \"def _unpack_body(self, buff):\\n\\n # Unpack <return_code> and <count> (how many records affected or selected)\\n self._return_code = struct_L.unpack_from(buff, offset=0)[0]\\n\\n # Separate return_code and completion_code\\n self._completion_status = self._return_code & 0x00ff\\n self._return_code >>= 8\\n\\n # In case of an error unpack the body as an error message\\n if self._return_code != 0:\\n self._return_message = unicode(buff[4:-1], self.charset, self.errors)\\n if self._completion_status == 2:\\n raise TarantoolError(self._return_code, self._return_message)\\n\\n # Unpack <count> (how many records affected or selected)\\n self._rowcount = struct_L.unpack_from(buff, offset=4)[0]\\n\\n # If the response doesn't contain any tuple - there is nothing to unpack\\n if self._body_length == 8:\\n return\\n\\n # Parse response tuples (<fq_tuple>)\\n if self._rowcount > 0:\\n offset = 8 # The first 4 bytes in the response body is the <count> we have already read\\n while offset < self._body_length:\\n # In resonse tuples have the form <size><tuple> (<fq_tuple> ::= <size><tuple>).\\n # Attribute <size> takes into account only size of tuple's <field> payload,\\n # but does not include 4-byte of <cardinality> field.\\n #Therefore the actual size of the <tuple> is greater to 4 bytes.\\n tuple_size = struct.unpack_from(\\\"<L\\\", buff, offset)[0] + 4\\n tuple_data = struct.unpack_from(\\\"<%ds\\\" % (tuple_size), buff, offset+4)[0]\\n tuple_value = self._unpack_tuple(tuple_data)\\n if self.field_types:\\n self.append(self._cast_tuple(tuple_value))\\n else:\\n self.append(tuple_value)\\n\\n offset = offset + tuple_size + 4 # This '4' is a size of <size> attribute\",\n \"def read(self, bytes):\\r\\n return int.from_bytes(self.__input__.read(bytes), byteorder='big')\",\n \"def _get_data(self, read_size):\\n return self._pipe.recv_bytes()\",\n \"def _getVal(self, mask, size):\\n\\t\\tif (int(self.header['flags']) & mask) > 0:\\n\\t\\t\\t# First unsigned short is the length of the string\\n\\t\\t\\ttxt = self.fpLnk.read(2)\\n\\t\\t\\tlength = struct.unpack(\\\"<H\\\", txt)[0]\\n\\t\\t\\t# Adjust for unicode\\n\\t\\t\\tlength = length * size\\n\\t\\t\\treturn self.fpLnk.read(length)\",\n \"def _unpackb2(s, **options):\\n if not isinstance(s, (str, bytearray)):\\n raise TypeError(\\\"packed data must be type 'str' or 'bytearray'\\\")\\n return _unpack(io.BytesIO(s), options)\",\n \"def _receive(self, length):\\n \\n return self.device.read(length)\",\n \"def _read_var(self, time_idx, pressure_idx, var_idx, lat_idx, lng_idx):\\n offset = self.item_size * (\\n time_idx * self.t_idx + pressure_idx * self.p_idx +\\n var_idx * self.v_idx + lat_idx * self.l_idx + lng_idx)\\n self.mm.seek(offset)\\n return self.unpacker.unpack(self.mm.read(self.item_size))[0]\",\n \"def read(self):\\n self.close()\\n return self._buffer.getvalue()\",\n \"def convert_from_bytes(output: ResponseOutput, ty: Optional[Type]) -> Any:\\n if ty == str:\\n return bytearray(output.data).decode(\\\"UTF-8\\\")\\n else:\\n py_str = bytearray(output.data).decode(\\\"UTF-8\\\")\\n from ast import literal_eval\\n\\n return literal_eval(py_str)\",\n \"def decode_varint(buf, pos):\\n # Convert buffer to string\\n if six.PY2:\\n buf = str(buf)\\n try:\\n value, pos = decoder._DecodeSignedVarint(buf, pos)\\n except (TypeError, IndexError, decoder._DecodeError) as exc:\\n six.raise_from(\\n DecoderException(\\n \\\"Error decoding varint from %s...\\\"\\n % binascii.hexlify(buf[pos : pos + 8])\\n ),\\n exc,\\n )\\n return (value, pos)\",\n \"def bdecode(f):\\n\\tbtype = TYPES[f.read(1)]\\n\\tif btype is not None:\\n\\t\\tf.seek(-1, SEEK_CUR)\\n\\t\\treturn DECODERS[btype](f)\\n\\telse: #Used in dicts and lists to designate an end\\n\\t\\treturn None\",\n \"def _unpack(chid, data, count=None, ftype=None, as_numpy=True):\\n\\n def array_cast(data, count, ntype, use_numpy):\\n \\\"cast ctypes array to numpy array (if using numpy)\\\"\\n if use_numpy:\\n dtype = dbr.NP_Map.get(ntype, None)\\n if dtype is not None:\\n out = numpy.empty(shape=(count,), dtype=dbr.NP_Map[ntype])\\n ctypes.memmove(out.ctypes.data, data, out.nbytes)\\n else:\\n out = numpy.ctypeslib.as_array(copy(data))\\n else:\\n out = copy(data)\\n return out\\n\\n def unpack_simple(data, count, ntype, use_numpy):\\n \\\"simple, native data type\\\"\\n if count == 1 and ntype != dbr.STRING:\\n return data[0]\\n if ntype == dbr.STRING:\\n out = []\\n for elem in range(min(count, len(data))):\\n this = strjoin('', data[elem]).rstrip()\\n if NULLCHAR_2 in this:\\n this = this[:this.index(NULLCHAR_2)]\\n out.append(this)\\n if len(out) == 1:\\n out = out[0]\\n return out\\n if count > 1:\\n data = array_cast(data, count, ntype, use_numpy)\\n return data\\n\\n def unpack_ctrltime(data, count, ntype, use_numpy):\\n \\\"ctrl and time data types\\\"\\n if count == 1 or ntype == dbr.STRING:\\n data = data[0].value\\n if ntype == dbr.STRING and NULLCHAR in data:\\n data = data[:data.index(NULLCHAR)]\\n return data\\n # fix for CTRL / TIME array data:Thanks to Glen Wright !\\n data = (count*dbr.Map[ntype]).from_address(ctypes.addressof(data) +\\n dbr.value_offset[ftype])\\n if count > 1:\\n data = array_cast(data, count, ntype, use_numpy)\\n return data\\n\\n unpack = unpack_simple\\n if ftype >= dbr.TIME_STRING:\\n unpack = unpack_ctrltime\\n\\n if count is None and chid is not None:\\n count = element_count(chid)\\n if count is None:\\n count = 1\\n\\n if ftype is None and chid is not None:\\n ftype = field_type(chid)\\n if ftype is None:\\n ftype = dbr.INT\\n ntype = native_type(ftype)\\n use_numpy = (HAS_NUMPY and as_numpy and ntype != dbr.STRING and count > 1)\\n return unpack(data, count, ntype, use_numpy)\",\n \"def readinto(self, buf: bytes, nack: bool = True, /) -> None:\",\n \"def readinto(self, buf: bytes, nack: bool = True, /) -> None:\",\n \"def read(self, num=1):\\n contents = self.stream.read(num)\\n self.bitsRead += len(contents)\\n self.observerRead(contents)\\n return contents\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6121442","0.6102325","0.6010905","0.59326094","0.59165037","0.57921314","0.57729095","0.5755466","0.5736085","0.5672907","0.5606049","0.5564489","0.5529752","0.5459146","0.54543996","0.5428361","0.5421578","0.5403828","0.53911126","0.5365144","0.53487855","0.5347592","0.5315378","0.5296069","0.5259917","0.52524257","0.5251493","0.5241789","0.52321625","0.5229975","0.5211236","0.5209441","0.5169989","0.5168172","0.5142828","0.5114232","0.50850666","0.5066517","0.5049398","0.5036906","0.5034401","0.5026365","0.5021032","0.5018202","0.5018202","0.49942756","0.49935094","0.49834064","0.49805874","0.49755085","0.49746358","0.49621925","0.49498594","0.494843","0.49398834","0.49339142","0.4933287","0.49232394","0.49104172","0.49074075","0.4884741","0.48815912","0.48788345","0.48678482","0.48657236","0.48648039","0.48600563","0.4858086","0.4856605","0.48561668","0.4850141","0.4850141","0.48404288","0.48382926","0.48324564","0.48219043","0.48154092","0.4812825","0.48079598","0.480514","0.48043087","0.4800981","0.4799948","0.47997358","0.47989243","0.4787224","0.4783559","0.47834378","0.4775893","0.4755347","0.4751788","0.47456884","0.47137657","0.47081876","0.4705728","0.47053388","0.47006232","0.46964","0.46964","0.46955365"],"string":"[\n \"0.6121442\",\n \"0.6102325\",\n \"0.6010905\",\n \"0.59326094\",\n \"0.59165037\",\n \"0.57921314\",\n \"0.57729095\",\n \"0.5755466\",\n \"0.5736085\",\n \"0.5672907\",\n \"0.5606049\",\n \"0.5564489\",\n \"0.5529752\",\n \"0.5459146\",\n \"0.54543996\",\n \"0.5428361\",\n \"0.5421578\",\n \"0.5403828\",\n \"0.53911126\",\n \"0.5365144\",\n \"0.53487855\",\n \"0.5347592\",\n \"0.5315378\",\n \"0.5296069\",\n \"0.5259917\",\n \"0.52524257\",\n \"0.5251493\",\n \"0.5241789\",\n \"0.52321625\",\n \"0.5229975\",\n \"0.5211236\",\n \"0.5209441\",\n \"0.5169989\",\n \"0.5168172\",\n \"0.5142828\",\n \"0.5114232\",\n \"0.50850666\",\n \"0.5066517\",\n \"0.5049398\",\n \"0.5036906\",\n \"0.5034401\",\n \"0.5026365\",\n \"0.5021032\",\n \"0.5018202\",\n \"0.5018202\",\n \"0.49942756\",\n \"0.49935094\",\n \"0.49834064\",\n \"0.49805874\",\n \"0.49755085\",\n \"0.49746358\",\n \"0.49621925\",\n \"0.49498594\",\n \"0.494843\",\n \"0.49398834\",\n \"0.49339142\",\n \"0.4933287\",\n \"0.49232394\",\n \"0.49104172\",\n \"0.49074075\",\n \"0.4884741\",\n \"0.48815912\",\n \"0.48788345\",\n \"0.48678482\",\n \"0.48657236\",\n \"0.48648039\",\n \"0.48600563\",\n \"0.4858086\",\n \"0.4856605\",\n \"0.48561668\",\n \"0.4850141\",\n \"0.4850141\",\n \"0.48404288\",\n \"0.48382926\",\n \"0.48324564\",\n \"0.48219043\",\n \"0.48154092\",\n \"0.4812825\",\n \"0.48079598\",\n \"0.480514\",\n \"0.48043087\",\n \"0.4800981\",\n \"0.4799948\",\n \"0.47997358\",\n \"0.47989243\",\n \"0.4787224\",\n \"0.4783559\",\n \"0.47834378\",\n \"0.4775893\",\n \"0.4755347\",\n \"0.4751788\",\n \"0.47456884\",\n \"0.47137657\",\n \"0.47081876\",\n \"0.4705728\",\n \"0.47053388\",\n \"0.47006232\",\n \"0.46964\",\n \"0.46964\",\n \"0.46955365\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6249607"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90586,"cells":{"query":{"kind":"string","value":"A helper function for unpack(), it handles any data type that is understood by the struct module."},"document":{"kind":"string","value":"def unpack_real(self, data_type, length):\n\t\tif len(self.buff) < length:\n\t\t\traise IncompleteData()\n\t\to = struct.unpack_from('!'+data_type, self.buff)[0]\n\t\tself.buff = self.buff[length:]\n\t\treturn o"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_type(fobj, data_type):\n if data_type == \"Boolean\": ## False if 0x00 else True\n return bool(fobj.read(1))\n elif data_type == \"Byte\": ## 1 byte int\n return fobj.read(1)[0]\n elif data_type == \"DateTime\": ## 8 bytes signed int\n return struct.unpack(\"<q\", fobj.read(8))[0]\n elif data_type == \"Double\": ## 8 bytes floating point\n return struct.unpack(\"<d\", fobj.read(8))[0]\n elif data_type == \"Int\": ## 4 bytes unsigned int\n return struct.unpack(\"<I\", fobj.read(4))[0]\n elif data_type == \"Int-Double pair\": ## 0x08-Int-0x0d-Double with AssertionError\n bb = fobj.read(1)[0]\n if bb != 0x08:\n raise AssertionError('parse_type(fobj, data_type): '\n '1st byte(%s) of \"Int-Double pair\" != 0x08' % bb)\n first_int = parse_type(fobj, \"Int\")\n bb = fobj.read(1)[0]\n if bb != 0x0d:\n raise AssertionError('parse_type(fobj, data_type): '\n '6th byte(%s) of \"Int-Double pair\" != 0x0d' % bb)\n return [first_int, parse_type(fobj, \"Double\")]\n elif data_type == \"Int-Double pair*\": ## int(n) - \"Int-Double pair\"*n\n return [parse_type(fobj, \"Int-Double pair\") for i in range(parse_type(fobj, \"Int\"))]\n elif data_type == \"Long\": ## 8 bytes unsigned int\n return struct.unpack(\"<Q\", fobj.read(8))[0]\n elif data_type == \"Short\": ## 2 bytes unsigned int\n return struct.unpack(\"<H\", fobj.read(2))[0]\n elif data_type == \"Single\": ## 4 bytes floating point\n return struct.unpack(\"<f\", fobj.read(4))[0]\n elif data_type == \"String\": ## 0x00 or 0x0b - ULE128(n) - UTF-8(length=n)\n bb = fobj.read(1)[0]\n if bb == 0x00:\n return None\n elif bb != 0x0b:\n ## TODO: show integers in assertion error in hexadecimal and decimal\n ## to make debug more convenient (cause I may inspect the file in a byte reader.\n raise AssertionError('parse_type(fobj, data_type): '\n '1st byte(%s) of \"String\" not in {0x00, 0x0b}' % bb)\n strlen = parse_type(fobj, \"ULEB128\")\n return fobj.read(strlen).decode(\"utf-8\")\n elif data_type == \"ULEB128\": ## https://en.wikipedia.org/wiki/LEB128#Decode_unsigned_integer\n i = 0 ## derived from the wiki psuedo code\n res = 0\n shift = 0\n while True:\n bb = fobj.read(1)[0]\n i += 1\n res |= ((bb & 0b1111111) << shift)\n if (bb & 0b10000000) == 0:\n break\n shift += 7\n return res\n elif data_type == \"Timing point\": ## Double - Double - Boolean\n return parse_types(fobj, [\"Double\", \"Double\", \"Boolean\"])\n elif data_type == \"Timing point+\": ## int(n) - \"Timing point\"*n\n return [parse_type(fobj, \"Timing point\") for i in range(parse_type(fobj, \"Int\"))]\n else:\n raise NotImplementedError('parse_type(fobj, data_type): Unknown data type: \"%s\".' % data_type)","def unpack(self, data_type):\n\t\tif data_type in data_types:\n\t\t\tformat = data_types[data_type]\n\t\t\treturn self.unpack_real(format[0], format[1])\n\t\t\n\t\tif data_type == \"string8\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:length]\n\t\t\tself.buff = self.buff[length:]\n\t\t\treturn string\n\t\tif data_type == \"string16\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < 2*length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:2*length].decode('utf-16be')\n\t\t\tself.buff = self.buff[2*length:]\n\t\t\treturn string\n\t\tif data_type == \"slot\":\n\t\t\to = {}\n\t\t\to[\"id\"] = self.unpack('short')\n\t\t\tif o[\"id\"] > 0:\n\t\t\t\to[\"amount\"] = self.unpack('byte')\n\t\t\t\to[\"damage\"] = self.unpack('short')\n\t\t\tif o[\"id\"] in SLOT_EXTRA_DATA_IDS:\n\t\t\t\textra_len = self.unpack('short')\n\t\t\t\tif extra_len <= 0:\n\t\t\t\t\to[\"extra\"] = None\n\t\t\t\telse:\n\t\t\t\t\tif len(self.buff) < extra_len:\n\t\t\t\t\t\traise IncompleteData()\n\t\t\t\t\textra_buff = self.buff[:extra_len]\n\t\t\t\t\tself.buff = self.buff[extra_len:]\n\t\t\t\t\to[\"extra\"] = extra_buff\n\t\t\treturn o\n\t\tif data_type == \"metadata\":\n\t\t\t#[(17, 0), (0, 0), (16, -1)]\n\t\t\to = []\n\t\t\tmtype = self.unpack('byte')\n\t\t\twhile mtype != 127:\n\t\t\t\tmtype2 = mtype >> 5\n\t\t\t\tt = 0\n\t\t\t\tif mtype2 == 0: t = self.unpack('byte') \n\t\t\t\tif mtype2 == 1: t = self.unpack('short') \n\t\t\t\tif mtype2 == 2: t = self.unpack('int') \n\t\t\t\tif mtype2 == 3: t = self.unpack('float') \n\t\t\t\tif mtype2 == 4: t = self.unpack('string16')\n\t\t\t\tif mtype2 == 5:\n\t\t\t\t\tt = {}\n\t\t\t\t\tt[\"id\"] = self.unpack('short')\n\t\t\t\t\tt[\"count\"] = self.unpack('byte')\n\t\t\t\t\tt[\"damage\"] = self.unpack('short')\n\t\t\t\tif mtype2 == 6:\n\t\t\t\t\tt = []\n\t\t\t\t\tfor i in range(3):\n\t\t\t\t\t\ts = self.unpack('int')\n\t\t\t\t\t\tt.append(s)\n\t\t\t\tt = (mtype, t)\n\t\t\t\to.append(t)\n\t\t\t\tmtype = self.unpack('byte')\n\t\t\treturn o","def _unpack(formatstring, packed):\n _checkString(formatstring, description='formatstring', minlength=1)\n _checkString(packed, description='packed string', minlength=1)\n\n if sys.version_info[0] > 2:\n packed = bytes(packed, encoding='latin1') # Convert types to make it Python3 compatible\n\n try:\n value = struct.unpack(formatstring, packed)[0]\n except:\n errortext = 'The received bytestring is probably wrong, as the bytestring-to-num conversion failed.'\n errortext += ' Bytestring: {0!r} Struct format code is: {1}'\n raise ValueError(errortext.format(packed, formatstring))\n\n return value","def _structUnpack(fmt, data, offs=0, _depth=0):\n assert _depth < 10, \"Maximum depth exceeded\"\n if type(fmt) is str:\n r = struct.unpack_from(fmt, data, offs)\n if len(r) == 1: return r[0] # grumble\n return r\n\n # fmt is ( offset, type, name[, count] ) or a tuple of such\n res = {}\n if type(fmt[0]) is not tuple: fmt = (fmt,)\n for item in fmt:\n if len(item) > 3:\n itemOffs, itemType, itemName, itemCount = item\n else:\n itemOffs, itemType, itemName = item\n itemCount = 1\n size = struct.calcsize(_structTupleToFmt(itemType))\n val = []\n for i in range(itemCount):\n val.append(_structUnpack(itemType, data, offs=offs, _depth=_depth+1))\n offs += size\n if len(val) == 1: res[itemName] = val[0]\n else: res[itemName] = val\n return res","def unpack(fmt, data):\n fmt = _normalize(fmt)\n formatdef, endianness, i, alignment = _getmode(fmt)\n j = 0\n num = 0\n result = []\n length = calcsize(fmt)\n if length != len (data):\n raise StructError(\"unpack str size does not match format\")\n while i < len(fmt):\n num, i = _getnum(fmt, i)\n cur = fmt[i]\n i += 1\n try:\n format = formatdef[cur]\n except KeyError:\n raise StructError(\"%s is not a valid format\" % cur)\n\n if not num :\n num = 1\n\n if cur == 'x':\n j += num\n elif cur == 's':\n result.append(data[j:j + num])\n j += num\n elif cur == 'p':\n n = data[j]\n if n >= num:\n n = num - 1\n result.append(data[j + 1:j + n + 1])\n j += num\n else:\n # skip padding bytes until we get at a multiple of size\n if j > 0 and alignment:\n padding = format['size'] - j % format['size']\n j += padding\n for n in range(num):\n result += [format['unpack'](data, j, format['size'],\n endianness)]\n j += format['size']\n\n return tuple(result)","def interpret_packet_value_pair(data):\n if data is None:\n return None, None\n packet_type = int.from_bytes(data[3:4], 'little')\n name = value = None\n if packet_type == 1:\n name = str(data[17:], 'utf8') \n value = float(ustruct.unpack('<i', data[12:16])[0])\n elif packet_type == 5:\n name = str(data[21:29], 'ascii').strip()\n value = ustruct.unpack('<d', data[12:20])[0]\n else:\n display.scroll('Packet type {} not recognised'.format(packet_type))\n return name, value","def dec_elem(dtype, binary):\n if dtype == BOOL:\n return struct.unpack('>?', binary)[0]\n elif dtype == UINT8:\n return struct.unpack('>B', binary)[0]\n elif dtype == UINT16:\n return struct.unpack('>H', binary)[0]\n elif dtype == UINT24:\n (major, minor) = struct.unpack('>BH', binary)\n return (major << 16) + minor\n elif dtype == UINT32:\n return struct.unpack('>I', binary)[0]\n elif dtype == UINT64:\n return struct.unpack('>Q', binary)[0]\n elif dtype == INT8:\n return struct.unpack('>b', binary)[0]\n elif dtype == INT16:\n return struct.unpack('>h', binary)[0]\n elif dtype == INT24:\n (major, minor) = struct.unpack('>hB', binary)\n return (major << 8) + minor\n elif dtype == INT32:\n return struct.unpack('>i', binary)[0]\n elif dtype == INT64:\n return struct.unpack('>q', binary)[0]\n elif dtype == DOUBLE:\n return struct.unpack('>d', binary)[0]\n elif dtype == STRING:\n return binary\n elif dtype == BITMAP:\n (unused,) = struct.unpack('>B', binary[0])\n binary = binary[1:]\n bitsize = len(binary) * 8 - unused\n if bitsize == 0:\n return []\n result = []\n b = None\n bitpointer = 0\n while bitsize > 0:\n if b is None:\n b = struct.unpack('>B', binary[0])[0]\n binary = binary[1:]\n bitpointer = 0\n bitpointer += 1\n if unused > 0:\n unused -= 1\n b <<= 1\n continue\n result.append((b & 0b10000000) >> 7)\n bitsize -= 1\n b <<= 1\n if bitpointer == 8:\n b = None\n return result\n elif dtype == LIST_OF_STRING:\n result = []\n while binary:\n length = struct.unpack('>H', binary[:2])[0]\n result.append(binary[2:2 + length])\n binary = binary[2 + length:]\n return result\n elif dtype == LIST_OF_UINT8:\n return list(struct.unpack('>' + 'B' * len(binary), binary))\n elif dtype == LIST_OF_UINT16:\n return list(struct.unpack('>' + 'H' * (len(binary) / 2), binary))\n elif dtype == LIST_OF_UINT24:\n unpacked = struct.unpack('>' + 'BH' * (len(binary) / 3), binary)\n result = []\n while unpacked:\n result.append((unpacked[0] << 16) + unpacked[1])\n unpacked = unpacked[2:]\n return result\n elif dtype == LIST_OF_UINT32:\n return list(struct.unpack('>' + 'I' * (len(binary) / 4), binary))\n elif dtype == LIST_OF_UINT64:\n return list(struct.unpack('>' + 'Q' * (len(binary) / 8), binary))\n elif dtype == LIST_OF_INT8:\n return list(struct.unpack('>' + 'b' * len(binary), binary))\n elif dtype == LIST_OF_INT16:\n return list(struct.unpack('>' + 'h' * (len(binary) / 2), binary))\n elif dtype == LIST_OF_INT24:\n unpacked = struct.unpack('>' + 'hB' * (len(binary) / 3), binary)\n result = []\n while unpacked:\n result.append((unpacked[0] << 8) + unpacked[1])\n unpacked = unpacked[2:]\n return result\n elif dtype == LIST_OF_INT32:\n return list(struct.unpack('>' + 'i' * (len(binary) / 4), binary))\n elif dtype == LIST_OF_INT64:\n return list(struct.unpack('>' + 'q' * (len(binary) / 8), binary))\n elif dtype == LIST_OF_DOUBLE:\n return list(struct.unpack('>' + 'd' * (len(binary) / 8), binary))","def _unpack_with_byteorder(self, fmt, data):\n return struct.unpack(self.struct_byteorder + fmt, data)","def _decode_struct(\n data_type, obj, alias_validators, strict, old_style, for_msgpack):\n if obj is None and data_type.has_default():\n return data_type.get_default()\n elif not isinstance(obj, dict):\n raise bv.ValidationError('expected object, got %s' %\n bv.generic_type_name(obj))\n if strict:\n for key in obj:\n if (key not in data_type.definition._all_field_names_ and\n not key.startswith('.tag')):\n raise bv.ValidationError(\"unknown field '%s'\" % key)\n ins = data_type.definition()\n _decode_struct_fields(\n ins, data_type.definition._all_fields_, obj, alias_validators, strict,\n old_style, for_msgpack)\n # Check that all required fields have been set.\n data_type.validate_fields_only(ins)\n return ins","def _unpack(chid, data, count=None, ftype=None, as_numpy=True):\n\n def array_cast(data, count, ntype, use_numpy):\n \"cast ctypes array to numpy array (if using numpy)\"\n if use_numpy:\n dtype = dbr.NP_Map.get(ntype, None)\n if dtype is not None:\n out = numpy.empty(shape=(count,), dtype=dbr.NP_Map[ntype])\n ctypes.memmove(out.ctypes.data, data, out.nbytes)\n else:\n out = numpy.ctypeslib.as_array(copy(data))\n else:\n out = copy(data)\n return out\n\n def unpack_simple(data, count, ntype, use_numpy):\n \"simple, native data type\"\n if count == 1 and ntype != dbr.STRING:\n return data[0]\n if ntype == dbr.STRING:\n out = []\n for elem in range(min(count, len(data))):\n this = strjoin('', data[elem]).rstrip()\n if NULLCHAR_2 in this:\n this = this[:this.index(NULLCHAR_2)]\n out.append(this)\n if len(out) == 1:\n out = out[0]\n return out\n if count > 1:\n data = array_cast(data, count, ntype, use_numpy)\n return data\n\n def unpack_ctrltime(data, count, ntype, use_numpy):\n \"ctrl and time data types\"\n if count == 1 or ntype == dbr.STRING:\n data = data[0].value\n if ntype == dbr.STRING and NULLCHAR in data:\n data = data[:data.index(NULLCHAR)]\n return data\n # fix for CTRL / TIME array data:Thanks to Glen Wright !\n data = (count*dbr.Map[ntype]).from_address(ctypes.addressof(data) +\n dbr.value_offset[ftype])\n if count > 1:\n data = array_cast(data, count, ntype, use_numpy)\n return data\n\n unpack = unpack_simple\n if ftype >= dbr.TIME_STRING:\n unpack = unpack_ctrltime\n\n if count is None and chid is not None:\n count = element_count(chid)\n if count is None:\n count = 1\n\n if ftype is None and chid is not None:\n ftype = field_type(chid)\n if ftype is None:\n ftype = dbr.INT\n ntype = native_type(ftype)\n use_numpy = (HAS_NUMPY and as_numpy and ntype != dbr.STRING and count > 1)\n return unpack(data, count, ntype, use_numpy)","def unpack( self, key, data ) :\r\n\r\n return struct.unpack(self[key], data)","def unpack(self, fmt):\n try:\n data = self.get(struct.calcsize(fmt))\n return struct.unpack(fmt, data)\n except struct.error as e:\n raise BufferError(\n \"Error unpacking struct '%s' <%s>\" %\n (fmt, binascii.hexlify(data).decode())\n )","def unpack (self, buffer):\n\t\timport struct\n\t\tvalues = struct.unpack (self.struct, buffer)\n\t\tj = 0\n\t\tfor i in self.structref:\n\t\t\tself.value[i[self.NAME]] = values[j]\n\t\t\tj = j + 1","def get_unpack_format(in_dtype, dsize, endian='big', logger=cubeds.pylogger.get_logger(__name__)):\n # logger = cubeds.pylogger.get_logger(__name__)\n if dsize <= 8:\n # bits\n letter = 'b'\n elif dsize == 16:\n # short\n letter = 'h'\n elif dsize == 32:\n # int\n letter = 'i'\n elif dsize == 64:\n # long long\n letter = 'q'\n elif dsize == -1:\n # padding\n letter = str(dsize//8)+'x' # want self.size bytes of padding\n in_dtype = 'int'\n dsize = 1\n else:\n logger.fatal(\"parsing error for datatype size\")\n raise cubeds.exceptions.UnpackFormatError(msg=\"parsing error for datatype size\")\n\n if in_dtype == 'dn':\n letter = letter.upper()\n elif in_dtype == 'sn':\n letter = letter.lower()\n elif in_dtype == 'char':\n letter = str(int(dsize/8)) + 's'\n elif in_dtype == 'float' or in_dtype == 'double':\n letter = 'd'\n else:\n logger.fatal(\"parsing error for datatype \\\"\" + in_dtype + \"\\\" with size \\\"\" + str(dsize) + \"\\\"\")\n raise cubeds.exceptions.UnpackFormatError(msg=\"parsing error for datatype \\\"\" + in_dtype + \"\\\" with size \\\"\"\n + str(dsize) + \"\\\"\")\n\n if endian == 'big':\n letter = '>' + letter\n elif endian == 'little':\n letter = '<' + letter\n else:\n logger.fatal(\"DID NOT SPECIFY ENDIANNESS CORRECTLY\")\n raise cubeds.exceptions.UnpackFormatError(\"Endianness not specified correctly.\")\n return letter","def decode_data_info(metadict):\n if 'datatype' not in metadict.keys():\n raise KeyError(f\"'datatype' not found in the metadata dictionary\")\n datatype = metadict['datatype']\n if datatype not in DtypeDecoder.keys():\n raise KeyError(f\"unknown data type: {datatype}\")\n basetype, byteorder_sensitive = DtypeDecoder[datatype]\n if byteorder_sensitive == True:\n baseorder = _sys.byteorder\n if 'byteorder' not in metadict.keys():\n _warnings.warn(\"'byteorder' not found in the metadata dictionary: the native order is assumed.\")\n return basetype\n order = metadict['byteorder']\n if order != baseorder:\n return basetype.newbyteorder(ByteOrderDecoder[order])\n else:\n return basetype\n else:\n return basetype","def _decode_field(self, field_type, field_data, subcontent=None):\n # check wire type\n wt_schema = self.__class__.FIELD_WIRE_TYPE[field_type]\n wt_data = field_data['wire_type']\n if wt_schema != wt_data:\n raise TypeError(\n 'Wire type mismatch (expect {0} but got {1})'\\\n .format(wt_schema, wt_data)\n )\n\n field_decoded = None\n\n # the actual decoding process\n # nested structure\n if field_type == 'a' and subcontent:\n self.logger.debug('_decode_field(): nested field begin')\n if self._kv_fmt:\n field_decoded = dict(self._decode_wire(\n io.BytesIO(field_data['data']),\n subcontent\n ))\n else:\n field_decoded = tuple(self._decode_wire(\n io.BytesIO(field_data['data']),\n subcontent\n ))\n self.logger.debug('_decode_field(): nested field end')\n\n # string, unsigned vint (2sc)\n elif field_type in 'aT':\n field_decoded = field_data['data']\n\n # unicode\n elif field_type in 'U':\n field_decoded = field_data['data'].decode('utf-8')\n\n # vint (zigzag)\n elif field_type == 'z':\n field_decoded = self._vint_dezigzagify(field_data['data'])\n\n # signed 2sc\n elif field_type == 't':\n field_decoded = self._vint_2sctosigned(field_data['data'])\n\n # fixed, float, double\n elif field_type in 'iIfdqQ':\n field_decoded = struct.unpack(\n '<{0}'.format(field_type), field_data['data']\n )[0]\n\n # boolean\n elif field_type == 'b':\n if field_data['data'] == 0:\n field_decoded = False\n else:\n field_decoded = True\n\n return field_decoded","def unpack(self, s):\n\n raise NotImplementedError()","def unpack(struct, s, callback=None):\n\toutput = []\n\t\n\twhile len(struct) > 0:\n\t\tchar = struct[0]\n\t\tstruct = struct[1:]\n\n\t\tif char == ' ' or char == '!':\n\t\t\tcontinue\n\t\telif char == '{':\n\t\t\t# Find the closing brace\n\t\t\tsubstruct, struct = string.split(struct, '}', maxsplit=1)\n\t\t\tdata, s = unpack_list(\"L\", substruct, s, callback)\n\t\t\t\n\t\t\toutput.append(data)\n\t\telif char == '[':\n\t\t\t# Find the closing brace\n\t\t\tsubstruct, struct = smartsplit(struct, '[', ']')\n\t\t\tdata, s = unpack_list(\"I\", substruct, s, callback)\n\t\t\t\n\t\t\toutput.append(data)\n\t\telif char in 'Tt':\n\t\t\tdata, s = unpack_time(s, times[char])\n\t\t\t\n\t\t\toutput.append(data)\n\t\telif char == 'S':\n\t\t\tdata, s = unpack_string(s)\n\t\t\t\n\t\t\toutput.append(data)\n\t\telif char in string.digits:\n\t\t\t# Get all the numbers\n\t\t\tsubstruct = char\n\t\t\twhile struct[0] in string.digits:\n\t\t\t\tsubstruct += struct[0]\n\t\t\t\tstruct = struct[1:]\n\t\t\t# And the value the number applies to\n\t\t\tsubstruct += struct[0]\n\t\t\tstruct = struct[1:]\n\t\t\t\n\t\t\tsize = _calcsize(substruct)\n\t\t\tsize = _calcsize(substruct)\n\t\t\tif size > len(s):\n\t\t\t\traise TypeError(\"Not enough data for %s, needed %s bytes got %r (%s bytes)\" % (substruct[1:], size, s, len(s)))\n\n\t\t\tdata = _unpack(\"!\"+substruct, s[:size])\n\t\t\ts = s[size:]\n\n\t\t\toutput += data\n\t\telif char == 'x':\n\t\t\to, s = callback(s)\n\t\t\toutput += o\n\t\telse:\n\t\t\tif char in semi.keys():\n\t\t\t\tsubstruct = \"!\"+semi[char][1]\n\t\t\telse:\n\t\t\t\tsubstruct = \"!\"+char\n\n\t\t\tsize = _calcsize(substruct)\n\t\t\tif size > len(s):\n\t\t\t\traise TypeError(\"Not enough data for %s, needed %s bytes got %r (%s bytes)\" % (substruct[1:], size, s, len(s)))\n\n\t\t\ttry:\n\t\t\t\tdata = _unpack(substruct, s[:size])\n\t\t\texcept _error, e:\n\t\t\t\tprint \"Struct\", substruct, \"Args '%s'\" % (s[:size],)\n\t\t\t\traise\n\t\t\ts = s[size:]\n\n\t\t\tif char in semi.keys():\n\t\t\t\tif data[0] == 2**semi[char][0]-1:\n\t\t\t\t\tdata = (-1,)\n\t\t\toutput += data\n\n\treturn tuple(output), s","def parse_binary_field(b):\n\n\n codec, length, params = struct.unpack(\">iii\", b[:12])\n len4 = lambda b: int(len(b[12:]) / 4)\n if codec == 1: return struct.unpack(\"f\" * length, b[12:])\n elif codec == 2: return struct.unpack(\"b\" * length, b[12:])\n elif codec == 3: return struct.unpack(\">\" + \"h\" * length, b[12:])\n elif codec == 4: return struct.unpack(\">\" + \"i\" * length, b[12:])\n elif codec == 5:\n chars = struct.unpack(\"c\" * (length * 4), b[12:])\n return [b\"\".join([\n c for c in chars[i * 4: (i + 1) * 4] if c != b\"\\x00\"\n ]).decode() for i in range(length)]\n elif codec == 6:\n integers = struct.unpack(\">\" + (\"i\" * len4(b)), b[12:])\n return [chr(c) if c != 0 else \"\" for c in run_length_decode(integers)]\n elif codec == 7:\n integers = struct.unpack(\">\" + (\"i\" * len4(b)), b[12:])\n return run_length_decode(integers)\n elif codec == 8:\n integers = struct.unpack(\">\" + (\"i\" * len4(b)), b[12:])\n return delta_decode(run_length_decode(integers))\n elif codec == 9:\n integers = struct.unpack(\">\" + (\"i\" * len4(b)), b[12:])\n return [n / params for n in run_length_decode(integers)]\n elif codec == 10:\n integers = struct.unpack(\">\" + (\"h\" * int(len(b[12:]) / 2)), b[12:])\n return [n / params for n in delta_decode(recursive_decode(integers))]\n else: raise ValueError(\".mmtf error: {} is invalid codec\".format(codec))","def loads(value):\n return unpackb(value)","def decode_struct(self, fmt, buf, pos):\n new_pos = pos + struct.calcsize(fmt)\n return struct.unpack(fmt, buf[pos:new_pos])[0], new_pos","def decode_network_values(ptype, plen, buf):\n nvalues = short.unpack_from(buf, header.size)[0]\n off = header.size + short.size + nvalues\n valskip = double.size\n\n # Check whether our expected packet size is the reported one\n assert ((valskip + 1) * nvalues + short.size + header.size) == plen\n assert double.size == number.size\n\n result = []\n\n for dstype in buf[header.size + short.size:off]:\n if type(dstype) is type(\"foo\"): ## Python 2 handles dsType as a string!\n dstype = int(dstype.encode('hex'))\n \n if dstype == DS_TYPE_COUNTER:\n result.append((dstype, number.unpack_from(buf, off)[0]))\n off += valskip\n elif dstype == DS_TYPE_GAUGE:\n result.append((dstype, double.unpack_from(buf, off)[0]))\n off += valskip\n elif dstype == DS_TYPE_DERIVE:\n result.append((dstype, number.unpack_from(buf, off)[0]))\n off += valskip\n elif dstype == DS_TYPE_ABSOLUTE:\n pprint(\"DS_TYPE_ABSOLUTE\")\n result.append((dstype, number.unpack_from(buf, off)[0]))\n off += valskip\n else:\n raise ValueError(\"DS type %i unsupported\" % dstype)\n\n return result","def unpack_type_spec_from(\n buffer: bytes, offset: int = 0\n) -> tuple[computation_types.Type, int]:\n length, length_size = _unpack_length_from(buffer, offset=offset)\n offset += length_size\n type_spec_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\n proto = computation_pb2.Type.FromString(type_spec_bytes)\n type_spec = type_serialization.deserialize_type(proto)\n return type_spec, length_size + length # pytype: disable=bad-return-type","def decode(self, data):\n\n # Tested:\n # types: z, T, a\n # nested_structure\n # repeated\n if not hasattr(data, 'read'):\n data = io.BytesIO(data)\n\n if self._kv_fmt:\n return dict(self._decode_wire(data))\n else:\n return tuple(self._decode_wire(data))","def _unpackb2(s, **options):\n if not isinstance(s, (str, bytearray)):\n raise TypeError(\"packed data must be type 'str' or 'bytearray'\")\n return _unpack(io.BytesIO(s), options)","def unpack(self,format,size,recType='-----'):\n endPos = self.ins.tell() + size\n if endPos > self.size:\n raise Tes3ReadError(self.inName, recType,endPos,self.size)\n return struct.unpack(format,self.ins.read(size))","def unpackb(value):\n return load(io.BytesIO(value))","def get_type_unpack(self, arg, option):\n pass","def _from_packed(self, value):\n raise NotImplementedError","def _decode(data: BencodedString) -> Union[bytes, dict, int, list]:\n if not data.bytes:\n raise ValueError(\"Cannot decode an empty bencoded string.\")\n\n if data.bytes[0] == START_DICT:\n return _decode_dict(data)\n\n if data.bytes[0] == START_LIST:\n return _decode_list(data)\n\n if data.bytes[0] == START_INTEGER:\n return _decode_int(data)\n\n if chr(data.bytes[0]).isdigit():\n return _decode_bytes(data)\n\n raise ValueError(\n \"Cannot decode data, expected the first byte to be one of \"\n f\"'d', 'i', 'l' or a digit, got {chr(data.bytes[0])!r} instead.\"\n )","def unpack(self, packedData):\n raise NotImplementedError, 'Method need to be overriden'","def _unbox_data_structure(struct):\n\n if isinstance(struct, list):\n return [ _unbox_data_structure(item) for item in struct ]\n elif isinstance(struct, graphlab.data_structures.sframe.SFrame):\n return list(struct.pack_columns(column_prefix='', dtype=dict)['X1'])\n elif isinstance(struct, graphlab.data_structures.sframe.SArray):\n return list(struct)\n elif isinstance(struct, graphlab.data_structures.sgraph.SGraph):\n #TODO implement for SGraph\n raise NotImplementedError('SGraph not supported.')\n #encode_value will truncate and json-ify lists/dicts. Need to treat them differently\n elif isinstance(struct, dict):\n return { k: _unbox_data_structure(v) for (k, v) in six.iteritems(struct) }\n else:\n return _encode_value(struct)","def _decode_struct_tree(data_type, obj, alias_validators, strict, for_msgpack):\n subtype = _determine_struct_tree_subtype(data_type, obj, strict)\n return _decode_struct(\n subtype, obj, alias_validators, strict, False, for_msgpack)","def _decode_value(data):\n\n # since Value messages contain only one value, it didn't seem necessary to\n # represent it as a Python class.\n\n msg = Message(data)\n value = None\n count = 0\n\n for field in msg:\n count += 1\n if field.tag == ValueTags.STRING:\n value = field.as_string()\n\n elif field.tag == ValueTags.FLOAT:\n value = field.as_float()\n\n elif field.tag == ValueTags.DOUBLE:\n value = field.as_double()\n\n elif field.tag == ValueTags.INT64:\n value = field.as_int64()\n\n elif field.tag == ValueTags.UINT64:\n value = field.as_uint64()\n\n elif field.tag == ValueTags.SINT64:\n value = field.as_sint64()\n\n elif field.tag == ValueTags.BOOL:\n value = field.as_int32() != 0\n\n else:\n raise ValueError('Unexpected tag %d while decoding value'\n % (field.tag,))\n\n # the MVT spec says that there should be one and only one field in the\n # Value message, so check for that.\n if value is None:\n raise ValueError('Found no fields when decoding value')\n if count > 1:\n raise ValueError('Found multiple fields when decoding value')\n\n return value","def decode(packed_data, custom_decoder=None):\n decoder = make_decoder(custom_decoder)\n structure = msgpack.unpackb(packed_data, ext_hook=decoder, encoding='utf-8')\n return structure","def _decode_wire(self, buf, subfmt=None):\n def _concat_fields(fields):\n \"\"\"\n Concatenate 2 fields with the same wire type together\n \"\"\"\n result_wire = io.BytesIO()\n result = {'id': fields[0]['id'], 'wire_type': fields[0]['wire_type']}\n for field in fields:\n assert field['id'] == result['id'] and \\\n field['wire_type'] == result['wire_type'], \\\n 'field id or wire_type mismatch'\n result_wire.write(field['data'])\n result['data'] = result_wire.getvalue()\n return result\n\n decoded_raw = tuple(self._break_down(buf))\n if not subfmt:\n subfmt = self._fmt\n\n for fmt in subfmt:\n field_id_start = fmt['field_id']\n field_type = fmt['field_type']\n field_prefix = fmt.get('prefix')\n subcontent = fmt.get('subcontent')\n repeat = fmt.get('repeat', 1)\n\n # sanity check\n if self._kv_fmt:\n assert repeat == 1 or field_type == 'x', 'Refuse to do field copying on non-skip field in key-value mode.'\n\n for field_id in range(field_id_start, field_id_start + repeat):\n self.logger.debug(\n '_decode_wire(): processing field #%d type %s',\n field_id, field_type\n )\n\n # skip blank field\n if field_type == 'x':\n continue\n\n # get all the data attached on the given field\n fields = tuple(x for x in decoded_raw if x['id'] == field_id)\n\n # raise error if a required field is empty\n if field_prefix == '*' and len(fields) == 0:\n raise CodecError(\n 'Field {0} is required but is empty'\\\n .format(field_id)\n )\n\n # identify which kind of repeated field is present\n # normal repeated fields\n if field_prefix == '+':\n field_decoded = tuple(\n self._decode_field(field_type, f, subcontent)\n for f in fields\n )\n\n # packed repeated field\n elif field_prefix == '#':\n if len(fields) > 1:\n self.logger.warning(\n 'Multiple data found in a packed-repeated field.'\n )\n fields = (_concat_fields(fields), )\n if fields[0]['wire_type'] != self.__class__.FIELD_WIRE_TYPE['a']:\n raise CodecError('Packed repeated field {0} has wire type other than str'.format(\n fmt['name'] if self._kv_fmt else field_id\n ))\n field = io.BytesIO(fields[0]['data'])\n unpacked_field = self._break_down(\n field,\n type_override=self.__class__.FIELD_WIRE_TYPE[field_type],\n id_override=field_id\n )\n field_decoded = tuple(\n self._decode_field(field_type, f, subcontent)\n for f in unpacked_field\n )\n\n # not a repeated field but has multiple data in one field\n elif len(fields) > 1:\n self.logger.warning(\n 'Multiple data found in a non-repeated field.'\n )\n # Check if we are expecting a nested message\n if subcontent is None:\n # Use the last found data\n field_decoded = self._decode_field(\n field_type, fields[-1], subcontent\n )\n else:\n # Concat all pieces of the nested message together and decode\n #\n # https://developers.google.com/protocol-buffers/docs/encoding#optional\n # For embedded message fields, the parser merges multiple instances of the same field,\n # as if with the `Message::MergeFrom` method – that is, all singular scalar fields in\n # the latter instance replace those in the former, singular embedded messages are merged,\n # and repeated fields are concatenated.\n field_decoded = self._decode_field(\n field_type, _concat_fields(fields), subcontent\n )\n\n # not a repeated field\n else:\n if len(fields) != 0:\n field_decoded = self._decode_field(\n field_type, fields[0], subcontent\n )\n else:\n field_decoded = None\n\n if self._kv_fmt:\n yield fmt['name'], field_decoded\n else:\n yield field_decoded","def _decode_union_old(data_type, obj, alias_validators, strict, for_msgpack):\n val = None\n if isinstance(obj, six.string_types):\n # Union member has no associated value\n tag = obj\n if tag in data_type.definition._tagmap:\n val_data_type = data_type.definition._tagmap[tag]\n if not isinstance(val_data_type, (bv.Void, bv.Nullable)):\n raise bv.ValidationError(\n \"expected object for '%s', got symbol\" % tag)\n else:\n if not strict and data_type.definition._catch_all:\n tag = data_type.definition._catch_all\n else:\n raise bv.ValidationError(\"unknown tag '%s'\" % tag)\n elif isinstance(obj, dict):\n # Union member has value\n if len(obj) != 1:\n raise bv.ValidationError('expected 1 key, got %s' % len(obj))\n tag = list(obj)[0]\n raw_val = obj[tag]\n if tag in data_type.definition._tagmap:\n val_data_type = data_type.definition._tagmap[tag]\n if isinstance(val_data_type, bv.Nullable) and raw_val is None:\n val = None\n elif isinstance(val_data_type, bv.Void):\n if raw_val is None or not strict:\n # If raw_val is None, then this is the more verbose\n # representation of a void union member. If raw_val isn't\n # None, then maybe the spec has changed, so check if we're\n # in strict mode.\n val = None\n else:\n raise bv.ValidationError('expected null, got %s' %\n bv.generic_type_name(raw_val))\n else:\n try:\n val = _json_compat_obj_decode_helper(\n val_data_type, raw_val, alias_validators, strict, True,\n for_msgpack)\n except bv.ValidationError as e:\n e.add_parent(tag)\n raise\n else:\n if not strict and data_type.definition._catch_all:\n tag = data_type.definition._catch_all\n else:\n raise bv.ValidationError(\"unknown tag '%s'\" % tag)\n else:\n raise bv.ValidationError(\"expected string or object, got %s\" %\n bv.generic_type_name(obj))\n return data_type.definition(tag, val)","def test_unpack_3(self):\n val = ('item number', int)\n assert lws.parse_schema_val(val) == (int, '')","def _decode_value(data):\n\n if type(data) is tuple:\n data = data[0]\n\n # Key does not exist\n if data == '0' or data == \"\":\n return None\n \n elif data[0] == _PREFIX:\n\n encoding = data[:2]\n value = data[2:]\n\n if encoding == _TYPE_DOUBLE or encoding == _TYPE_DOUBLE_C:\n return float(value)\n elif encoding == _TYPE_STRING or encoding == _TYPE_STRING_C:\n return value\n elif encoding == _TYPE_INT or encoding == _TYPE_INT_C:\n return int(value)\n elif encoding == _TYPE_BOOL or encoding == _TYPE_BOOL_C:\n return value == \"true\"\n else:\n return data\n\n elif data.startswith(\"<elsystem.collections.vector>\"):\n return _decode_vector(data)\n elif data.startswith(\"<elsystem.collections.dictionary>\"):\n return _decode_dictionary(data)\n else:\n return data","def _unpackb3(s, **options):\n if not isinstance(s, (bytes, bytearray)):\n raise TypeError(\"packed data must be type 'bytes' or 'bytearray'\")\n return _unpack(io.BytesIO(s), options)","def _unpack(self, _format: str, size: int) -> Any:\n return unpack(_format, self.read(size))[0]","def extract_packet(_buffer):\n if len(_buffer)>=5:\n mtype=_buffer[0]\n msglen=struct.unpack('!L',_buffer[1:5])[0]\n if len(_buffer)>=msglen+1:\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\n return None,None,_buffer","def read_and_unpack(self, fmt):\n try:\n return unpack(\n self.byte_order + fmt,\n self.read(calcsize(self.byte_order + fmt)))\n except Exception as e:\n if e.args[0].startswith('unpack requires a buffer of'):\n raise EOFError(e)\n else:\n raise","def unpack(buf: bytes) -> dict[str, Any]:\n flags: int\n column_count: int\n len_names: int\n flags, column_count, len_names = struct_unpack_from(\"<BHH\", buf)\n data_offset_code, coldata_size, data_offset_mask = decode_data_size(flags)\n if (flags & 0xFC) != 4:\n raise DynColValueError(\"Unknown dynamic columns format\")\n\n if column_count == 0:\n return {}\n\n column_directory_end = (1 + 2 + 2) + coldata_size * column_count\n names_end = column_directory_end + len_names\n\n column_directory = buf[1 + 2 + 2 : column_directory_end]\n enc_names = buf[column_directory_end:names_end]\n data = buf[names_end:]\n\n names = {}\n values = {}\n\n last_name_offset: int | None = None\n last_data_offset: int | None = None\n last_dtype: int | None = None\n name_offset: int\n data_offset_dtype: int\n\n for i in range(column_count):\n if coldata_size % 2 == 0:\n name_offset, data_offset_dtype = struct_unpack_from(\n \"<H\" + data_offset_code, column_directory, offset=i * coldata_size\n )\n else:\n (name_offset,) = struct_unpack_from(\n \"<H\", column_directory, offset=i * coldata_size\n )\n # can't struct_unpack the 3 bytes so hack around\n dodt_bytes = (\n column_directory[i * coldata_size + 2 : (i * coldata_size + 5)]\n + b\"\\x00\"\n )\n (data_offset_dtype,) = struct_unpack(\"<\" + data_offset_code, dodt_bytes)\n\n data_offset_dtype &= data_offset_mask\n data_offset = data_offset_dtype >> 4\n dtype = data_offset_dtype & 0xF\n\n # Store *last* column's name\n if last_name_offset is not None:\n names[i - 1] = enc_names[last_name_offset:name_offset].decode(\"utf-8\")\n last_name_offset = name_offset\n\n #\n if last_data_offset is not None:\n assert last_dtype is not None\n values[i - 1] = decode(last_dtype, data[last_data_offset:data_offset])\n last_data_offset = data_offset\n last_dtype = dtype\n\n names[column_count - 1] = enc_names[last_name_offset:].decode(\"utf-8\")\n assert last_dtype is not None\n values[column_count - 1] = decode(last_dtype, data[last_data_offset:])\n\n # join data and names\n return {names[i]: values[i] for i in range(column_count)}","def test_unpack_2(self):\n val = ('item name', str)\n assert lws.parse_schema_val(val) == (str, '.*')","def unpack(self, struct):\n if len(self.view) < struct.size:\n raise UnderflowDecodeError()\n\n v = struct.unpack(self.view[0:struct.size])\n self.num_bytes_consumed += struct.size\n self.view = self.view[struct.size:]\n return v","def msgpack_unpackb(value):\n return msgpack.unpackb(value, object_hook=pseud_decode, encoding='utf-8')","def __extract_fields(self):\n for name, stuff in self.data.items():\n if stuff == (): # Empty tuple == 1 bit, value of 0\n self.fields.append(Field(name=name, value=0, size=1))\n elif isinstance(stuff, int): # int == specified value, value of 0\n self.fields.append(Field(name=name, value=0, size=stuff))\n elif isinstance(stuff, str): # str == specified value, value of 0\n pattern = re.compile(\"[0-9]+[bB]\")\n if pattern.match(stuff):\n if \"b\" in stuff: # bits specified\n size = int(stuff[:stuff.lower().index(\"b\")])\n self.fields.append(Field(name=name, value=0, size=size))\n elif \"B\" in stuff: # Bytes specified\n size = int(stuff[:stuff.lower().index(\"b\")]) * 8\n self.fields.append(Field(name=name, value=0, size=size))\n else: # No other string option, so must have been one of the \"vary\" constants from above.\n self.fields.append(Field(name=name, value=stuff, size=\"vary\"))\n elif isinstance(stuff, tuple) or isinstance(stuff, list): # specified value and size.\n if isinstance(stuff[0], str):\n if \"b\" in stuff[0]: # Bits\n size = int(stuff[0][:stuff[0].lower().index(\"b\")])\n # if not self.__check_bit_size(stuff[1], size):\n # raise Exception(\"error. \" + str(stuff[1]) + \" cannot be fit in \" + str(size) + \" bits.\")\n self.fields.append(Field(name=name, value=stuff[1], size=size))\n elif \"B\" in stuff[0]: # Bytes\n size = int(stuff[0][:stuff[0].lower().index(\"b\")]) * 8\n # if not self.__check_bit_size(stuff[1], size):\n # raise Exception(\"error. \" + str(stuff[1]) + \" cannot be fit in \" + str(size) + \" bits.\")\n self.fields.append(Field(name=name, value=stuff[1], size=size))\n elif stuff[0].lower() == NULL_TERMINATE:\n self.fields.append(Field(name=name, value=stuff[1], size=NULL_TERMINATE))\n elif stuff[0].lower() == PREFIX_LENGTH:\n self.fields.append(Field(name=name, value=stuff[1], size=PREFIX_LENGTH))\n elif stuff[0].lower() == PREFIX_LEN_NULL_TERM:\n self.fields.append(Field(name=name, value=stuff[1], size=PREFIX_LEN_NULL_TERM))\n elif stuff[0].lower() == IPv4:\n self.fields.append(Field(name=name, value=stuff[1], size=IPv4))\n elif isinstance(stuff[0], int):\n # if not self.__check_bit_size(stuff[1], stuff[0]):\n # raise Exception(\"error. \" + str(stuff[1]) + \" cannot be fit in \" + str(stuff[0]) + \" bits.\")\n self.fields.append(Field(name=name, value=stuff[1], size=stuff[0]))","def _decode_union(data_type, obj, alias_validators, strict, for_msgpack):\n val = None\n if isinstance(obj, six.string_types):\n # Handles the shorthand format where the union is serialized as only\n # the string of the tag.\n tag = obj\n if tag in data_type.definition._tagmap:\n val_data_type = data_type.definition._tagmap[tag]\n if not isinstance(val_data_type, (bv.Void, bv.Nullable)):\n raise bv.ValidationError(\n \"expected object for '%s', got symbol\" % tag)\n if tag == data_type.definition._catch_all:\n raise bv.ValidationError(\n \"unexpected use of the catch-all tag '%s'\" % tag)\n else:\n if not strict and data_type.definition._catch_all:\n tag = data_type.definition._catch_all\n else:\n raise bv.ValidationError(\"unknown tag '%s'\" % tag)\n elif isinstance(obj, dict):\n tag, val = _decode_union_dict(\n data_type, obj, alias_validators, strict, for_msgpack)\n else:\n raise bv.ValidationError(\"expected string or object, got %s\" %\n bv.generic_type_name(obj))\n return data_type.definition(tag, val)","def serialize_deserializedata(datastr):\r\n\r\n if type(datastr) != str:\r\n raise TypeError(\"Cannot deserialize non-string of type '\"+str(type(datastr))+\"'\")\r\n typeindicator = datastr[0]\r\n restofstring = datastr[1:]\r\n\r\n # this is essentially one huge case statement...\r\n\r\n # None\r\n if typeindicator == 'N':\r\n if restofstring != '':\r\n raise ValueError(\"Malformed None string '\"+restofstring+\"'\")\r\n return None\r\n\r\n # Boolean\r\n elif typeindicator == 'B':\r\n if restofstring == 'T':\r\n return True\r\n elif restofstring == 'F':\r\n return False\r\n raise ValueError(\"Malformed Boolean string '\"+restofstring+\"'\")\r\n\r\n # Integer / Long\r\n elif typeindicator == 'I':\r\n try:\r\n return int(restofstring) \r\n except ValueError:\r\n raise ValueError(\"Malformed Integer string '\"+restofstring+\"'\")\r\n\r\n\r\n # Float\r\n elif typeindicator == 'F':\r\n try:\r\n return float(restofstring) \r\n except ValueError:\r\n raise ValueError(\"Malformed Float string '\"+restofstring+\"'\")\r\n\r\n # Float\r\n elif typeindicator == 'C':\r\n try:\r\n return complex(restofstring) \r\n except ValueError:\r\n raise ValueError(\"Malformed Complex string '\"+restofstring+\"'\")\r\n\r\n\r\n\r\n # String\r\n elif typeindicator == 'S':\r\n return restofstring\r\n\r\n # List / Tuple / set / frozenset / dict\r\n elif typeindicator == 'L' or typeindicator == 'T' or typeindicator == 's' or typeindicator == 'f':\r\n # We'll split this and keep adding items to the list. At the end, we'll\r\n # convert it to the right type\r\n\r\n thislist = []\r\n\r\n data = restofstring\r\n # We'll use '0:' as our 'end separator'\r\n while data != '0:':\r\n lengthstr, restofdata = data.split(':', 1)\r\n length = int(lengthstr)\r\n\r\n # get this item, convert to a string, append to the list.\r\n thisitemdata = restofdata[:length]\r\n thisitem = serialize_deserializedata(thisitemdata)\r\n thislist.append(thisitem)\r\n\r\n # Now toss away the part we parsed.\r\n data = restofdata[length:]\r\n\r\n if typeindicator == 'L':\r\n return thislist\r\n elif typeindicator == 'T':\r\n return tuple(thislist)\r\n elif typeindicator == 's':\r\n return set(thislist)\r\n elif typeindicator == 'f':\r\n return frozenset(thislist)\r\n else:\r\n raise Exception(\"InternalError: not a known type after checking\")\r\n\r\n\r\n elif typeindicator == 'D':\r\n\r\n lengthstr, restofdata = restofstring.split(':', 1)\r\n length = int(lengthstr)\r\n\r\n # get this item, convert to a string, append to the list.\r\n keysdata = restofdata[:length]\r\n keys = serialize_deserializedata(keysdata)\r\n\r\n # The rest should be the values list.\r\n values = serialize_deserializedata(restofdata[length:])\r\n\r\n if type(keys) != list or type(values) != list or len(keys) != len(values):\r\n raise ValueError(\"Malformed Dict string '\"+restofstring+\"'\")\r\n \r\n thisdict = {}\r\n for position in xrange(len(keys)):\r\n thisdict[keys[position]] = values[position]\r\n \r\n return thisdict\r\n\r\n\r\n\r\n\r\n # Unknown!!!\r\n else:\r\n raise ValueError(\"Unknown typeindicator '\"+str(typeindicator)+\"' for data :\"+str(restofstring))","def stream_to_tuple(data, structure_definition, target):\n for index, definition in enumerate(structure_definition):\n logging.debug(definition)\n name, form = definition\n number, formtype = form\n logging.debug(\"{0}: {1}\".format(name, form))\n\n if type(formtype) == type(str()):\n # We have a string format, so no recursion\n formstr = \"{0}{1}\".format(number, formtype)\n logging.debug(\"Reading {0} ({1}) from stream at offset {2}.\".format(\n name, formstr, data.tell()))\n\n size = struct.calcsize(formstr)\n my_data = data.read(size)\n value = struct.unpack_from(formstr, my_data)\n\n logging.debug(\"Found: {0}\".format(value))\n\n # Now that we have the data, we need to consider whether it is an\n # array or a single value. If a character array, create a string.\n # If a numerical array, make a list. If a single value, make a\n # single value\n if form[-1] in \"?bBhHiIlLqQfdP\":\n logging.debug(\"Numerical value.\")\n # Numerical value\n if form[0] == 1:\n # Single value\n value = value[0]\n else:\n value = list(value)\n else:\n # Character value\n # Kludge to get rid of \"\\x00\". This should be possible using nicer\n # methods.\n logging.debug(\"Character value.\")\n value = strip_null(bytes(\"\".encode()).join(value).decode())\n\n logging.debug(\"{0}: {1}\".format(name, value))\n \n setattr(target, name, value)\n else:\n # Recursion!\n logging.debug(\"Recursing!\")\n if number == 1:\n setattr(target, name, CStruct(formtype))\n stream_to_tuple(data, formtype, getattr(target, name))\n else:\n setattr(target, name, tuple([CStruct(formtype)\n for i in range(number)]))\n for i in range(number):\n stream_to_tuple(data, formtype, getattr(target, name)[i])","def _break_down(self, buf, type_override=None, id_override=None):\n assert (id_override is not None and type_override is not None) or\\\n (id_override is None and type_override is None),\\\n 'Field ID and type must be both specified in headerless mode'\n\n while 1:\n field = {}\n if type_override is not None:\n f_type = type_override\n f_id = id_override\n else:\n # if no more data, stop and return\n try:\n f_type, f_id = self._decode_header(buf)\n except EOFError:\n break\n\n self.logger.debug(\n \"_break_down():field #%d pbtype #%d\", f_id, f_type\n )\n try:\n if f_type == 0: # vint\n field['data'] = self._decode_vint(buf)\n elif f_type == 1: # 64-bit\n field['data'] = self._read_fixed(buf, 8)\n elif f_type == 2: # str\n field['data'] = self._decode_str(buf)\n elif f_type == 5: # 32-bit\n field['data'] = self._read_fixed(buf, 4)\n else:\n self.logger.warning(\n \"_break_down():Ignore unknown type #%d\", f_type\n )\n continue\n except EndOfMessage as e:\n if type_override is None or e.partial:\n raise CodecError('Unexpected end of message while decoding field {0}'.format(f_id))\n else:\n break\n field['id'] = f_id\n field['wire_type'] = f_type\n yield field","def _decode(value):\n # TODO add support for strings\n return struct.unpack('<i', value)[0]","def unpack(self, format_str, data_range):\r\n new_format_str = ''.join(\r\n ('%c%c' % ('>' if self.endianness is self.BIG_ENDIAN else '<', format)\r\n for format in format_str))\r\n try:\r\n value = struct.unpack(new_format_str, self.data[data_range])\r\n except struct.error as e:\r\n raise ValueError('Possibly corrupt data buffer: %s' % e)\r\n if len(format_str) > 1:\r\n return value\r\n else:\r\n return value[0]","def parse_typed_struct(typed_struct):\n if len(typed_struct.keys()) == 1:\n for key in typed_struct:\n if key == 'S':\n return str(typed_struct[key])\n if key == 'N':\n return int(typed_struct[key])\n if key == 'M':\n for sub_key in typed_struct[key]:\n if isinstance(typed_struct[key][sub_key], dict):\n typed_struct[key][sub_key] = parse_typed_struct(typed_struct[key][sub_key])\n return dict(typed_struct[key])\n if key == 'L':\n for idx, elem in enumerate(typed_struct[key]):\n if isinstance(elem, dict):\n typed_struct[key][idx] = parse_typed_struct(typed_struct[key][idx])\n return list(typed_struct[key])\n else:\n for key in typed_struct:\n if isinstance(typed_struct[key], dict):\n typed_struct[key] = parse_typed_struct(typed_struct[key])","def _fill_cdata(cls):\n\n funcs = {}\n for key, name in [(\"b\", \"char\"), (\"h\", \"short\"),\n (\"i\", \"int\"), (\"q\", \"longlong\")]:\n for echar, esuffix in [(\"<\", \"le\"), (\">\", \"be\")]:\n esuffix = \"_\" + esuffix\n for unsigned in [True, False]:\n s = struct.Struct(echar + (key.upper() if unsigned else key))\n get_wrapper = lambda f: lambda *a, **k: f(*a, **k)[0]\n unpack = get_wrapper(s.unpack)\n unpack_from = get_wrapper(s.unpack_from)\n\n def get_unpack_from(s):\n def unpack_from(data, offset=0):\n return s.unpack_from(data, offset)[0], offset + s.size\n return unpack_from\n\n unpack_from = get_unpack_from(s)\n pack = s.pack\n\n prefix = \"u\" if unsigned else \"\"\n if s.size == 1:\n esuffix = \"\"\n bits = str(s.size * 8)\n\n if unsigned:\n max_ = 2 ** (s.size * 8) - 1\n min_ = 0\n else:\n max_ = 2 ** (s.size * 8 - 1) - 1\n min_ = - 2 ** (s.size * 8 - 1)\n\n funcs[\"%s%s_min\" % (prefix, name)] = min_\n funcs[\"%s%s_max\" % (prefix, name)] = max_\n funcs[\"%sint%s_min\" % (prefix, bits)] = min_\n funcs[\"%sint%s_max\" % (prefix, bits)] = max_\n\n funcs[\"%s%s%s\" % (prefix, name, esuffix)] = unpack\n funcs[\"%sint%s%s\" % (prefix, bits, esuffix)] = unpack\n funcs[\"%s%s%s_from\" % (prefix, name, esuffix)] = unpack_from\n funcs[\"%sint%s%s_from\" % (prefix, bits, esuffix)] = unpack_from\n funcs[\"to_%s%s%s\" % (prefix, name, esuffix)] = pack\n funcs[\"to_%sint%s%s\" % (prefix, bits, esuffix)] = pack\n\n for key, func in iteritems(funcs):\n setattr(cls, key, staticmethod(func))","def _pack_data( self, data ) : \r\n \r\n # hints = self._translation_table.get( type(data), None )\r\n hints = self._get_hints( data ) \r\n \r\n if hints is None : \r\n \r\n ## #debug: \r\n ## print \"_pack_data(): no hints for data type %s (data repr: %s)\" % (type(data), repr(data))\r\n \r\n # \"one-level recursion\" : \r\n # return self._pack_data( repr(data) )\r\n return self._pack_data( str(data) )\r\n \r\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \r\n ## if data is None: data = 0\r\n \r\n # else ... \r\n \r\n # 'DescType' + 'length' + 'data'\r\n desctype = hints[0]\r\n if desctype == 'TEXT' : \r\n length = len(data)\r\n data_str = data \r\n else :\r\n length = struct.calcsize( hints[1] )\r\n data_str = struct.pack( hints[1], data )\r\n \r\n length_str = struct.pack('=H', length)\r\n \r\n \r\n return _cat(desctype, length_str, data_str)","def unpack_time(s, type='I'):\n\ttry:\n\t\t(l,), s = unpack(\"!\"+type, s)\n\texcept TypeError, e:\n\t\traise TypeError(\"Problem unpacking time: %s\" % e)\n\n\tif l < 0:\n\t\treturn None\n\treturn datetime.fromtimestamp(l), s","def ingest(d):\n if isinstance(d, rawtype):\n return raw2str(d)\n elif isinstance(d, safetype):\n return d\n else:\n raise TypeError(\"Can't ingest data of type %s\" % type(d))","def dec(binary):\n result = []\n while binary:\n (key, dtype, length) = struct.unpack('>HBH', binary[:5])\n value = dec_elem(dtype, binary[5:5 + length])\n if value is not None:\n result.append((key, dtype, value))\n binary = binary[5 + length:]\n return result","def unpack32(data):\n\treturn struct.unpack('<I', data)[0]","def parse(cls, buf: memoryview, params: Params) \\\n -> tuple[AnyParseable, memoryview]:\n for data_type in params.expected:\n try:\n return data_type.parse(buf, params)\n except NotParseable:\n pass\n raise UnexpectedType(buf)","def dataRipFrom8583(text,typ) :\n\ttyp1,length1,varlength = DataTypeDetail(typ)\n\tif typ1 == 'z' :\n\t\treturn (text,len(text))\n\n\tif length1=='' :\n\t\traise Exception('type definition miss length(%s)' % typ)\n\tif typ1=='' :\n\t\traise Exception('type definition miss type(%s)' % typ)\n\tif varlength :\n\t\tl = len(length1)\n\t\tmaxlength = 0\n\t\ttry :\n\t\t\tmaxlength = int(length1)\n\t\texcept :\n\t\t\traise \n\t\ts1 = text[:l]\n\t\tdatalen = 0 \n\t\ttry :\n\t\t\tdatalen = int(s1)\n\t\texcept :\n\t\t\traise Exception('need int but not,(%s)' % s1)\n\t\tif datalen > maxlength :\n\t\t\traise Exception('%d extend maxlen(%d)' % (datalen,maxlength))\n\t\tvalue = text[l:l+datalen]\n\t\treturn (value,l + datalen)\n\tdatalen = int(length1)\n\tif typ1=='b' :\n\t\tdatalen,v = divmod(datalen,8)\n\t\tif v :\n\t\t\tdatalen += 1\n\n\tvalue = text[:datalen]\n\t#for i in value :\n\t#\tif not checkCharType(typ1,i) :\n\t#\t\ts = 'typ1= %s' % typ1 + 'i=%s' % i\n\t#\t\traise s,text\n\treturn (value,datalen)","def unpack(self, fmt, length=1):\n return struct.unpack(fmt, self.stream.read(length))[0]","def _unpacked_type(self):\n return self._UnpackedType","def deserialize(self, str):\n try:\n end = 0\n start = end\n end += 8\n (self.i,) = _struct_d.unpack(str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def deconstruct_single(self, op):\n bom = str(PlatformVar(\"bom\"))\n int_size = int(self.__size)\n if 1 == int_size:\n return struct.pack(bom + \"B\", op)\n if 2 == int_size:\n if 0 > op:\n return struct.pack(bom + \"h\", op)\n else:\n return struct.pack(bom + \"H\", op)\n elif 4 == int_size:\n if 0 > op:\n return struct.pack(bom + \"i\", op)\n else:\n return struct.pack(bom + \"I\", op)\n elif 8 == int_size:\n if 0 > op:\n return struct.pack(bom + \"q\", op)\n else:\n return struct.pack(bom + \"Q\", op)\n raise RuntimeError(\"cannot pack value of size %i\" % (int_size))","def read_type(adr, tyname):\n data = Rsp.read_mem(adr,tyname2size(tyname))\n data = bytes.fromhex(data)\n res, = struct.unpack(tyname2fmt(tyname), data)\n return(res)","def get_value_data(struct, data):\n func = data['func']\n value = '-'\n if func is not None:\n try:\n val = getattr(struct, func)()\n except Exception as e:\n _logger.debug('Failed to collect %s: %s', func, str(e))\n return '-', 1\n\n if data['type'] == 'str':\n value = data['convert'](val) if 'convert' in data else val\n if data['type'] == 'int':\n value = data['convert'](val) if 'convert' in data else val\n if data['type'] == 'float':\n value = data['convert'](val) if 'convert' in data else val\n if data['type'] == 'list':\n value = data['convert'](val[data['index']]) if 'convert' in data else val[data['index']]\n if data['type'] == 'yesno':\n value = get_yesno(val)\n if data['type'] == 'bool':\n value = data['convert'](val) if 'convert' in data else val\n return value, get_length(value)\n return None, 4","def packSub(self,type,data,*values):\n if values: data = struct.pack(data,*values)\n self.out.write(struct.pack('4si',type,len(data)))\n self.out.write(data)","def read_atom(datastream):\r\n size, type = struct.unpack(\">L4s\", datastream.read(8))\r\n type = type.decode('ascii')\r\n return size, type","def unpack64(data):\n\treturn struct.unpack('<Q', data)[0]","def unpack_str_from(buffer: bytes, offset: int = 0) -> tuple[str, int]:\n length, length_size = _unpack_length_from(buffer, offset=offset)\n offset += length_size\n str_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\n value = str_bytes.decode('utf-8')\n return value, length_size + length","def unpack_from(self, struct):\n if len(self.view) < struct.size:\n raise UnderflowDecodeError()\n\n v = struct.unpack_from(self.view)\n self.num_bytes_consumed += struct.size\n self.view = self.view[struct.size:]\n return v","def get_info(curf, begin, read, param_of_unpack):\n curf.seek(begin)\n info = curf.read(read)\n info = struct.unpack(param_of_unpack, info)\n return str(info[0])","def decode(fmtstr, data):\n return Wire(fmtstr).decode(data)","def _unpack(self, headerBytes):\n pass","def decode(data): #@NoSelf","def _unpack(self, headerBytes) -> None:\n unpacked = struct.unpack(self.PACKAGING_FORMAT, headerBytes)\n\n self.first_operand = unpacked[0]\n self.operator = unpacked[1]\n self.type_of_second_operand = unpacked[2]\n self.second_operand = unpacked[3]\n self.length = unpacked[4]","def data(self, overrun=0):\n data_type = self.data_type()\n data_length = self.raw_data_length()\n d = self.raw_data(overrun=overrun)\n\n if data_type == RegSZ or data_type == RegExpandSZ:\n if overrun > 0:\n # decode_utf16le() only returns the first string, but if we explicitly\n # ask for overrun, let's make a best-effort to decode as much as possible.\n return d.decode('utf16')\n else:\n return decode_utf16le(d)\n elif data_type == RegBin or data_type == RegNone:\n return d\n elif data_type == RegDWord:\n return struct.unpack_from(str(\"<I\"), d, 0)[0]\n elif data_type == RegMultiSZ:\n s = d.decode(\"utf16\")\n return s.split(\"\\x00\")\n elif data_type == RegQWord:\n return struct.unpack_from(str(\"<Q\"), d, 0)[0]\n elif data_type == RegBigEndian:\n return struct.unpack_from(str(\">I\"), d, 0)[0]\n elif data_type == RegLink or \\\n data_type == RegResourceList or \\\n data_type == RegFullResourceDescriptor or \\\n data_type == RegResourceRequirementsList:\n # we don't really support these types, but can at least\n # return raw binary for someone else to work with.\n return d\n elif data_type in (RegUint8, RegInt16, RegUint16, RegInt32, RegUint32, \n RegInt64, RegUint64, RegFloat, RegDouble, RegUnicodeChar, \n RegBoolean, RegUnicodeString, RegCompositeValue,RegDateTimeOffset, \n RegTimeSpan, RegGUID, RegUnk111, RegUnk112, RegUnk113, RegBytesArray, \n RegInt16Array, RegUint16Array, RegInt32Array, RegUInt32Array, \n RegInt64Array, RegUInt64Array, RegFloatArray, RegDoubleArray, \n RegUnicodeCharArray, RegBooleanArray, RegUnicodeStringArray):\n d = d[0:-8] # remove timestamp from end\n comp_type = data_type & 0xEFF # Apply mask for composite types\n return SettingsParse.ParseAppDataCompositeValue(comp_type, d, len(d))\n elif data_type == RegFileTime:\n return parse_windows_timestamp(struct.unpack_from(str(\"<Q\"), d, 0)[0])\n elif data_length < 5 or data_length >= 0x80000000:\n return struct.unpack_from(str(\"<I\"), d, 0)[0]\n else:\n raise UnknownTypeException(\"Unknown VK Record type 0x%x at 0x%x\" % (data_type, self.offset()))","def unmarshal(compoundSignature, data, offset=0, lendian=True, oobFDs=None):\n values = []\n start_offset = offset\n\n for ct in genCompleteTypes(compoundSignature):\n tcode = ct[0]\n offset += len(pad[tcode](offset))\n\n nbytes, value = unmarshallers[tcode](ct, data, offset, lendian, oobFDs)\n\n offset += nbytes\n values.append(value)\n\n return offset - start_offset, values","def read(self, fmt):\n fmt = '>' + fmt\n if not PY3:\n fmt = fmt.encode('utf-8')\n return struct.unpack(fmt, self.bin.read(format_byte_size(fmt)))","def decode(cls, dat):\n if len(dat) == 1:\n dat = dat[0]\n if len(dat) != len(cls.fields):\n return None\n return [dat[0], {'value': dat[1], 'time':dat[2], 'temp':dat[3]}]","def unpack(value):\n if not isinstance(value, tuple):\n return value, 200, {}\n try:\n data, code, headers = value\n return data, code, headers\n except ValueError:\n pass\n try:\n data, code = value\n return data, code, {}\n except ValueError:\n pass\n return value, 200, {}","def parse_from_dref(self, packet):\n\t\tname = packet[9:].strip(b'\\x00').decode('utf-8')\n\t\traw_value = packet[5:9]\n\t\tvalue = struct.unpack('f', raw_value)[0]\n\t\treturn name, value","def process_MESSAGE_TYPE_EDA(self, raw):\n eda = raw[2:6]\n return struct.unpack('>f', eda)","def readData(self, rawstring, datatype):\n data = rawstring[:-1] #remove last NULL byte\n\n if datatype == ERROR:\n if is_python3():\n data2 = data.tobytes()\n data = data2.decode('utf-8')\n return data\n elif datatype == STRING or datatype == DOUBLE:\n # try to convert data to a more appropriate type\n if is_python3():\n data2 = data.tobytes()\n data = data2.decode('utf-8')\n\n try:\n data = int(data)\n except:\n try:\n data = float(data)\n except:\n pass\n\n return data\n elif datatype == ASSOC:\n return rawtodictonary(rawstring)\n elif SpecArray.isArrayType(datatype):\n #Here we read cols and rows... which are *supposed* to be received in the header!!!\n #better approach: data contains this information (since it is particular to that data type)\n return SpecArray.SpecArray(rawstring, datatype, self.rows, self.cols)\n else:\n raise TypeError","def readStruct(file, fmt, offset=None):\n if offset is not None: file.seek(offset)\n if type(fmt) is tuple: # ( (item), (item), ... )\n fStr = _structTupleToFmt(fmt)\n size = struct.calcsize(fStr)\n data = file.read(size)\n return _structUnpack(fmt, data)\n else:\n size = struct.calcsize(fmt)\n data = file.read(size)\n res = struct.unpack(fmt, data)\n if len(res) == 1: return res[0] # grumble\n return res","def _decode_header(self, buf):\n ord_data = self._decode_vint(buf)\n f_type = ord_data & 7\n f_id = ord_data >> 3\n return f_type, f_id","def split_type(type):\n\n match = _type_re.match(type)\n if not match:\n raise ValueError(\"malformed type: %r\" % type)\n kind, precision = match.groups()\n itemsize = None\n if precision:\n precision = int(precision)\n itemsize, remainder = divmod(precision, 8)\n if remainder: # 0 could be a valid item size\n raise ValueError(\"precision must be a multiple of 8: %d\"\n % precision)\n return (kind, itemsize)","def test_unpack_2(self):\n key = ('item name', str, r'name')\n assert lws.parse_schema_key(key) == (str, 'name', '')","def bitcast(self, typ):","def dtype_to_pytype(type_):\n\n return {\n bool_: bool,\n int8: int,\n int16: int,\n int32: int,\n int64: int,\n uint8: int,\n uint16: int,\n uint32: int,\n uint64: int,\n float16: float,\n float32: float,\n float64: float,\n list_: list,\n tuple_: tuple,\n string: str,\n type_none: type(None)\n }[type_]","def _decode_message(self, label: str, buf, typedef=None, pos=0, end=None, group=False):\n print(str(pos) + \" decode_message \" + label)\n if end is None:\n end = len(buf)\n\n if typedef is None:\n typedef = {}\n else:\n # Don't want to accidentally modify the original\n typedef = copy.deepcopy(typedef)\n output = {}\n\n while pos < end:\n oldpos = pos\n tag, pos = decoder._DecodeVarint(buf, pos)\n try:\n field_number, wire_type = wire_format.UnpackTag(tag)\n except Exception as exc:\n raise (ValueError,\n 'Could not read valid tag at pos %d. Ensure it is a valid protobuf message: %s'\n % (pos-len(tag), exc), sys.exc_info()[2])\n # Convert to str\n field_number = str(field_number)\n orig_field_number = field_number\n \n field_typedef = None\n if field_number in typedef:\n field_typedef = typedef[field_number]\n else:\n field_typedef = {}\n field_typedef['type'] = self.wire_type_defaults[wire_type]\n field_type = field_typedef['type']\n if self.debug:\n ft = field_type\n if ft == None:\n ft = \"None\"\n print(\"@\" + str(oldpos) + \"-\" + str(pos-1) + \":\" + label + \" field_number \" +\n str(field_number) +\n \" wire_type \" + str(wire_type) +\n \" field_type \" + str(ft))\n # If field_type is None, its either an unsupported wire type, length delim or group\n # length delim we have to try and decode first\n field_out = None\n if field_type == 'LD':\n field_out, pos = self.decode_message_LD(label, buf, pos, field_typedef)\n elif field_type == 'endGroup':\n # TODO Should probably match the field_number to START_GROUP\n if not group:\n raise ValueError(\"Found END_GROUP before START_GROUP\")\n # exit out\n return output, typedef, pos\n elif field_type == 'message':\n field_out, pos = self.decode_message_message(\n label, buf, pos, field_typedef, field_number)\n elif field_type == 'group':\n group_typedef = None\n # Check for a anonymous type\n if 'group_typedef' in field_typedef:\n group_typedef = field_typedef['group_typedef']\n field_out, group_typedef, pos = self.decode_group(\n label, buf, group_typedef, pos)\n # Save type definition\n field_typedef['group_typedef'] = group_typedef\n else:\n # Verify wiretype matches\n if self.wiretypes[field_type] != wire_type:\n raise ValueError(\"Invalid wiretype for field number %s. %s is not wiretype %s\"\n % (field_number, field_type, wire_type))\n # Simple type, just look up the decoder\n field_out, pos = self.decoders[field_type](buf, pos)\n field_typedef['type'] = field_type\n if 'name' not in field_typedef:\n field_typedef['name'] = ''\n field_key = field_number\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\n field_key = field_typedef['name']\n # Deal with repeats\n if field_key in output:\n if isinstance(field_out, list):\n if isinstance(output[field_number], list):\n output[field_key] += field_out\n else:\n output[field_key] = field_out.append(output[field_key])\n else:\n if isinstance(output[field_number], list):\n output[field_key].append(field_out)\n else:\n output[field_key] = [output[field_key], field_out]\n else:\n output[field_key] = field_out\n typedef[orig_field_number] = field_typedef\n if self.debug:\n print(str(field_key) + \" field_out:\" + str(field_out))\n if pos > end:\n raise decoder._DecodeError(\"Invalid Message Length, pos=\" +\n str(pos) + \" end=\" + str(end))\n # Should never hit here as a group\n if group:\n raise ValueError(\"Got START_GROUP with no END_GROUP.\")\n print(\"decode_message finish \" + str(pos))\n return output, typedef, pos","def data_to_ctypes(data: Any) -> Tuple[int, Any]:\n if isinstance(data, bytes):\n return len(data), data\n else:\n if isinstance(data, tuple):\n data = array('f', data)\n try:\n m_view = memoryview(data)\n c_bytes = c_byte * m_view.nbytes\n return m_view.nbytes, c_bytes.from_buffer(m_view)\n except Exception as ex:\n raise TypeError(f\"Failed to convert data to ctypes: {ex}\")","def _deduceValueType(value):\n\n\tif value.lower() == 'null':\n\t\treturn None\n\n\tif value.startswith(\"0x\"):\n\t\treturn bytes.fromhex(value[2:])\n\n\t# If value can be an int, float() will not raise\n\t# exception too\n\tresult = value\n\ttry:\n\t\tresult = float(value)\n\t\tresult = int(value)\n\texcept:\n\t\tpass\n\n\treturn result","def deserialize(self, str):\n try:\n end = 0\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n start = end\n end += length\n if python3:\n self.name = str[start:end].decode('utf-8')\n else:\n self.name = str[start:end]\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.red_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.red_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.yellow_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.yellow_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.green_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.green_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.purple_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.purple_v = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.orange_u = struct.unpack(pattern, str[start:end])\n start = end\n end += 4\n (length,) = _struct_I.unpack(str[start:end])\n pattern = '<%sd'%length\n start = end\n end += struct.calcsize(pattern)\n self.orange_v = struct.unpack(pattern, str[start:end])\n return self\n except struct.error as e:\n raise genpy.DeserializationError(e) #most likely buffer underfill","def decode_tuple1(as_bytes: typing.List[int]) -> tuple:\n raise NotImplementedError()","def unpack_list(length_struct, struct, s, callback=None):\n\toutput, s = unpack(length_struct, s, callback)\n\tlength, = output\n\n\tlist = []\n\tfor i in range(0, length):\n\t\ttry:\n\t\t\toutput, s = unpack(struct, s, callback)\n\t\texcept TypeError, e:\n\t\t\traise TypeError(\"Problem unpacking list item (index %s): %s\" % (i, e))\n\n\t\tif len(output) == 1:\n\t\t\tlist.append(output[0])\n\t\telse:\n\t\t\tlist.append(output)\n\n\treturn list, s","def get_fixed_unpack(self):\n from functools import partial\n import struct\n unpack_str = ''\n header = []\n length = 0\n\n for col in self.columns:\n\n size = col.width\n\n if not size:\n continue\n\n length += size\n\n unpack_str += \"{}s\".format(size)\n\n header.append(col.name)\n\n return partial(struct.unpack, unpack_str), header, unpack_str, length"],"string":"[\n \"def parse_type(fobj, data_type):\\n if data_type == \\\"Boolean\\\": ## False if 0x00 else True\\n return bool(fobj.read(1))\\n elif data_type == \\\"Byte\\\": ## 1 byte int\\n return fobj.read(1)[0]\\n elif data_type == \\\"DateTime\\\": ## 8 bytes signed int\\n return struct.unpack(\\\"<q\\\", fobj.read(8))[0]\\n elif data_type == \\\"Double\\\": ## 8 bytes floating point\\n return struct.unpack(\\\"<d\\\", fobj.read(8))[0]\\n elif data_type == \\\"Int\\\": ## 4 bytes unsigned int\\n return struct.unpack(\\\"<I\\\", fobj.read(4))[0]\\n elif data_type == \\\"Int-Double pair\\\": ## 0x08-Int-0x0d-Double with AssertionError\\n bb = fobj.read(1)[0]\\n if bb != 0x08:\\n raise AssertionError('parse_type(fobj, data_type): '\\n '1st byte(%s) of \\\"Int-Double pair\\\" != 0x08' % bb)\\n first_int = parse_type(fobj, \\\"Int\\\")\\n bb = fobj.read(1)[0]\\n if bb != 0x0d:\\n raise AssertionError('parse_type(fobj, data_type): '\\n '6th byte(%s) of \\\"Int-Double pair\\\" != 0x0d' % bb)\\n return [first_int, parse_type(fobj, \\\"Double\\\")]\\n elif data_type == \\\"Int-Double pair*\\\": ## int(n) - \\\"Int-Double pair\\\"*n\\n return [parse_type(fobj, \\\"Int-Double pair\\\") for i in range(parse_type(fobj, \\\"Int\\\"))]\\n elif data_type == \\\"Long\\\": ## 8 bytes unsigned int\\n return struct.unpack(\\\"<Q\\\", fobj.read(8))[0]\\n elif data_type == \\\"Short\\\": ## 2 bytes unsigned int\\n return struct.unpack(\\\"<H\\\", fobj.read(2))[0]\\n elif data_type == \\\"Single\\\": ## 4 bytes floating point\\n return struct.unpack(\\\"<f\\\", fobj.read(4))[0]\\n elif data_type == \\\"String\\\": ## 0x00 or 0x0b - ULE128(n) - UTF-8(length=n)\\n bb = fobj.read(1)[0]\\n if bb == 0x00:\\n return None\\n elif bb != 0x0b:\\n ## TODO: show integers in assertion error in hexadecimal and decimal\\n ## to make debug more convenient (cause I may inspect the file in a byte reader.\\n raise AssertionError('parse_type(fobj, data_type): '\\n '1st byte(%s) of \\\"String\\\" not in {0x00, 0x0b}' % bb)\\n strlen = parse_type(fobj, \\\"ULEB128\\\")\\n return fobj.read(strlen).decode(\\\"utf-8\\\")\\n elif data_type == \\\"ULEB128\\\": ## https://en.wikipedia.org/wiki/LEB128#Decode_unsigned_integer\\n i = 0 ## derived from the wiki psuedo code\\n res = 0\\n shift = 0\\n while True:\\n bb = fobj.read(1)[0]\\n i += 1\\n res |= ((bb & 0b1111111) << shift)\\n if (bb & 0b10000000) == 0:\\n break\\n shift += 7\\n return res\\n elif data_type == \\\"Timing point\\\": ## Double - Double - Boolean\\n return parse_types(fobj, [\\\"Double\\\", \\\"Double\\\", \\\"Boolean\\\"])\\n elif data_type == \\\"Timing point+\\\": ## int(n) - \\\"Timing point\\\"*n\\n return [parse_type(fobj, \\\"Timing point\\\") for i in range(parse_type(fobj, \\\"Int\\\"))]\\n else:\\n raise NotImplementedError('parse_type(fobj, data_type): Unknown data type: \\\"%s\\\".' % data_type)\",\n \"def unpack(self, data_type):\\n\\t\\tif data_type in data_types:\\n\\t\\t\\tformat = data_types[data_type]\\n\\t\\t\\treturn self.unpack_real(format[0], format[1])\\n\\t\\t\\n\\t\\tif data_type == \\\"string8\\\":\\n\\t\\t\\tlength = self.unpack('short')\\n\\t\\t\\tif length < 0:\\n\\t\\t\\t\\traise Exception(\\\"Negative length for string\\\")\\n\\t\\t\\tif len(self.buff) < length:\\n\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\tstring = self.buff[:length]\\n\\t\\t\\tself.buff = self.buff[length:]\\n\\t\\t\\treturn string\\n\\t\\tif data_type == \\\"string16\\\":\\n\\t\\t\\tlength = self.unpack('short')\\n\\t\\t\\tif length < 0:\\n\\t\\t\\t\\traise Exception(\\\"Negative length for string\\\")\\n\\t\\t\\tif len(self.buff) < 2*length:\\n\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\tstring = self.buff[:2*length].decode('utf-16be')\\n\\t\\t\\tself.buff = self.buff[2*length:]\\n\\t\\t\\treturn string\\n\\t\\tif data_type == \\\"slot\\\":\\n\\t\\t\\to = {}\\n\\t\\t\\to[\\\"id\\\"] = self.unpack('short')\\n\\t\\t\\tif o[\\\"id\\\"] > 0:\\n\\t\\t\\t\\to[\\\"amount\\\"] = self.unpack('byte')\\n\\t\\t\\t\\to[\\\"damage\\\"] = self.unpack('short')\\n\\t\\t\\tif o[\\\"id\\\"] in SLOT_EXTRA_DATA_IDS:\\n\\t\\t\\t\\textra_len = self.unpack('short')\\n\\t\\t\\t\\tif extra_len <= 0:\\n\\t\\t\\t\\t\\to[\\\"extra\\\"] = None\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif len(self.buff) < extra_len:\\n\\t\\t\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\t\\t\\textra_buff = self.buff[:extra_len]\\n\\t\\t\\t\\t\\tself.buff = self.buff[extra_len:]\\n\\t\\t\\t\\t\\to[\\\"extra\\\"] = extra_buff\\n\\t\\t\\treturn o\\n\\t\\tif data_type == \\\"metadata\\\":\\n\\t\\t\\t#[(17, 0), (0, 0), (16, -1)]\\n\\t\\t\\to = []\\n\\t\\t\\tmtype = self.unpack('byte')\\n\\t\\t\\twhile mtype != 127:\\n\\t\\t\\t\\tmtype2 = mtype >> 5\\n\\t\\t\\t\\tt = 0\\n\\t\\t\\t\\tif mtype2 == 0: t = self.unpack('byte') \\n\\t\\t\\t\\tif mtype2 == 1: t = self.unpack('short') \\n\\t\\t\\t\\tif mtype2 == 2: t = self.unpack('int') \\n\\t\\t\\t\\tif mtype2 == 3: t = self.unpack('float') \\n\\t\\t\\t\\tif mtype2 == 4: t = self.unpack('string16')\\n\\t\\t\\t\\tif mtype2 == 5:\\n\\t\\t\\t\\t\\tt = {}\\n\\t\\t\\t\\t\\tt[\\\"id\\\"] = self.unpack('short')\\n\\t\\t\\t\\t\\tt[\\\"count\\\"] = self.unpack('byte')\\n\\t\\t\\t\\t\\tt[\\\"damage\\\"] = self.unpack('short')\\n\\t\\t\\t\\tif mtype2 == 6:\\n\\t\\t\\t\\t\\tt = []\\n\\t\\t\\t\\t\\tfor i in range(3):\\n\\t\\t\\t\\t\\t\\ts = self.unpack('int')\\n\\t\\t\\t\\t\\t\\tt.append(s)\\n\\t\\t\\t\\tt = (mtype, t)\\n\\t\\t\\t\\to.append(t)\\n\\t\\t\\t\\tmtype = self.unpack('byte')\\n\\t\\t\\treturn o\",\n \"def _unpack(formatstring, packed):\\n _checkString(formatstring, description='formatstring', minlength=1)\\n _checkString(packed, description='packed string', minlength=1)\\n\\n if sys.version_info[0] > 2:\\n packed = bytes(packed, encoding='latin1') # Convert types to make it Python3 compatible\\n\\n try:\\n value = struct.unpack(formatstring, packed)[0]\\n except:\\n errortext = 'The received bytestring is probably wrong, as the bytestring-to-num conversion failed.'\\n errortext += ' Bytestring: {0!r} Struct format code is: {1}'\\n raise ValueError(errortext.format(packed, formatstring))\\n\\n return value\",\n \"def _structUnpack(fmt, data, offs=0, _depth=0):\\n assert _depth < 10, \\\"Maximum depth exceeded\\\"\\n if type(fmt) is str:\\n r = struct.unpack_from(fmt, data, offs)\\n if len(r) == 1: return r[0] # grumble\\n return r\\n\\n # fmt is ( offset, type, name[, count] ) or a tuple of such\\n res = {}\\n if type(fmt[0]) is not tuple: fmt = (fmt,)\\n for item in fmt:\\n if len(item) > 3:\\n itemOffs, itemType, itemName, itemCount = item\\n else:\\n itemOffs, itemType, itemName = item\\n itemCount = 1\\n size = struct.calcsize(_structTupleToFmt(itemType))\\n val = []\\n for i in range(itemCount):\\n val.append(_structUnpack(itemType, data, offs=offs, _depth=_depth+1))\\n offs += size\\n if len(val) == 1: res[itemName] = val[0]\\n else: res[itemName] = val\\n return res\",\n \"def unpack(fmt, data):\\n fmt = _normalize(fmt)\\n formatdef, endianness, i, alignment = _getmode(fmt)\\n j = 0\\n num = 0\\n result = []\\n length = calcsize(fmt)\\n if length != len (data):\\n raise StructError(\\\"unpack str size does not match format\\\")\\n while i < len(fmt):\\n num, i = _getnum(fmt, i)\\n cur = fmt[i]\\n i += 1\\n try:\\n format = formatdef[cur]\\n except KeyError:\\n raise StructError(\\\"%s is not a valid format\\\" % cur)\\n\\n if not num :\\n num = 1\\n\\n if cur == 'x':\\n j += num\\n elif cur == 's':\\n result.append(data[j:j + num])\\n j += num\\n elif cur == 'p':\\n n = data[j]\\n if n >= num:\\n n = num - 1\\n result.append(data[j + 1:j + n + 1])\\n j += num\\n else:\\n # skip padding bytes until we get at a multiple of size\\n if j > 0 and alignment:\\n padding = format['size'] - j % format['size']\\n j += padding\\n for n in range(num):\\n result += [format['unpack'](data, j, format['size'],\\n endianness)]\\n j += format['size']\\n\\n return tuple(result)\",\n \"def interpret_packet_value_pair(data):\\n if data is None:\\n return None, None\\n packet_type = int.from_bytes(data[3:4], 'little')\\n name = value = None\\n if packet_type == 1:\\n name = str(data[17:], 'utf8') \\n value = float(ustruct.unpack('<i', data[12:16])[0])\\n elif packet_type == 5:\\n name = str(data[21:29], 'ascii').strip()\\n value = ustruct.unpack('<d', data[12:20])[0]\\n else:\\n display.scroll('Packet type {} not recognised'.format(packet_type))\\n return name, value\",\n \"def dec_elem(dtype, binary):\\n if dtype == BOOL:\\n return struct.unpack('>?', binary)[0]\\n elif dtype == UINT8:\\n return struct.unpack('>B', binary)[0]\\n elif dtype == UINT16:\\n return struct.unpack('>H', binary)[0]\\n elif dtype == UINT24:\\n (major, minor) = struct.unpack('>BH', binary)\\n return (major << 16) + minor\\n elif dtype == UINT32:\\n return struct.unpack('>I', binary)[0]\\n elif dtype == UINT64:\\n return struct.unpack('>Q', binary)[0]\\n elif dtype == INT8:\\n return struct.unpack('>b', binary)[0]\\n elif dtype == INT16:\\n return struct.unpack('>h', binary)[0]\\n elif dtype == INT24:\\n (major, minor) = struct.unpack('>hB', binary)\\n return (major << 8) + minor\\n elif dtype == INT32:\\n return struct.unpack('>i', binary)[0]\\n elif dtype == INT64:\\n return struct.unpack('>q', binary)[0]\\n elif dtype == DOUBLE:\\n return struct.unpack('>d', binary)[0]\\n elif dtype == STRING:\\n return binary\\n elif dtype == BITMAP:\\n (unused,) = struct.unpack('>B', binary[0])\\n binary = binary[1:]\\n bitsize = len(binary) * 8 - unused\\n if bitsize == 0:\\n return []\\n result = []\\n b = None\\n bitpointer = 0\\n while bitsize > 0:\\n if b is None:\\n b = struct.unpack('>B', binary[0])[0]\\n binary = binary[1:]\\n bitpointer = 0\\n bitpointer += 1\\n if unused > 0:\\n unused -= 1\\n b <<= 1\\n continue\\n result.append((b & 0b10000000) >> 7)\\n bitsize -= 1\\n b <<= 1\\n if bitpointer == 8:\\n b = None\\n return result\\n elif dtype == LIST_OF_STRING:\\n result = []\\n while binary:\\n length = struct.unpack('>H', binary[:2])[0]\\n result.append(binary[2:2 + length])\\n binary = binary[2 + length:]\\n return result\\n elif dtype == LIST_OF_UINT8:\\n return list(struct.unpack('>' + 'B' * len(binary), binary))\\n elif dtype == LIST_OF_UINT16:\\n return list(struct.unpack('>' + 'H' * (len(binary) / 2), binary))\\n elif dtype == LIST_OF_UINT24:\\n unpacked = struct.unpack('>' + 'BH' * (len(binary) / 3), binary)\\n result = []\\n while unpacked:\\n result.append((unpacked[0] << 16) + unpacked[1])\\n unpacked = unpacked[2:]\\n return result\\n elif dtype == LIST_OF_UINT32:\\n return list(struct.unpack('>' + 'I' * (len(binary) / 4), binary))\\n elif dtype == LIST_OF_UINT64:\\n return list(struct.unpack('>' + 'Q' * (len(binary) / 8), binary))\\n elif dtype == LIST_OF_INT8:\\n return list(struct.unpack('>' + 'b' * len(binary), binary))\\n elif dtype == LIST_OF_INT16:\\n return list(struct.unpack('>' + 'h' * (len(binary) / 2), binary))\\n elif dtype == LIST_OF_INT24:\\n unpacked = struct.unpack('>' + 'hB' * (len(binary) / 3), binary)\\n result = []\\n while unpacked:\\n result.append((unpacked[0] << 8) + unpacked[1])\\n unpacked = unpacked[2:]\\n return result\\n elif dtype == LIST_OF_INT32:\\n return list(struct.unpack('>' + 'i' * (len(binary) / 4), binary))\\n elif dtype == LIST_OF_INT64:\\n return list(struct.unpack('>' + 'q' * (len(binary) / 8), binary))\\n elif dtype == LIST_OF_DOUBLE:\\n return list(struct.unpack('>' + 'd' * (len(binary) / 8), binary))\",\n \"def _unpack_with_byteorder(self, fmt, data):\\n return struct.unpack(self.struct_byteorder + fmt, data)\",\n \"def _decode_struct(\\n data_type, obj, alias_validators, strict, old_style, for_msgpack):\\n if obj is None and data_type.has_default():\\n return data_type.get_default()\\n elif not isinstance(obj, dict):\\n raise bv.ValidationError('expected object, got %s' %\\n bv.generic_type_name(obj))\\n if strict:\\n for key in obj:\\n if (key not in data_type.definition._all_field_names_ and\\n not key.startswith('.tag')):\\n raise bv.ValidationError(\\\"unknown field '%s'\\\" % key)\\n ins = data_type.definition()\\n _decode_struct_fields(\\n ins, data_type.definition._all_fields_, obj, alias_validators, strict,\\n old_style, for_msgpack)\\n # Check that all required fields have been set.\\n data_type.validate_fields_only(ins)\\n return ins\",\n \"def _unpack(chid, data, count=None, ftype=None, as_numpy=True):\\n\\n def array_cast(data, count, ntype, use_numpy):\\n \\\"cast ctypes array to numpy array (if using numpy)\\\"\\n if use_numpy:\\n dtype = dbr.NP_Map.get(ntype, None)\\n if dtype is not None:\\n out = numpy.empty(shape=(count,), dtype=dbr.NP_Map[ntype])\\n ctypes.memmove(out.ctypes.data, data, out.nbytes)\\n else:\\n out = numpy.ctypeslib.as_array(copy(data))\\n else:\\n out = copy(data)\\n return out\\n\\n def unpack_simple(data, count, ntype, use_numpy):\\n \\\"simple, native data type\\\"\\n if count == 1 and ntype != dbr.STRING:\\n return data[0]\\n if ntype == dbr.STRING:\\n out = []\\n for elem in range(min(count, len(data))):\\n this = strjoin('', data[elem]).rstrip()\\n if NULLCHAR_2 in this:\\n this = this[:this.index(NULLCHAR_2)]\\n out.append(this)\\n if len(out) == 1:\\n out = out[0]\\n return out\\n if count > 1:\\n data = array_cast(data, count, ntype, use_numpy)\\n return data\\n\\n def unpack_ctrltime(data, count, ntype, use_numpy):\\n \\\"ctrl and time data types\\\"\\n if count == 1 or ntype == dbr.STRING:\\n data = data[0].value\\n if ntype == dbr.STRING and NULLCHAR in data:\\n data = data[:data.index(NULLCHAR)]\\n return data\\n # fix for CTRL / TIME array data:Thanks to Glen Wright !\\n data = (count*dbr.Map[ntype]).from_address(ctypes.addressof(data) +\\n dbr.value_offset[ftype])\\n if count > 1:\\n data = array_cast(data, count, ntype, use_numpy)\\n return data\\n\\n unpack = unpack_simple\\n if ftype >= dbr.TIME_STRING:\\n unpack = unpack_ctrltime\\n\\n if count is None and chid is not None:\\n count = element_count(chid)\\n if count is None:\\n count = 1\\n\\n if ftype is None and chid is not None:\\n ftype = field_type(chid)\\n if ftype is None:\\n ftype = dbr.INT\\n ntype = native_type(ftype)\\n use_numpy = (HAS_NUMPY and as_numpy and ntype != dbr.STRING and count > 1)\\n return unpack(data, count, ntype, use_numpy)\",\n \"def unpack( self, key, data ) :\\r\\n\\r\\n return struct.unpack(self[key], data)\",\n \"def unpack(self, fmt):\\n try:\\n data = self.get(struct.calcsize(fmt))\\n return struct.unpack(fmt, data)\\n except struct.error as e:\\n raise BufferError(\\n \\\"Error unpacking struct '%s' <%s>\\\" %\\n (fmt, binascii.hexlify(data).decode())\\n )\",\n \"def unpack (self, buffer):\\n\\t\\timport struct\\n\\t\\tvalues = struct.unpack (self.struct, buffer)\\n\\t\\tj = 0\\n\\t\\tfor i in self.structref:\\n\\t\\t\\tself.value[i[self.NAME]] = values[j]\\n\\t\\t\\tj = j + 1\",\n \"def get_unpack_format(in_dtype, dsize, endian='big', logger=cubeds.pylogger.get_logger(__name__)):\\n # logger = cubeds.pylogger.get_logger(__name__)\\n if dsize <= 8:\\n # bits\\n letter = 'b'\\n elif dsize == 16:\\n # short\\n letter = 'h'\\n elif dsize == 32:\\n # int\\n letter = 'i'\\n elif dsize == 64:\\n # long long\\n letter = 'q'\\n elif dsize == -1:\\n # padding\\n letter = str(dsize//8)+'x' # want self.size bytes of padding\\n in_dtype = 'int'\\n dsize = 1\\n else:\\n logger.fatal(\\\"parsing error for datatype size\\\")\\n raise cubeds.exceptions.UnpackFormatError(msg=\\\"parsing error for datatype size\\\")\\n\\n if in_dtype == 'dn':\\n letter = letter.upper()\\n elif in_dtype == 'sn':\\n letter = letter.lower()\\n elif in_dtype == 'char':\\n letter = str(int(dsize/8)) + 's'\\n elif in_dtype == 'float' or in_dtype == 'double':\\n letter = 'd'\\n else:\\n logger.fatal(\\\"parsing error for datatype \\\\\\\"\\\" + in_dtype + \\\"\\\\\\\" with size \\\\\\\"\\\" + str(dsize) + \\\"\\\\\\\"\\\")\\n raise cubeds.exceptions.UnpackFormatError(msg=\\\"parsing error for datatype \\\\\\\"\\\" + in_dtype + \\\"\\\\\\\" with size \\\\\\\"\\\"\\n + str(dsize) + \\\"\\\\\\\"\\\")\\n\\n if endian == 'big':\\n letter = '>' + letter\\n elif endian == 'little':\\n letter = '<' + letter\\n else:\\n logger.fatal(\\\"DID NOT SPECIFY ENDIANNESS CORRECTLY\\\")\\n raise cubeds.exceptions.UnpackFormatError(\\\"Endianness not specified correctly.\\\")\\n return letter\",\n \"def decode_data_info(metadict):\\n if 'datatype' not in metadict.keys():\\n raise KeyError(f\\\"'datatype' not found in the metadata dictionary\\\")\\n datatype = metadict['datatype']\\n if datatype not in DtypeDecoder.keys():\\n raise KeyError(f\\\"unknown data type: {datatype}\\\")\\n basetype, byteorder_sensitive = DtypeDecoder[datatype]\\n if byteorder_sensitive == True:\\n baseorder = _sys.byteorder\\n if 'byteorder' not in metadict.keys():\\n _warnings.warn(\\\"'byteorder' not found in the metadata dictionary: the native order is assumed.\\\")\\n return basetype\\n order = metadict['byteorder']\\n if order != baseorder:\\n return basetype.newbyteorder(ByteOrderDecoder[order])\\n else:\\n return basetype\\n else:\\n return basetype\",\n \"def _decode_field(self, field_type, field_data, subcontent=None):\\n # check wire type\\n wt_schema = self.__class__.FIELD_WIRE_TYPE[field_type]\\n wt_data = field_data['wire_type']\\n if wt_schema != wt_data:\\n raise TypeError(\\n 'Wire type mismatch (expect {0} but got {1})'\\\\\\n .format(wt_schema, wt_data)\\n )\\n\\n field_decoded = None\\n\\n # the actual decoding process\\n # nested structure\\n if field_type == 'a' and subcontent:\\n self.logger.debug('_decode_field(): nested field begin')\\n if self._kv_fmt:\\n field_decoded = dict(self._decode_wire(\\n io.BytesIO(field_data['data']),\\n subcontent\\n ))\\n else:\\n field_decoded = tuple(self._decode_wire(\\n io.BytesIO(field_data['data']),\\n subcontent\\n ))\\n self.logger.debug('_decode_field(): nested field end')\\n\\n # string, unsigned vint (2sc)\\n elif field_type in 'aT':\\n field_decoded = field_data['data']\\n\\n # unicode\\n elif field_type in 'U':\\n field_decoded = field_data['data'].decode('utf-8')\\n\\n # vint (zigzag)\\n elif field_type == 'z':\\n field_decoded = self._vint_dezigzagify(field_data['data'])\\n\\n # signed 2sc\\n elif field_type == 't':\\n field_decoded = self._vint_2sctosigned(field_data['data'])\\n\\n # fixed, float, double\\n elif field_type in 'iIfdqQ':\\n field_decoded = struct.unpack(\\n '<{0}'.format(field_type), field_data['data']\\n )[0]\\n\\n # boolean\\n elif field_type == 'b':\\n if field_data['data'] == 0:\\n field_decoded = False\\n else:\\n field_decoded = True\\n\\n return field_decoded\",\n \"def unpack(self, s):\\n\\n raise NotImplementedError()\",\n \"def unpack(struct, s, callback=None):\\n\\toutput = []\\n\\t\\n\\twhile len(struct) > 0:\\n\\t\\tchar = struct[0]\\n\\t\\tstruct = struct[1:]\\n\\n\\t\\tif char == ' ' or char == '!':\\n\\t\\t\\tcontinue\\n\\t\\telif char == '{':\\n\\t\\t\\t# Find the closing brace\\n\\t\\t\\tsubstruct, struct = string.split(struct, '}', maxsplit=1)\\n\\t\\t\\tdata, s = unpack_list(\\\"L\\\", substruct, s, callback)\\n\\t\\t\\t\\n\\t\\t\\toutput.append(data)\\n\\t\\telif char == '[':\\n\\t\\t\\t# Find the closing brace\\n\\t\\t\\tsubstruct, struct = smartsplit(struct, '[', ']')\\n\\t\\t\\tdata, s = unpack_list(\\\"I\\\", substruct, s, callback)\\n\\t\\t\\t\\n\\t\\t\\toutput.append(data)\\n\\t\\telif char in 'Tt':\\n\\t\\t\\tdata, s = unpack_time(s, times[char])\\n\\t\\t\\t\\n\\t\\t\\toutput.append(data)\\n\\t\\telif char == 'S':\\n\\t\\t\\tdata, s = unpack_string(s)\\n\\t\\t\\t\\n\\t\\t\\toutput.append(data)\\n\\t\\telif char in string.digits:\\n\\t\\t\\t# Get all the numbers\\n\\t\\t\\tsubstruct = char\\n\\t\\t\\twhile struct[0] in string.digits:\\n\\t\\t\\t\\tsubstruct += struct[0]\\n\\t\\t\\t\\tstruct = struct[1:]\\n\\t\\t\\t# And the value the number applies to\\n\\t\\t\\tsubstruct += struct[0]\\n\\t\\t\\tstruct = struct[1:]\\n\\t\\t\\t\\n\\t\\t\\tsize = _calcsize(substruct)\\n\\t\\t\\tsize = _calcsize(substruct)\\n\\t\\t\\tif size > len(s):\\n\\t\\t\\t\\traise TypeError(\\\"Not enough data for %s, needed %s bytes got %r (%s bytes)\\\" % (substruct[1:], size, s, len(s)))\\n\\n\\t\\t\\tdata = _unpack(\\\"!\\\"+substruct, s[:size])\\n\\t\\t\\ts = s[size:]\\n\\n\\t\\t\\toutput += data\\n\\t\\telif char == 'x':\\n\\t\\t\\to, s = callback(s)\\n\\t\\t\\toutput += o\\n\\t\\telse:\\n\\t\\t\\tif char in semi.keys():\\n\\t\\t\\t\\tsubstruct = \\\"!\\\"+semi[char][1]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tsubstruct = \\\"!\\\"+char\\n\\n\\t\\t\\tsize = _calcsize(substruct)\\n\\t\\t\\tif size > len(s):\\n\\t\\t\\t\\traise TypeError(\\\"Not enough data for %s, needed %s bytes got %r (%s bytes)\\\" % (substruct[1:], size, s, len(s)))\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tdata = _unpack(substruct, s[:size])\\n\\t\\t\\texcept _error, e:\\n\\t\\t\\t\\tprint \\\"Struct\\\", substruct, \\\"Args '%s'\\\" % (s[:size],)\\n\\t\\t\\t\\traise\\n\\t\\t\\ts = s[size:]\\n\\n\\t\\t\\tif char in semi.keys():\\n\\t\\t\\t\\tif data[0] == 2**semi[char][0]-1:\\n\\t\\t\\t\\t\\tdata = (-1,)\\n\\t\\t\\toutput += data\\n\\n\\treturn tuple(output), s\",\n \"def parse_binary_field(b):\\n\\n\\n codec, length, params = struct.unpack(\\\">iii\\\", b[:12])\\n len4 = lambda b: int(len(b[12:]) / 4)\\n if codec == 1: return struct.unpack(\\\"f\\\" * length, b[12:])\\n elif codec == 2: return struct.unpack(\\\"b\\\" * length, b[12:])\\n elif codec == 3: return struct.unpack(\\\">\\\" + \\\"h\\\" * length, b[12:])\\n elif codec == 4: return struct.unpack(\\\">\\\" + \\\"i\\\" * length, b[12:])\\n elif codec == 5:\\n chars = struct.unpack(\\\"c\\\" * (length * 4), b[12:])\\n return [b\\\"\\\".join([\\n c for c in chars[i * 4: (i + 1) * 4] if c != b\\\"\\\\x00\\\"\\n ]).decode() for i in range(length)]\\n elif codec == 6:\\n integers = struct.unpack(\\\">\\\" + (\\\"i\\\" * len4(b)), b[12:])\\n return [chr(c) if c != 0 else \\\"\\\" for c in run_length_decode(integers)]\\n elif codec == 7:\\n integers = struct.unpack(\\\">\\\" + (\\\"i\\\" * len4(b)), b[12:])\\n return run_length_decode(integers)\\n elif codec == 8:\\n integers = struct.unpack(\\\">\\\" + (\\\"i\\\" * len4(b)), b[12:])\\n return delta_decode(run_length_decode(integers))\\n elif codec == 9:\\n integers = struct.unpack(\\\">\\\" + (\\\"i\\\" * len4(b)), b[12:])\\n return [n / params for n in run_length_decode(integers)]\\n elif codec == 10:\\n integers = struct.unpack(\\\">\\\" + (\\\"h\\\" * int(len(b[12:]) / 2)), b[12:])\\n return [n / params for n in delta_decode(recursive_decode(integers))]\\n else: raise ValueError(\\\".mmtf error: {} is invalid codec\\\".format(codec))\",\n \"def loads(value):\\n return unpackb(value)\",\n \"def decode_struct(self, fmt, buf, pos):\\n new_pos = pos + struct.calcsize(fmt)\\n return struct.unpack(fmt, buf[pos:new_pos])[0], new_pos\",\n \"def decode_network_values(ptype, plen, buf):\\n nvalues = short.unpack_from(buf, header.size)[0]\\n off = header.size + short.size + nvalues\\n valskip = double.size\\n\\n # Check whether our expected packet size is the reported one\\n assert ((valskip + 1) * nvalues + short.size + header.size) == plen\\n assert double.size == number.size\\n\\n result = []\\n\\n for dstype in buf[header.size + short.size:off]:\\n if type(dstype) is type(\\\"foo\\\"): ## Python 2 handles dsType as a string!\\n dstype = int(dstype.encode('hex'))\\n \\n if dstype == DS_TYPE_COUNTER:\\n result.append((dstype, number.unpack_from(buf, off)[0]))\\n off += valskip\\n elif dstype == DS_TYPE_GAUGE:\\n result.append((dstype, double.unpack_from(buf, off)[0]))\\n off += valskip\\n elif dstype == DS_TYPE_DERIVE:\\n result.append((dstype, number.unpack_from(buf, off)[0]))\\n off += valskip\\n elif dstype == DS_TYPE_ABSOLUTE:\\n pprint(\\\"DS_TYPE_ABSOLUTE\\\")\\n result.append((dstype, number.unpack_from(buf, off)[0]))\\n off += valskip\\n else:\\n raise ValueError(\\\"DS type %i unsupported\\\" % dstype)\\n\\n return result\",\n \"def unpack_type_spec_from(\\n buffer: bytes, offset: int = 0\\n) -> tuple[computation_types.Type, int]:\\n length, length_size = _unpack_length_from(buffer, offset=offset)\\n offset += length_size\\n type_spec_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\\n proto = computation_pb2.Type.FromString(type_spec_bytes)\\n type_spec = type_serialization.deserialize_type(proto)\\n return type_spec, length_size + length # pytype: disable=bad-return-type\",\n \"def decode(self, data):\\n\\n # Tested:\\n # types: z, T, a\\n # nested_structure\\n # repeated\\n if not hasattr(data, 'read'):\\n data = io.BytesIO(data)\\n\\n if self._kv_fmt:\\n return dict(self._decode_wire(data))\\n else:\\n return tuple(self._decode_wire(data))\",\n \"def _unpackb2(s, **options):\\n if not isinstance(s, (str, bytearray)):\\n raise TypeError(\\\"packed data must be type 'str' or 'bytearray'\\\")\\n return _unpack(io.BytesIO(s), options)\",\n \"def unpack(self,format,size,recType='-----'):\\n endPos = self.ins.tell() + size\\n if endPos > self.size:\\n raise Tes3ReadError(self.inName, recType,endPos,self.size)\\n return struct.unpack(format,self.ins.read(size))\",\n \"def unpackb(value):\\n return load(io.BytesIO(value))\",\n \"def get_type_unpack(self, arg, option):\\n pass\",\n \"def _from_packed(self, value):\\n raise NotImplementedError\",\n \"def _decode(data: BencodedString) -> Union[bytes, dict, int, list]:\\n if not data.bytes:\\n raise ValueError(\\\"Cannot decode an empty bencoded string.\\\")\\n\\n if data.bytes[0] == START_DICT:\\n return _decode_dict(data)\\n\\n if data.bytes[0] == START_LIST:\\n return _decode_list(data)\\n\\n if data.bytes[0] == START_INTEGER:\\n return _decode_int(data)\\n\\n if chr(data.bytes[0]).isdigit():\\n return _decode_bytes(data)\\n\\n raise ValueError(\\n \\\"Cannot decode data, expected the first byte to be one of \\\"\\n f\\\"'d', 'i', 'l' or a digit, got {chr(data.bytes[0])!r} instead.\\\"\\n )\",\n \"def unpack(self, packedData):\\n raise NotImplementedError, 'Method need to be overriden'\",\n \"def _unbox_data_structure(struct):\\n\\n if isinstance(struct, list):\\n return [ _unbox_data_structure(item) for item in struct ]\\n elif isinstance(struct, graphlab.data_structures.sframe.SFrame):\\n return list(struct.pack_columns(column_prefix='', dtype=dict)['X1'])\\n elif isinstance(struct, graphlab.data_structures.sframe.SArray):\\n return list(struct)\\n elif isinstance(struct, graphlab.data_structures.sgraph.SGraph):\\n #TODO implement for SGraph\\n raise NotImplementedError('SGraph not supported.')\\n #encode_value will truncate and json-ify lists/dicts. Need to treat them differently\\n elif isinstance(struct, dict):\\n return { k: _unbox_data_structure(v) for (k, v) in six.iteritems(struct) }\\n else:\\n return _encode_value(struct)\",\n \"def _decode_struct_tree(data_type, obj, alias_validators, strict, for_msgpack):\\n subtype = _determine_struct_tree_subtype(data_type, obj, strict)\\n return _decode_struct(\\n subtype, obj, alias_validators, strict, False, for_msgpack)\",\n \"def _decode_value(data):\\n\\n # since Value messages contain only one value, it didn't seem necessary to\\n # represent it as a Python class.\\n\\n msg = Message(data)\\n value = None\\n count = 0\\n\\n for field in msg:\\n count += 1\\n if field.tag == ValueTags.STRING:\\n value = field.as_string()\\n\\n elif field.tag == ValueTags.FLOAT:\\n value = field.as_float()\\n\\n elif field.tag == ValueTags.DOUBLE:\\n value = field.as_double()\\n\\n elif field.tag == ValueTags.INT64:\\n value = field.as_int64()\\n\\n elif field.tag == ValueTags.UINT64:\\n value = field.as_uint64()\\n\\n elif field.tag == ValueTags.SINT64:\\n value = field.as_sint64()\\n\\n elif field.tag == ValueTags.BOOL:\\n value = field.as_int32() != 0\\n\\n else:\\n raise ValueError('Unexpected tag %d while decoding value'\\n % (field.tag,))\\n\\n # the MVT spec says that there should be one and only one field in the\\n # Value message, so check for that.\\n if value is None:\\n raise ValueError('Found no fields when decoding value')\\n if count > 1:\\n raise ValueError('Found multiple fields when decoding value')\\n\\n return value\",\n \"def decode(packed_data, custom_decoder=None):\\n decoder = make_decoder(custom_decoder)\\n structure = msgpack.unpackb(packed_data, ext_hook=decoder, encoding='utf-8')\\n return structure\",\n \"def _decode_wire(self, buf, subfmt=None):\\n def _concat_fields(fields):\\n \\\"\\\"\\\"\\n Concatenate 2 fields with the same wire type together\\n \\\"\\\"\\\"\\n result_wire = io.BytesIO()\\n result = {'id': fields[0]['id'], 'wire_type': fields[0]['wire_type']}\\n for field in fields:\\n assert field['id'] == result['id'] and \\\\\\n field['wire_type'] == result['wire_type'], \\\\\\n 'field id or wire_type mismatch'\\n result_wire.write(field['data'])\\n result['data'] = result_wire.getvalue()\\n return result\\n\\n decoded_raw = tuple(self._break_down(buf))\\n if not subfmt:\\n subfmt = self._fmt\\n\\n for fmt in subfmt:\\n field_id_start = fmt['field_id']\\n field_type = fmt['field_type']\\n field_prefix = fmt.get('prefix')\\n subcontent = fmt.get('subcontent')\\n repeat = fmt.get('repeat', 1)\\n\\n # sanity check\\n if self._kv_fmt:\\n assert repeat == 1 or field_type == 'x', 'Refuse to do field copying on non-skip field in key-value mode.'\\n\\n for field_id in range(field_id_start, field_id_start + repeat):\\n self.logger.debug(\\n '_decode_wire(): processing field #%d type %s',\\n field_id, field_type\\n )\\n\\n # skip blank field\\n if field_type == 'x':\\n continue\\n\\n # get all the data attached on the given field\\n fields = tuple(x for x in decoded_raw if x['id'] == field_id)\\n\\n # raise error if a required field is empty\\n if field_prefix == '*' and len(fields) == 0:\\n raise CodecError(\\n 'Field {0} is required but is empty'\\\\\\n .format(field_id)\\n )\\n\\n # identify which kind of repeated field is present\\n # normal repeated fields\\n if field_prefix == '+':\\n field_decoded = tuple(\\n self._decode_field(field_type, f, subcontent)\\n for f in fields\\n )\\n\\n # packed repeated field\\n elif field_prefix == '#':\\n if len(fields) > 1:\\n self.logger.warning(\\n 'Multiple data found in a packed-repeated field.'\\n )\\n fields = (_concat_fields(fields), )\\n if fields[0]['wire_type'] != self.__class__.FIELD_WIRE_TYPE['a']:\\n raise CodecError('Packed repeated field {0} has wire type other than str'.format(\\n fmt['name'] if self._kv_fmt else field_id\\n ))\\n field = io.BytesIO(fields[0]['data'])\\n unpacked_field = self._break_down(\\n field,\\n type_override=self.__class__.FIELD_WIRE_TYPE[field_type],\\n id_override=field_id\\n )\\n field_decoded = tuple(\\n self._decode_field(field_type, f, subcontent)\\n for f in unpacked_field\\n )\\n\\n # not a repeated field but has multiple data in one field\\n elif len(fields) > 1:\\n self.logger.warning(\\n 'Multiple data found in a non-repeated field.'\\n )\\n # Check if we are expecting a nested message\\n if subcontent is None:\\n # Use the last found data\\n field_decoded = self._decode_field(\\n field_type, fields[-1], subcontent\\n )\\n else:\\n # Concat all pieces of the nested message together and decode\\n #\\n # https://developers.google.com/protocol-buffers/docs/encoding#optional\\n # For embedded message fields, the parser merges multiple instances of the same field,\\n # as if with the `Message::MergeFrom` method – that is, all singular scalar fields in\\n # the latter instance replace those in the former, singular embedded messages are merged,\\n # and repeated fields are concatenated.\\n field_decoded = self._decode_field(\\n field_type, _concat_fields(fields), subcontent\\n )\\n\\n # not a repeated field\\n else:\\n if len(fields) != 0:\\n field_decoded = self._decode_field(\\n field_type, fields[0], subcontent\\n )\\n else:\\n field_decoded = None\\n\\n if self._kv_fmt:\\n yield fmt['name'], field_decoded\\n else:\\n yield field_decoded\",\n \"def _decode_union_old(data_type, obj, alias_validators, strict, for_msgpack):\\n val = None\\n if isinstance(obj, six.string_types):\\n # Union member has no associated value\\n tag = obj\\n if tag in data_type.definition._tagmap:\\n val_data_type = data_type.definition._tagmap[tag]\\n if not isinstance(val_data_type, (bv.Void, bv.Nullable)):\\n raise bv.ValidationError(\\n \\\"expected object for '%s', got symbol\\\" % tag)\\n else:\\n if not strict and data_type.definition._catch_all:\\n tag = data_type.definition._catch_all\\n else:\\n raise bv.ValidationError(\\\"unknown tag '%s'\\\" % tag)\\n elif isinstance(obj, dict):\\n # Union member has value\\n if len(obj) != 1:\\n raise bv.ValidationError('expected 1 key, got %s' % len(obj))\\n tag = list(obj)[0]\\n raw_val = obj[tag]\\n if tag in data_type.definition._tagmap:\\n val_data_type = data_type.definition._tagmap[tag]\\n if isinstance(val_data_type, bv.Nullable) and raw_val is None:\\n val = None\\n elif isinstance(val_data_type, bv.Void):\\n if raw_val is None or not strict:\\n # If raw_val is None, then this is the more verbose\\n # representation of a void union member. If raw_val isn't\\n # None, then maybe the spec has changed, so check if we're\\n # in strict mode.\\n val = None\\n else:\\n raise bv.ValidationError('expected null, got %s' %\\n bv.generic_type_name(raw_val))\\n else:\\n try:\\n val = _json_compat_obj_decode_helper(\\n val_data_type, raw_val, alias_validators, strict, True,\\n for_msgpack)\\n except bv.ValidationError as e:\\n e.add_parent(tag)\\n raise\\n else:\\n if not strict and data_type.definition._catch_all:\\n tag = data_type.definition._catch_all\\n else:\\n raise bv.ValidationError(\\\"unknown tag '%s'\\\" % tag)\\n else:\\n raise bv.ValidationError(\\\"expected string or object, got %s\\\" %\\n bv.generic_type_name(obj))\\n return data_type.definition(tag, val)\",\n \"def test_unpack_3(self):\\n val = ('item number', int)\\n assert lws.parse_schema_val(val) == (int, '')\",\n \"def _decode_value(data):\\n\\n if type(data) is tuple:\\n data = data[0]\\n\\n # Key does not exist\\n if data == '0' or data == \\\"\\\":\\n return None\\n \\n elif data[0] == _PREFIX:\\n\\n encoding = data[:2]\\n value = data[2:]\\n\\n if encoding == _TYPE_DOUBLE or encoding == _TYPE_DOUBLE_C:\\n return float(value)\\n elif encoding == _TYPE_STRING or encoding == _TYPE_STRING_C:\\n return value\\n elif encoding == _TYPE_INT or encoding == _TYPE_INT_C:\\n return int(value)\\n elif encoding == _TYPE_BOOL or encoding == _TYPE_BOOL_C:\\n return value == \\\"true\\\"\\n else:\\n return data\\n\\n elif data.startswith(\\\"<elsystem.collections.vector>\\\"):\\n return _decode_vector(data)\\n elif data.startswith(\\\"<elsystem.collections.dictionary>\\\"):\\n return _decode_dictionary(data)\\n else:\\n return data\",\n \"def _unpackb3(s, **options):\\n if not isinstance(s, (bytes, bytearray)):\\n raise TypeError(\\\"packed data must be type 'bytes' or 'bytearray'\\\")\\n return _unpack(io.BytesIO(s), options)\",\n \"def _unpack(self, _format: str, size: int) -> Any:\\n return unpack(_format, self.read(size))[0]\",\n \"def extract_packet(_buffer):\\n if len(_buffer)>=5:\\n mtype=_buffer[0]\\n msglen=struct.unpack('!L',_buffer[1:5])[0]\\n if len(_buffer)>=msglen+1:\\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\\n return None,None,_buffer\",\n \"def read_and_unpack(self, fmt):\\n try:\\n return unpack(\\n self.byte_order + fmt,\\n self.read(calcsize(self.byte_order + fmt)))\\n except Exception as e:\\n if e.args[0].startswith('unpack requires a buffer of'):\\n raise EOFError(e)\\n else:\\n raise\",\n \"def unpack(buf: bytes) -> dict[str, Any]:\\n flags: int\\n column_count: int\\n len_names: int\\n flags, column_count, len_names = struct_unpack_from(\\\"<BHH\\\", buf)\\n data_offset_code, coldata_size, data_offset_mask = decode_data_size(flags)\\n if (flags & 0xFC) != 4:\\n raise DynColValueError(\\\"Unknown dynamic columns format\\\")\\n\\n if column_count == 0:\\n return {}\\n\\n column_directory_end = (1 + 2 + 2) + coldata_size * column_count\\n names_end = column_directory_end + len_names\\n\\n column_directory = buf[1 + 2 + 2 : column_directory_end]\\n enc_names = buf[column_directory_end:names_end]\\n data = buf[names_end:]\\n\\n names = {}\\n values = {}\\n\\n last_name_offset: int | None = None\\n last_data_offset: int | None = None\\n last_dtype: int | None = None\\n name_offset: int\\n data_offset_dtype: int\\n\\n for i in range(column_count):\\n if coldata_size % 2 == 0:\\n name_offset, data_offset_dtype = struct_unpack_from(\\n \\\"<H\\\" + data_offset_code, column_directory, offset=i * coldata_size\\n )\\n else:\\n (name_offset,) = struct_unpack_from(\\n \\\"<H\\\", column_directory, offset=i * coldata_size\\n )\\n # can't struct_unpack the 3 bytes so hack around\\n dodt_bytes = (\\n column_directory[i * coldata_size + 2 : (i * coldata_size + 5)]\\n + b\\\"\\\\x00\\\"\\n )\\n (data_offset_dtype,) = struct_unpack(\\\"<\\\" + data_offset_code, dodt_bytes)\\n\\n data_offset_dtype &= data_offset_mask\\n data_offset = data_offset_dtype >> 4\\n dtype = data_offset_dtype & 0xF\\n\\n # Store *last* column's name\\n if last_name_offset is not None:\\n names[i - 1] = enc_names[last_name_offset:name_offset].decode(\\\"utf-8\\\")\\n last_name_offset = name_offset\\n\\n #\\n if last_data_offset is not None:\\n assert last_dtype is not None\\n values[i - 1] = decode(last_dtype, data[last_data_offset:data_offset])\\n last_data_offset = data_offset\\n last_dtype = dtype\\n\\n names[column_count - 1] = enc_names[last_name_offset:].decode(\\\"utf-8\\\")\\n assert last_dtype is not None\\n values[column_count - 1] = decode(last_dtype, data[last_data_offset:])\\n\\n # join data and names\\n return {names[i]: values[i] for i in range(column_count)}\",\n \"def test_unpack_2(self):\\n val = ('item name', str)\\n assert lws.parse_schema_val(val) == (str, '.*')\",\n \"def unpack(self, struct):\\n if len(self.view) < struct.size:\\n raise UnderflowDecodeError()\\n\\n v = struct.unpack(self.view[0:struct.size])\\n self.num_bytes_consumed += struct.size\\n self.view = self.view[struct.size:]\\n return v\",\n \"def msgpack_unpackb(value):\\n return msgpack.unpackb(value, object_hook=pseud_decode, encoding='utf-8')\",\n \"def __extract_fields(self):\\n for name, stuff in self.data.items():\\n if stuff == (): # Empty tuple == 1 bit, value of 0\\n self.fields.append(Field(name=name, value=0, size=1))\\n elif isinstance(stuff, int): # int == specified value, value of 0\\n self.fields.append(Field(name=name, value=0, size=stuff))\\n elif isinstance(stuff, str): # str == specified value, value of 0\\n pattern = re.compile(\\\"[0-9]+[bB]\\\")\\n if pattern.match(stuff):\\n if \\\"b\\\" in stuff: # bits specified\\n size = int(stuff[:stuff.lower().index(\\\"b\\\")])\\n self.fields.append(Field(name=name, value=0, size=size))\\n elif \\\"B\\\" in stuff: # Bytes specified\\n size = int(stuff[:stuff.lower().index(\\\"b\\\")]) * 8\\n self.fields.append(Field(name=name, value=0, size=size))\\n else: # No other string option, so must have been one of the \\\"vary\\\" constants from above.\\n self.fields.append(Field(name=name, value=stuff, size=\\\"vary\\\"))\\n elif isinstance(stuff, tuple) or isinstance(stuff, list): # specified value and size.\\n if isinstance(stuff[0], str):\\n if \\\"b\\\" in stuff[0]: # Bits\\n size = int(stuff[0][:stuff[0].lower().index(\\\"b\\\")])\\n # if not self.__check_bit_size(stuff[1], size):\\n # raise Exception(\\\"error. \\\" + str(stuff[1]) + \\\" cannot be fit in \\\" + str(size) + \\\" bits.\\\")\\n self.fields.append(Field(name=name, value=stuff[1], size=size))\\n elif \\\"B\\\" in stuff[0]: # Bytes\\n size = int(stuff[0][:stuff[0].lower().index(\\\"b\\\")]) * 8\\n # if not self.__check_bit_size(stuff[1], size):\\n # raise Exception(\\\"error. \\\" + str(stuff[1]) + \\\" cannot be fit in \\\" + str(size) + \\\" bits.\\\")\\n self.fields.append(Field(name=name, value=stuff[1], size=size))\\n elif stuff[0].lower() == NULL_TERMINATE:\\n self.fields.append(Field(name=name, value=stuff[1], size=NULL_TERMINATE))\\n elif stuff[0].lower() == PREFIX_LENGTH:\\n self.fields.append(Field(name=name, value=stuff[1], size=PREFIX_LENGTH))\\n elif stuff[0].lower() == PREFIX_LEN_NULL_TERM:\\n self.fields.append(Field(name=name, value=stuff[1], size=PREFIX_LEN_NULL_TERM))\\n elif stuff[0].lower() == IPv4:\\n self.fields.append(Field(name=name, value=stuff[1], size=IPv4))\\n elif isinstance(stuff[0], int):\\n # if not self.__check_bit_size(stuff[1], stuff[0]):\\n # raise Exception(\\\"error. \\\" + str(stuff[1]) + \\\" cannot be fit in \\\" + str(stuff[0]) + \\\" bits.\\\")\\n self.fields.append(Field(name=name, value=stuff[1], size=stuff[0]))\",\n \"def _decode_union(data_type, obj, alias_validators, strict, for_msgpack):\\n val = None\\n if isinstance(obj, six.string_types):\\n # Handles the shorthand format where the union is serialized as only\\n # the string of the tag.\\n tag = obj\\n if tag in data_type.definition._tagmap:\\n val_data_type = data_type.definition._tagmap[tag]\\n if not isinstance(val_data_type, (bv.Void, bv.Nullable)):\\n raise bv.ValidationError(\\n \\\"expected object for '%s', got symbol\\\" % tag)\\n if tag == data_type.definition._catch_all:\\n raise bv.ValidationError(\\n \\\"unexpected use of the catch-all tag '%s'\\\" % tag)\\n else:\\n if not strict and data_type.definition._catch_all:\\n tag = data_type.definition._catch_all\\n else:\\n raise bv.ValidationError(\\\"unknown tag '%s'\\\" % tag)\\n elif isinstance(obj, dict):\\n tag, val = _decode_union_dict(\\n data_type, obj, alias_validators, strict, for_msgpack)\\n else:\\n raise bv.ValidationError(\\\"expected string or object, got %s\\\" %\\n bv.generic_type_name(obj))\\n return data_type.definition(tag, val)\",\n \"def serialize_deserializedata(datastr):\\r\\n\\r\\n if type(datastr) != str:\\r\\n raise TypeError(\\\"Cannot deserialize non-string of type '\\\"+str(type(datastr))+\\\"'\\\")\\r\\n typeindicator = datastr[0]\\r\\n restofstring = datastr[1:]\\r\\n\\r\\n # this is essentially one huge case statement...\\r\\n\\r\\n # None\\r\\n if typeindicator == 'N':\\r\\n if restofstring != '':\\r\\n raise ValueError(\\\"Malformed None string '\\\"+restofstring+\\\"'\\\")\\r\\n return None\\r\\n\\r\\n # Boolean\\r\\n elif typeindicator == 'B':\\r\\n if restofstring == 'T':\\r\\n return True\\r\\n elif restofstring == 'F':\\r\\n return False\\r\\n raise ValueError(\\\"Malformed Boolean string '\\\"+restofstring+\\\"'\\\")\\r\\n\\r\\n # Integer / Long\\r\\n elif typeindicator == 'I':\\r\\n try:\\r\\n return int(restofstring) \\r\\n except ValueError:\\r\\n raise ValueError(\\\"Malformed Integer string '\\\"+restofstring+\\\"'\\\")\\r\\n\\r\\n\\r\\n # Float\\r\\n elif typeindicator == 'F':\\r\\n try:\\r\\n return float(restofstring) \\r\\n except ValueError:\\r\\n raise ValueError(\\\"Malformed Float string '\\\"+restofstring+\\\"'\\\")\\r\\n\\r\\n # Float\\r\\n elif typeindicator == 'C':\\r\\n try:\\r\\n return complex(restofstring) \\r\\n except ValueError:\\r\\n raise ValueError(\\\"Malformed Complex string '\\\"+restofstring+\\\"'\\\")\\r\\n\\r\\n\\r\\n\\r\\n # String\\r\\n elif typeindicator == 'S':\\r\\n return restofstring\\r\\n\\r\\n # List / Tuple / set / frozenset / dict\\r\\n elif typeindicator == 'L' or typeindicator == 'T' or typeindicator == 's' or typeindicator == 'f':\\r\\n # We'll split this and keep adding items to the list. At the end, we'll\\r\\n # convert it to the right type\\r\\n\\r\\n thislist = []\\r\\n\\r\\n data = restofstring\\r\\n # We'll use '0:' as our 'end separator'\\r\\n while data != '0:':\\r\\n lengthstr, restofdata = data.split(':', 1)\\r\\n length = int(lengthstr)\\r\\n\\r\\n # get this item, convert to a string, append to the list.\\r\\n thisitemdata = restofdata[:length]\\r\\n thisitem = serialize_deserializedata(thisitemdata)\\r\\n thislist.append(thisitem)\\r\\n\\r\\n # Now toss away the part we parsed.\\r\\n data = restofdata[length:]\\r\\n\\r\\n if typeindicator == 'L':\\r\\n return thislist\\r\\n elif typeindicator == 'T':\\r\\n return tuple(thislist)\\r\\n elif typeindicator == 's':\\r\\n return set(thislist)\\r\\n elif typeindicator == 'f':\\r\\n return frozenset(thislist)\\r\\n else:\\r\\n raise Exception(\\\"InternalError: not a known type after checking\\\")\\r\\n\\r\\n\\r\\n elif typeindicator == 'D':\\r\\n\\r\\n lengthstr, restofdata = restofstring.split(':', 1)\\r\\n length = int(lengthstr)\\r\\n\\r\\n # get this item, convert to a string, append to the list.\\r\\n keysdata = restofdata[:length]\\r\\n keys = serialize_deserializedata(keysdata)\\r\\n\\r\\n # The rest should be the values list.\\r\\n values = serialize_deserializedata(restofdata[length:])\\r\\n\\r\\n if type(keys) != list or type(values) != list or len(keys) != len(values):\\r\\n raise ValueError(\\\"Malformed Dict string '\\\"+restofstring+\\\"'\\\")\\r\\n \\r\\n thisdict = {}\\r\\n for position in xrange(len(keys)):\\r\\n thisdict[keys[position]] = values[position]\\r\\n \\r\\n return thisdict\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n # Unknown!!!\\r\\n else:\\r\\n raise ValueError(\\\"Unknown typeindicator '\\\"+str(typeindicator)+\\\"' for data :\\\"+str(restofstring))\",\n \"def stream_to_tuple(data, structure_definition, target):\\n for index, definition in enumerate(structure_definition):\\n logging.debug(definition)\\n name, form = definition\\n number, formtype = form\\n logging.debug(\\\"{0}: {1}\\\".format(name, form))\\n\\n if type(formtype) == type(str()):\\n # We have a string format, so no recursion\\n formstr = \\\"{0}{1}\\\".format(number, formtype)\\n logging.debug(\\\"Reading {0} ({1}) from stream at offset {2}.\\\".format(\\n name, formstr, data.tell()))\\n\\n size = struct.calcsize(formstr)\\n my_data = data.read(size)\\n value = struct.unpack_from(formstr, my_data)\\n\\n logging.debug(\\\"Found: {0}\\\".format(value))\\n\\n # Now that we have the data, we need to consider whether it is an\\n # array or a single value. If a character array, create a string.\\n # If a numerical array, make a list. If a single value, make a\\n # single value\\n if form[-1] in \\\"?bBhHiIlLqQfdP\\\":\\n logging.debug(\\\"Numerical value.\\\")\\n # Numerical value\\n if form[0] == 1:\\n # Single value\\n value = value[0]\\n else:\\n value = list(value)\\n else:\\n # Character value\\n # Kludge to get rid of \\\"\\\\x00\\\". This should be possible using nicer\\n # methods.\\n logging.debug(\\\"Character value.\\\")\\n value = strip_null(bytes(\\\"\\\".encode()).join(value).decode())\\n\\n logging.debug(\\\"{0}: {1}\\\".format(name, value))\\n \\n setattr(target, name, value)\\n else:\\n # Recursion!\\n logging.debug(\\\"Recursing!\\\")\\n if number == 1:\\n setattr(target, name, CStruct(formtype))\\n stream_to_tuple(data, formtype, getattr(target, name))\\n else:\\n setattr(target, name, tuple([CStruct(formtype)\\n for i in range(number)]))\\n for i in range(number):\\n stream_to_tuple(data, formtype, getattr(target, name)[i])\",\n \"def _break_down(self, buf, type_override=None, id_override=None):\\n assert (id_override is not None and type_override is not None) or\\\\\\n (id_override is None and type_override is None),\\\\\\n 'Field ID and type must be both specified in headerless mode'\\n\\n while 1:\\n field = {}\\n if type_override is not None:\\n f_type = type_override\\n f_id = id_override\\n else:\\n # if no more data, stop and return\\n try:\\n f_type, f_id = self._decode_header(buf)\\n except EOFError:\\n break\\n\\n self.logger.debug(\\n \\\"_break_down():field #%d pbtype #%d\\\", f_id, f_type\\n )\\n try:\\n if f_type == 0: # vint\\n field['data'] = self._decode_vint(buf)\\n elif f_type == 1: # 64-bit\\n field['data'] = self._read_fixed(buf, 8)\\n elif f_type == 2: # str\\n field['data'] = self._decode_str(buf)\\n elif f_type == 5: # 32-bit\\n field['data'] = self._read_fixed(buf, 4)\\n else:\\n self.logger.warning(\\n \\\"_break_down():Ignore unknown type #%d\\\", f_type\\n )\\n continue\\n except EndOfMessage as e:\\n if type_override is None or e.partial:\\n raise CodecError('Unexpected end of message while decoding field {0}'.format(f_id))\\n else:\\n break\\n field['id'] = f_id\\n field['wire_type'] = f_type\\n yield field\",\n \"def _decode(value):\\n # TODO add support for strings\\n return struct.unpack('<i', value)[0]\",\n \"def unpack(self, format_str, data_range):\\r\\n new_format_str = ''.join(\\r\\n ('%c%c' % ('>' if self.endianness is self.BIG_ENDIAN else '<', format)\\r\\n for format in format_str))\\r\\n try:\\r\\n value = struct.unpack(new_format_str, self.data[data_range])\\r\\n except struct.error as e:\\r\\n raise ValueError('Possibly corrupt data buffer: %s' % e)\\r\\n if len(format_str) > 1:\\r\\n return value\\r\\n else:\\r\\n return value[0]\",\n \"def parse_typed_struct(typed_struct):\\n if len(typed_struct.keys()) == 1:\\n for key in typed_struct:\\n if key == 'S':\\n return str(typed_struct[key])\\n if key == 'N':\\n return int(typed_struct[key])\\n if key == 'M':\\n for sub_key in typed_struct[key]:\\n if isinstance(typed_struct[key][sub_key], dict):\\n typed_struct[key][sub_key] = parse_typed_struct(typed_struct[key][sub_key])\\n return dict(typed_struct[key])\\n if key == 'L':\\n for idx, elem in enumerate(typed_struct[key]):\\n if isinstance(elem, dict):\\n typed_struct[key][idx] = parse_typed_struct(typed_struct[key][idx])\\n return list(typed_struct[key])\\n else:\\n for key in typed_struct:\\n if isinstance(typed_struct[key], dict):\\n typed_struct[key] = parse_typed_struct(typed_struct[key])\",\n \"def _fill_cdata(cls):\\n\\n funcs = {}\\n for key, name in [(\\\"b\\\", \\\"char\\\"), (\\\"h\\\", \\\"short\\\"),\\n (\\\"i\\\", \\\"int\\\"), (\\\"q\\\", \\\"longlong\\\")]:\\n for echar, esuffix in [(\\\"<\\\", \\\"le\\\"), (\\\">\\\", \\\"be\\\")]:\\n esuffix = \\\"_\\\" + esuffix\\n for unsigned in [True, False]:\\n s = struct.Struct(echar + (key.upper() if unsigned else key))\\n get_wrapper = lambda f: lambda *a, **k: f(*a, **k)[0]\\n unpack = get_wrapper(s.unpack)\\n unpack_from = get_wrapper(s.unpack_from)\\n\\n def get_unpack_from(s):\\n def unpack_from(data, offset=0):\\n return s.unpack_from(data, offset)[0], offset + s.size\\n return unpack_from\\n\\n unpack_from = get_unpack_from(s)\\n pack = s.pack\\n\\n prefix = \\\"u\\\" if unsigned else \\\"\\\"\\n if s.size == 1:\\n esuffix = \\\"\\\"\\n bits = str(s.size * 8)\\n\\n if unsigned:\\n max_ = 2 ** (s.size * 8) - 1\\n min_ = 0\\n else:\\n max_ = 2 ** (s.size * 8 - 1) - 1\\n min_ = - 2 ** (s.size * 8 - 1)\\n\\n funcs[\\\"%s%s_min\\\" % (prefix, name)] = min_\\n funcs[\\\"%s%s_max\\\" % (prefix, name)] = max_\\n funcs[\\\"%sint%s_min\\\" % (prefix, bits)] = min_\\n funcs[\\\"%sint%s_max\\\" % (prefix, bits)] = max_\\n\\n funcs[\\\"%s%s%s\\\" % (prefix, name, esuffix)] = unpack\\n funcs[\\\"%sint%s%s\\\" % (prefix, bits, esuffix)] = unpack\\n funcs[\\\"%s%s%s_from\\\" % (prefix, name, esuffix)] = unpack_from\\n funcs[\\\"%sint%s%s_from\\\" % (prefix, bits, esuffix)] = unpack_from\\n funcs[\\\"to_%s%s%s\\\" % (prefix, name, esuffix)] = pack\\n funcs[\\\"to_%sint%s%s\\\" % (prefix, bits, esuffix)] = pack\\n\\n for key, func in iteritems(funcs):\\n setattr(cls, key, staticmethod(func))\",\n \"def _pack_data( self, data ) : \\r\\n \\r\\n # hints = self._translation_table.get( type(data), None )\\r\\n hints = self._get_hints( data ) \\r\\n \\r\\n if hints is None : \\r\\n \\r\\n ## #debug: \\r\\n ## print \\\"_pack_data(): no hints for data type %s (data repr: %s)\\\" % (type(data), repr(data))\\r\\n \\r\\n # \\\"one-level recursion\\\" : \\r\\n # return self._pack_data( repr(data) )\\r\\n return self._pack_data( str(data) )\\r\\n \\r\\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \\r\\n ## if data is None: data = 0\\r\\n \\r\\n # else ... \\r\\n \\r\\n # 'DescType' + 'length' + 'data'\\r\\n desctype = hints[0]\\r\\n if desctype == 'TEXT' : \\r\\n length = len(data)\\r\\n data_str = data \\r\\n else :\\r\\n length = struct.calcsize( hints[1] )\\r\\n data_str = struct.pack( hints[1], data )\\r\\n \\r\\n length_str = struct.pack('=H', length)\\r\\n \\r\\n \\r\\n return _cat(desctype, length_str, data_str)\",\n \"def unpack_time(s, type='I'):\\n\\ttry:\\n\\t\\t(l,), s = unpack(\\\"!\\\"+type, s)\\n\\texcept TypeError, e:\\n\\t\\traise TypeError(\\\"Problem unpacking time: %s\\\" % e)\\n\\n\\tif l < 0:\\n\\t\\treturn None\\n\\treturn datetime.fromtimestamp(l), s\",\n \"def ingest(d):\\n if isinstance(d, rawtype):\\n return raw2str(d)\\n elif isinstance(d, safetype):\\n return d\\n else:\\n raise TypeError(\\\"Can't ingest data of type %s\\\" % type(d))\",\n \"def dec(binary):\\n result = []\\n while binary:\\n (key, dtype, length) = struct.unpack('>HBH', binary[:5])\\n value = dec_elem(dtype, binary[5:5 + length])\\n if value is not None:\\n result.append((key, dtype, value))\\n binary = binary[5 + length:]\\n return result\",\n \"def unpack32(data):\\n\\treturn struct.unpack('<I', data)[0]\",\n \"def parse(cls, buf: memoryview, params: Params) \\\\\\n -> tuple[AnyParseable, memoryview]:\\n for data_type in params.expected:\\n try:\\n return data_type.parse(buf, params)\\n except NotParseable:\\n pass\\n raise UnexpectedType(buf)\",\n \"def dataRipFrom8583(text,typ) :\\n\\ttyp1,length1,varlength = DataTypeDetail(typ)\\n\\tif typ1 == 'z' :\\n\\t\\treturn (text,len(text))\\n\\n\\tif length1=='' :\\n\\t\\traise Exception('type definition miss length(%s)' % typ)\\n\\tif typ1=='' :\\n\\t\\traise Exception('type definition miss type(%s)' % typ)\\n\\tif varlength :\\n\\t\\tl = len(length1)\\n\\t\\tmaxlength = 0\\n\\t\\ttry :\\n\\t\\t\\tmaxlength = int(length1)\\n\\t\\texcept :\\n\\t\\t\\traise \\n\\t\\ts1 = text[:l]\\n\\t\\tdatalen = 0 \\n\\t\\ttry :\\n\\t\\t\\tdatalen = int(s1)\\n\\t\\texcept :\\n\\t\\t\\traise Exception('need int but not,(%s)' % s1)\\n\\t\\tif datalen > maxlength :\\n\\t\\t\\traise Exception('%d extend maxlen(%d)' % (datalen,maxlength))\\n\\t\\tvalue = text[l:l+datalen]\\n\\t\\treturn (value,l + datalen)\\n\\tdatalen = int(length1)\\n\\tif typ1=='b' :\\n\\t\\tdatalen,v = divmod(datalen,8)\\n\\t\\tif v :\\n\\t\\t\\tdatalen += 1\\n\\n\\tvalue = text[:datalen]\\n\\t#for i in value :\\n\\t#\\tif not checkCharType(typ1,i) :\\n\\t#\\t\\ts = 'typ1= %s' % typ1 + 'i=%s' % i\\n\\t#\\t\\traise s,text\\n\\treturn (value,datalen)\",\n \"def unpack(self, fmt, length=1):\\n return struct.unpack(fmt, self.stream.read(length))[0]\",\n \"def _unpacked_type(self):\\n return self._UnpackedType\",\n \"def deserialize(self, str):\\n try:\\n end = 0\\n start = end\\n end += 8\\n (self.i,) = _struct_d.unpack(str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def deconstruct_single(self, op):\\n bom = str(PlatformVar(\\\"bom\\\"))\\n int_size = int(self.__size)\\n if 1 == int_size:\\n return struct.pack(bom + \\\"B\\\", op)\\n if 2 == int_size:\\n if 0 > op:\\n return struct.pack(bom + \\\"h\\\", op)\\n else:\\n return struct.pack(bom + \\\"H\\\", op)\\n elif 4 == int_size:\\n if 0 > op:\\n return struct.pack(bom + \\\"i\\\", op)\\n else:\\n return struct.pack(bom + \\\"I\\\", op)\\n elif 8 == int_size:\\n if 0 > op:\\n return struct.pack(bom + \\\"q\\\", op)\\n else:\\n return struct.pack(bom + \\\"Q\\\", op)\\n raise RuntimeError(\\\"cannot pack value of size %i\\\" % (int_size))\",\n \"def read_type(adr, tyname):\\n data = Rsp.read_mem(adr,tyname2size(tyname))\\n data = bytes.fromhex(data)\\n res, = struct.unpack(tyname2fmt(tyname), data)\\n return(res)\",\n \"def get_value_data(struct, data):\\n func = data['func']\\n value = '-'\\n if func is not None:\\n try:\\n val = getattr(struct, func)()\\n except Exception as e:\\n _logger.debug('Failed to collect %s: %s', func, str(e))\\n return '-', 1\\n\\n if data['type'] == 'str':\\n value = data['convert'](val) if 'convert' in data else val\\n if data['type'] == 'int':\\n value = data['convert'](val) if 'convert' in data else val\\n if data['type'] == 'float':\\n value = data['convert'](val) if 'convert' in data else val\\n if data['type'] == 'list':\\n value = data['convert'](val[data['index']]) if 'convert' in data else val[data['index']]\\n if data['type'] == 'yesno':\\n value = get_yesno(val)\\n if data['type'] == 'bool':\\n value = data['convert'](val) if 'convert' in data else val\\n return value, get_length(value)\\n return None, 4\",\n \"def packSub(self,type,data,*values):\\n if values: data = struct.pack(data,*values)\\n self.out.write(struct.pack('4si',type,len(data)))\\n self.out.write(data)\",\n \"def read_atom(datastream):\\r\\n size, type = struct.unpack(\\\">L4s\\\", datastream.read(8))\\r\\n type = type.decode('ascii')\\r\\n return size, type\",\n \"def unpack64(data):\\n\\treturn struct.unpack('<Q', data)[0]\",\n \"def unpack_str_from(buffer: bytes, offset: int = 0) -> tuple[str, int]:\\n length, length_size = _unpack_length_from(buffer, offset=offset)\\n offset += length_size\\n str_bytes, *_ = struct.unpack_from(f'!{length}s', buffer, offset=offset)\\n value = str_bytes.decode('utf-8')\\n return value, length_size + length\",\n \"def unpack_from(self, struct):\\n if len(self.view) < struct.size:\\n raise UnderflowDecodeError()\\n\\n v = struct.unpack_from(self.view)\\n self.num_bytes_consumed += struct.size\\n self.view = self.view[struct.size:]\\n return v\",\n \"def get_info(curf, begin, read, param_of_unpack):\\n curf.seek(begin)\\n info = curf.read(read)\\n info = struct.unpack(param_of_unpack, info)\\n return str(info[0])\",\n \"def decode(fmtstr, data):\\n return Wire(fmtstr).decode(data)\",\n \"def _unpack(self, headerBytes):\\n pass\",\n \"def decode(data): #@NoSelf\",\n \"def _unpack(self, headerBytes) -> None:\\n unpacked = struct.unpack(self.PACKAGING_FORMAT, headerBytes)\\n\\n self.first_operand = unpacked[0]\\n self.operator = unpacked[1]\\n self.type_of_second_operand = unpacked[2]\\n self.second_operand = unpacked[3]\\n self.length = unpacked[4]\",\n \"def data(self, overrun=0):\\n data_type = self.data_type()\\n data_length = self.raw_data_length()\\n d = self.raw_data(overrun=overrun)\\n\\n if data_type == RegSZ or data_type == RegExpandSZ:\\n if overrun > 0:\\n # decode_utf16le() only returns the first string, but if we explicitly\\n # ask for overrun, let's make a best-effort to decode as much as possible.\\n return d.decode('utf16')\\n else:\\n return decode_utf16le(d)\\n elif data_type == RegBin or data_type == RegNone:\\n return d\\n elif data_type == RegDWord:\\n return struct.unpack_from(str(\\\"<I\\\"), d, 0)[0]\\n elif data_type == RegMultiSZ:\\n s = d.decode(\\\"utf16\\\")\\n return s.split(\\\"\\\\x00\\\")\\n elif data_type == RegQWord:\\n return struct.unpack_from(str(\\\"<Q\\\"), d, 0)[0]\\n elif data_type == RegBigEndian:\\n return struct.unpack_from(str(\\\">I\\\"), d, 0)[0]\\n elif data_type == RegLink or \\\\\\n data_type == RegResourceList or \\\\\\n data_type == RegFullResourceDescriptor or \\\\\\n data_type == RegResourceRequirementsList:\\n # we don't really support these types, but can at least\\n # return raw binary for someone else to work with.\\n return d\\n elif data_type in (RegUint8, RegInt16, RegUint16, RegInt32, RegUint32, \\n RegInt64, RegUint64, RegFloat, RegDouble, RegUnicodeChar, \\n RegBoolean, RegUnicodeString, RegCompositeValue,RegDateTimeOffset, \\n RegTimeSpan, RegGUID, RegUnk111, RegUnk112, RegUnk113, RegBytesArray, \\n RegInt16Array, RegUint16Array, RegInt32Array, RegUInt32Array, \\n RegInt64Array, RegUInt64Array, RegFloatArray, RegDoubleArray, \\n RegUnicodeCharArray, RegBooleanArray, RegUnicodeStringArray):\\n d = d[0:-8] # remove timestamp from end\\n comp_type = data_type & 0xEFF # Apply mask for composite types\\n return SettingsParse.ParseAppDataCompositeValue(comp_type, d, len(d))\\n elif data_type == RegFileTime:\\n return parse_windows_timestamp(struct.unpack_from(str(\\\"<Q\\\"), d, 0)[0])\\n elif data_length < 5 or data_length >= 0x80000000:\\n return struct.unpack_from(str(\\\"<I\\\"), d, 0)[0]\\n else:\\n raise UnknownTypeException(\\\"Unknown VK Record type 0x%x at 0x%x\\\" % (data_type, self.offset()))\",\n \"def unmarshal(compoundSignature, data, offset=0, lendian=True, oobFDs=None):\\n values = []\\n start_offset = offset\\n\\n for ct in genCompleteTypes(compoundSignature):\\n tcode = ct[0]\\n offset += len(pad[tcode](offset))\\n\\n nbytes, value = unmarshallers[tcode](ct, data, offset, lendian, oobFDs)\\n\\n offset += nbytes\\n values.append(value)\\n\\n return offset - start_offset, values\",\n \"def read(self, fmt):\\n fmt = '>' + fmt\\n if not PY3:\\n fmt = fmt.encode('utf-8')\\n return struct.unpack(fmt, self.bin.read(format_byte_size(fmt)))\",\n \"def decode(cls, dat):\\n if len(dat) == 1:\\n dat = dat[0]\\n if len(dat) != len(cls.fields):\\n return None\\n return [dat[0], {'value': dat[1], 'time':dat[2], 'temp':dat[3]}]\",\n \"def unpack(value):\\n if not isinstance(value, tuple):\\n return value, 200, {}\\n try:\\n data, code, headers = value\\n return data, code, headers\\n except ValueError:\\n pass\\n try:\\n data, code = value\\n return data, code, {}\\n except ValueError:\\n pass\\n return value, 200, {}\",\n \"def parse_from_dref(self, packet):\\n\\t\\tname = packet[9:].strip(b'\\\\x00').decode('utf-8')\\n\\t\\traw_value = packet[5:9]\\n\\t\\tvalue = struct.unpack('f', raw_value)[0]\\n\\t\\treturn name, value\",\n \"def process_MESSAGE_TYPE_EDA(self, raw):\\n eda = raw[2:6]\\n return struct.unpack('>f', eda)\",\n \"def readData(self, rawstring, datatype):\\n data = rawstring[:-1] #remove last NULL byte\\n\\n if datatype == ERROR:\\n if is_python3():\\n data2 = data.tobytes()\\n data = data2.decode('utf-8')\\n return data\\n elif datatype == STRING or datatype == DOUBLE:\\n # try to convert data to a more appropriate type\\n if is_python3():\\n data2 = data.tobytes()\\n data = data2.decode('utf-8')\\n\\n try:\\n data = int(data)\\n except:\\n try:\\n data = float(data)\\n except:\\n pass\\n\\n return data\\n elif datatype == ASSOC:\\n return rawtodictonary(rawstring)\\n elif SpecArray.isArrayType(datatype):\\n #Here we read cols and rows... which are *supposed* to be received in the header!!!\\n #better approach: data contains this information (since it is particular to that data type)\\n return SpecArray.SpecArray(rawstring, datatype, self.rows, self.cols)\\n else:\\n raise TypeError\",\n \"def readStruct(file, fmt, offset=None):\\n if offset is not None: file.seek(offset)\\n if type(fmt) is tuple: # ( (item), (item), ... )\\n fStr = _structTupleToFmt(fmt)\\n size = struct.calcsize(fStr)\\n data = file.read(size)\\n return _structUnpack(fmt, data)\\n else:\\n size = struct.calcsize(fmt)\\n data = file.read(size)\\n res = struct.unpack(fmt, data)\\n if len(res) == 1: return res[0] # grumble\\n return res\",\n \"def _decode_header(self, buf):\\n ord_data = self._decode_vint(buf)\\n f_type = ord_data & 7\\n f_id = ord_data >> 3\\n return f_type, f_id\",\n \"def split_type(type):\\n\\n match = _type_re.match(type)\\n if not match:\\n raise ValueError(\\\"malformed type: %r\\\" % type)\\n kind, precision = match.groups()\\n itemsize = None\\n if precision:\\n precision = int(precision)\\n itemsize, remainder = divmod(precision, 8)\\n if remainder: # 0 could be a valid item size\\n raise ValueError(\\\"precision must be a multiple of 8: %d\\\"\\n % precision)\\n return (kind, itemsize)\",\n \"def test_unpack_2(self):\\n key = ('item name', str, r'name')\\n assert lws.parse_schema_key(key) == (str, 'name', '')\",\n \"def bitcast(self, typ):\",\n \"def dtype_to_pytype(type_):\\n\\n return {\\n bool_: bool,\\n int8: int,\\n int16: int,\\n int32: int,\\n int64: int,\\n uint8: int,\\n uint16: int,\\n uint32: int,\\n uint64: int,\\n float16: float,\\n float32: float,\\n float64: float,\\n list_: list,\\n tuple_: tuple,\\n string: str,\\n type_none: type(None)\\n }[type_]\",\n \"def _decode_message(self, label: str, buf, typedef=None, pos=0, end=None, group=False):\\n print(str(pos) + \\\" decode_message \\\" + label)\\n if end is None:\\n end = len(buf)\\n\\n if typedef is None:\\n typedef = {}\\n else:\\n # Don't want to accidentally modify the original\\n typedef = copy.deepcopy(typedef)\\n output = {}\\n\\n while pos < end:\\n oldpos = pos\\n tag, pos = decoder._DecodeVarint(buf, pos)\\n try:\\n field_number, wire_type = wire_format.UnpackTag(tag)\\n except Exception as exc:\\n raise (ValueError,\\n 'Could not read valid tag at pos %d. Ensure it is a valid protobuf message: %s'\\n % (pos-len(tag), exc), sys.exc_info()[2])\\n # Convert to str\\n field_number = str(field_number)\\n orig_field_number = field_number\\n \\n field_typedef = None\\n if field_number in typedef:\\n field_typedef = typedef[field_number]\\n else:\\n field_typedef = {}\\n field_typedef['type'] = self.wire_type_defaults[wire_type]\\n field_type = field_typedef['type']\\n if self.debug:\\n ft = field_type\\n if ft == None:\\n ft = \\\"None\\\"\\n print(\\\"@\\\" + str(oldpos) + \\\"-\\\" + str(pos-1) + \\\":\\\" + label + \\\" field_number \\\" +\\n str(field_number) +\\n \\\" wire_type \\\" + str(wire_type) +\\n \\\" field_type \\\" + str(ft))\\n # If field_type is None, its either an unsupported wire type, length delim or group\\n # length delim we have to try and decode first\\n field_out = None\\n if field_type == 'LD':\\n field_out, pos = self.decode_message_LD(label, buf, pos, field_typedef)\\n elif field_type == 'endGroup':\\n # TODO Should probably match the field_number to START_GROUP\\n if not group:\\n raise ValueError(\\\"Found END_GROUP before START_GROUP\\\")\\n # exit out\\n return output, typedef, pos\\n elif field_type == 'message':\\n field_out, pos = self.decode_message_message(\\n label, buf, pos, field_typedef, field_number)\\n elif field_type == 'group':\\n group_typedef = None\\n # Check for a anonymous type\\n if 'group_typedef' in field_typedef:\\n group_typedef = field_typedef['group_typedef']\\n field_out, group_typedef, pos = self.decode_group(\\n label, buf, group_typedef, pos)\\n # Save type definition\\n field_typedef['group_typedef'] = group_typedef\\n else:\\n # Verify wiretype matches\\n if self.wiretypes[field_type] != wire_type:\\n raise ValueError(\\\"Invalid wiretype for field number %s. %s is not wiretype %s\\\"\\n % (field_number, field_type, wire_type))\\n # Simple type, just look up the decoder\\n field_out, pos = self.decoders[field_type](buf, pos)\\n field_typedef['type'] = field_type\\n if 'name' not in field_typedef:\\n field_typedef['name'] = ''\\n field_key = field_number\\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\\n field_key = field_typedef['name']\\n # Deal with repeats\\n if field_key in output:\\n if isinstance(field_out, list):\\n if isinstance(output[field_number], list):\\n output[field_key] += field_out\\n else:\\n output[field_key] = field_out.append(output[field_key])\\n else:\\n if isinstance(output[field_number], list):\\n output[field_key].append(field_out)\\n else:\\n output[field_key] = [output[field_key], field_out]\\n else:\\n output[field_key] = field_out\\n typedef[orig_field_number] = field_typedef\\n if self.debug:\\n print(str(field_key) + \\\" field_out:\\\" + str(field_out))\\n if pos > end:\\n raise decoder._DecodeError(\\\"Invalid Message Length, pos=\\\" +\\n str(pos) + \\\" end=\\\" + str(end))\\n # Should never hit here as a group\\n if group:\\n raise ValueError(\\\"Got START_GROUP with no END_GROUP.\\\")\\n print(\\\"decode_message finish \\\" + str(pos))\\n return output, typedef, pos\",\n \"def data_to_ctypes(data: Any) -> Tuple[int, Any]:\\n if isinstance(data, bytes):\\n return len(data), data\\n else:\\n if isinstance(data, tuple):\\n data = array('f', data)\\n try:\\n m_view = memoryview(data)\\n c_bytes = c_byte * m_view.nbytes\\n return m_view.nbytes, c_bytes.from_buffer(m_view)\\n except Exception as ex:\\n raise TypeError(f\\\"Failed to convert data to ctypes: {ex}\\\")\",\n \"def _deduceValueType(value):\\n\\n\\tif value.lower() == 'null':\\n\\t\\treturn None\\n\\n\\tif value.startswith(\\\"0x\\\"):\\n\\t\\treturn bytes.fromhex(value[2:])\\n\\n\\t# If value can be an int, float() will not raise\\n\\t# exception too\\n\\tresult = value\\n\\ttry:\\n\\t\\tresult = float(value)\\n\\t\\tresult = int(value)\\n\\texcept:\\n\\t\\tpass\\n\\n\\treturn result\",\n \"def deserialize(self, str):\\n try:\\n end = 0\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n start = end\\n end += length\\n if python3:\\n self.name = str[start:end].decode('utf-8')\\n else:\\n self.name = str[start:end]\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.red_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.red_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.yellow_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.yellow_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.green_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.green_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.purple_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.purple_v = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.orange_u = struct.unpack(pattern, str[start:end])\\n start = end\\n end += 4\\n (length,) = _struct_I.unpack(str[start:end])\\n pattern = '<%sd'%length\\n start = end\\n end += struct.calcsize(pattern)\\n self.orange_v = struct.unpack(pattern, str[start:end])\\n return self\\n except struct.error as e:\\n raise genpy.DeserializationError(e) #most likely buffer underfill\",\n \"def decode_tuple1(as_bytes: typing.List[int]) -> tuple:\\n raise NotImplementedError()\",\n \"def unpack_list(length_struct, struct, s, callback=None):\\n\\toutput, s = unpack(length_struct, s, callback)\\n\\tlength, = output\\n\\n\\tlist = []\\n\\tfor i in range(0, length):\\n\\t\\ttry:\\n\\t\\t\\toutput, s = unpack(struct, s, callback)\\n\\t\\texcept TypeError, e:\\n\\t\\t\\traise TypeError(\\\"Problem unpacking list item (index %s): %s\\\" % (i, e))\\n\\n\\t\\tif len(output) == 1:\\n\\t\\t\\tlist.append(output[0])\\n\\t\\telse:\\n\\t\\t\\tlist.append(output)\\n\\n\\treturn list, s\",\n \"def get_fixed_unpack(self):\\n from functools import partial\\n import struct\\n unpack_str = ''\\n header = []\\n length = 0\\n\\n for col in self.columns:\\n\\n size = col.width\\n\\n if not size:\\n continue\\n\\n length += size\\n\\n unpack_str += \\\"{}s\\\".format(size)\\n\\n header.append(col.name)\\n\\n return partial(struct.unpack, unpack_str), header, unpack_str, length\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7574141","0.7300555","0.7035982","0.6990688","0.6908454","0.6716404","0.6593183","0.65563977","0.64701086","0.64119905","0.63946146","0.6381894","0.63355225","0.6306007","0.6268735","0.6262881","0.6244263","0.62122506","0.6211503","0.6190626","0.616264","0.6137288","0.60543644","0.6050495","0.60199654","0.6015257","0.60090977","0.5977878","0.59760517","0.59685254","0.5968093","0.5888214","0.5861897","0.5847496","0.58304316","0.58282083","0.5823518","0.5810369","0.57799286","0.57748","0.57426965","0.57397574","0.57294774","0.5726727","0.57212293","0.5703817","0.56997895","0.5699289","0.56967574","0.56856865","0.56744665","0.56686807","0.56662714","0.5665251","0.5656689","0.565511","0.5646117","0.5626259","0.5620838","0.5620363","0.5614692","0.5594453","0.5576172","0.55745095","0.5561378","0.555912","0.555772","0.5542668","0.5524935","0.5474644","0.5464076","0.54402673","0.5434985","0.5432767","0.542332","0.54174393","0.5414258","0.5413069","0.5412426","0.5411336","0.54072225","0.5402219","0.5401032","0.53952146","0.53937155","0.537118","0.53686315","0.53682065","0.53430504","0.5340239","0.5335076","0.5315308","0.5309184","0.5304651","0.5304309","0.53014326","0.52971506","0.52947086","0.52943575","0.52942175"],"string":"[\n \"0.7574141\",\n \"0.7300555\",\n \"0.7035982\",\n \"0.6990688\",\n \"0.6908454\",\n \"0.6716404\",\n \"0.6593183\",\n \"0.65563977\",\n \"0.64701086\",\n \"0.64119905\",\n \"0.63946146\",\n \"0.6381894\",\n \"0.63355225\",\n \"0.6306007\",\n \"0.6268735\",\n \"0.6262881\",\n \"0.6244263\",\n \"0.62122506\",\n \"0.6211503\",\n \"0.6190626\",\n \"0.616264\",\n \"0.6137288\",\n \"0.60543644\",\n \"0.6050495\",\n \"0.60199654\",\n \"0.6015257\",\n \"0.60090977\",\n \"0.5977878\",\n \"0.59760517\",\n \"0.59685254\",\n \"0.5968093\",\n \"0.5888214\",\n \"0.5861897\",\n \"0.5847496\",\n \"0.58304316\",\n \"0.58282083\",\n \"0.5823518\",\n \"0.5810369\",\n \"0.57799286\",\n \"0.57748\",\n \"0.57426965\",\n \"0.57397574\",\n \"0.57294774\",\n \"0.5726727\",\n \"0.57212293\",\n \"0.5703817\",\n \"0.56997895\",\n \"0.5699289\",\n \"0.56967574\",\n \"0.56856865\",\n \"0.56744665\",\n \"0.56686807\",\n \"0.56662714\",\n \"0.5665251\",\n \"0.5656689\",\n \"0.565511\",\n \"0.5646117\",\n \"0.5626259\",\n \"0.5620838\",\n \"0.5620363\",\n \"0.5614692\",\n \"0.5594453\",\n \"0.5576172\",\n \"0.55745095\",\n \"0.5561378\",\n \"0.555912\",\n \"0.555772\",\n \"0.5542668\",\n \"0.5524935\",\n \"0.5474644\",\n \"0.5464076\",\n \"0.54402673\",\n \"0.5434985\",\n \"0.5432767\",\n \"0.542332\",\n \"0.54174393\",\n \"0.5414258\",\n \"0.5413069\",\n \"0.5412426\",\n \"0.5411336\",\n \"0.54072225\",\n \"0.5402219\",\n \"0.5401032\",\n \"0.53952146\",\n \"0.53937155\",\n \"0.537118\",\n \"0.53686315\",\n \"0.53682065\",\n \"0.53430504\",\n \"0.5340239\",\n \"0.5335076\",\n \"0.5315308\",\n \"0.5309184\",\n \"0.5304651\",\n \"0.5304309\",\n \"0.53014326\",\n \"0.52971506\",\n \"0.52947086\",\n \"0.52943575\",\n \"0.52942175\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69019985"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":90587,"cells":{"query":{"kind":"string","value":"Reads the bytestring in self.buff, and returns the first packet contained within it. Sets self.buff to remaining bytestring. If packet is incomplete, returns None. But may raise if it thinks a real malformed packet has been recieved."},"document":{"kind":"string","value":"def read_packet(self):\n\n\t\t#self.debug(\"READ BUFFER SIZE: %d\" % len(self.buff))\n\t\tbackup = self.buff[:]\n\t\tpacket = Packet()\n\t\ttry:\n\t\t\tpacket.direction = self.node\n\t\t\tpacket.ident = self.unpack('ubyte')\n\t\t\t\n\t\t\t#Defined structs from huge dict\n\t\t\tfor datatype, name in self.get_struct(packet):\n\t\t\t\t# this populates packet.data with {name: value}\n\t\t\t\tpacket.data[name] = self.unpack(datatype)\n\n\t\t\t# I believe the following are packet-type specific fixes for variable-length packets.\n\n\t\t\t#0x17\n\t\t\tif packet.ident == 0x17:\n\t\t\t\tif packet.data['unknown'] > 0:\n\t\t\t\t\tpacket.data['x2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['y2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['z2'] = self.unpack('short')\n\t\t\n\t\t\t#0x33\n\t\t\tif packet.ident in (0x33, 0x34):\n\t\t\t\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n#\t\t\t#0x34\n#\t\t\tif packet.ident == 0x34:\n#\t\t\t\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\n#\t\t\t\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tpacket.data[\"blocks\"] = []\n#\t\t\t\tfor i in zip(coords, btype, metadata):\n#\t\t\t\t\tblock = {}\n#\t\t\t\t\tblock[\"x\"] =\t\ti[0] >> 12\n#\t\t\t\t\tblock[\"z\"] = 0x0F & i[0] >> 8\n#\t\t\t\t\tblock[\"y\"] = 0xFF & i[0]\n#\t\t\t\t\tblock[\"type\"] = i[1]\n#\t\t\t\t\tblock[\"metadata\"] = i[2]\n#\t\t\t\t\tpacket.data[\"blocks\"].append(block)\n#\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x3C\n\t\t\tif packet.ident == 0x3C:\n\t\t\t\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\n\t\t\t\ti = 0\n\t\t\t\tpacket.data[\"blocks\"] = []\n\t\t\t\twhile i < packet.data['data_size']*3:\n\t\t\t\t\tpacket.data[\"blocks\"].append(dict(zip(('x','y','z'), records[i:i+3])))\n\t\t\t\t\ti+=3\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x68\n\t\t\tif packet.ident == 0x68:\n\t\t\t\tpacket.data[\"slots_data\"] = self.unpack_array('slot', packet.data[\"data_size\"])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\t#0x82:\n\t\t\tif packet.ident == 0x82:\n\t\t\t\tpacket.data[\"text\"] = []\n\t\t\t\tfor i in range(4):\n\t\t\t\t\tpacket.data[\"text\"].append(packet.data[\"line_%s\" % (i+1)])\n\t\t\t\t\t\n\t\t\t#0x83\n\t\t\tif packet.ident == 0x83:\n\t\t\t\tpacket.data[\"data\"] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\n\t\t\t# Sets packet.original to the byte string that the packet was decoded from.\n\t\t\tpacket.original = backup[:len(backup) - len(self.buff)]\n\n\t\t\treturn packet\n\n\t\texcept IncompleteData:\n\t\t\tself.buff = backup\n\t\t\treturn None\n\t\texcept Exception, ex:\n\t\t\tself.buff = backup\n\t\t\tex.args += (self.buff[20:],)\n\t\t\traise"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def recv_packet(self):\r\n self.recv_bytes()\r\n\r\n packet_length_index = 0\r\n \r\n amount_data = len(self.recvBuffer) # available amount of data to read\r\n \r\n if amount_data <= packet_length_index: # just 0's in the buffer\r\n return None\r\n\r\n if len(self.recvBuffer) <= packet_length_index + 2: # length not received\r\n return None\r\n \r\n packet_length = unpack(self.recvBuffer, packet_length_index, 'H')\r\n \r\n if packet_length > len(self.recvBuffer): # packet not fully received\r\n return None\r\n \r\n if packet_length == 0: # some wrong generated packet by server, inc position of reading packet length\r\n packet_length_index += 1\r\n return None\r\n\r\n\t\t# extract packet data\r\n packet = self.recvBuffer[packet_length_index:packet_length_index+packet_length]\r\n\r\n # remaining recv buffer\r\n self.recvBuffer = self.recvBuffer[packet_length_index + packet_length:]\r\n packet_length_index = 0 # next packet length should be at pos 0 again\r\n\r\n return packet","def async_read(self):\n self.lock.acquire()\n\n # append data\n self.rx_buffer += self.interface.read()\n\n # ensure first byte start with 0xbc\n if len(self.rx_buffer) > 0:\n if self.rx_buffer[0] != 0xbc:\n try:\n pkt_start = self.rx_buffer.index(0xbc)\n self.rx_buffer = self.rx_buffer[pkt_start:]\n except ValueError:\n self.rx_buffer = bytes()\n\n # check if we got a valid packet\n if len(self.rx_buffer) >= 4:\n pkt_size = unpack('<H', self.rx_buffer[2:4])[0]\n # check if we got a complete packet\n if len(self.rx_buffer) >= (pkt_size + 5):\n # yep, parse this packet\n packet = Packet.fromBytes(self.rx_buffer[:pkt_size+5])\n self.rx_buffer = self.rx_buffer[pkt_size+5:]\n self.lock.release()\n return packet\n\n # otherwise, return None\n self.lock.release()\n return None","def read(self):\n packet = None\n while packet is None:\n packet = self.async_read()\n return packet","def read_pkt_line(self):\n if self._readahead is None:\n read = self.read\n else:\n read = self._readahead.read\n self._readahead = None\n\n try:\n sizestr = read(4)\n if not sizestr:\n raise HangupException()\n size = int(sizestr, 16)\n if size == 0:\n if self.report_activity:\n self.report_activity(4, \"read\")\n return None\n if self.report_activity:\n self.report_activity(size, \"read\")\n pkt_contents = read(size - 4)\n except socket.error as e:\n raise GitProtocolError(e)\n else:\n if len(pkt_contents) + 4 != size:\n raise GitProtocolError(\n \"Length of pkt read %04x does not match length prefix %04x\"\n % (len(pkt_contents) + 4, size)\n )\n return pkt_contents","def _read(self):\n \n try:\n d = self._get_byte()\n ts = time.time()\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n ts = time.time()\n packet = [d]\n d = self._get_byte()\n if d == self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n ts = time.time()\n else:\n packet.append(d)\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n packet.append(d)\n if self._debug == True:\n print \"Serial:_read: unescaped\", packet\n packet = self._unescape(packet)\n \n crc = self._crc16(0, packet[1:-3])\n packet_crc = self._decode(packet[-3:-1])\n \n if crc != packet_crc:\n print \"Warning: wrong CRC! %x != %x %s\" % (crc, packet_crc, [\"%2x\" % i for i in packet])\n if self._debug:\n if self._ts == None:\n self._ts = ts\n else:\n print \"Serial:_read: %.4f (%.4f) Recv:\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\n self._ts = ts\n return RawPacket(ts, packet[1:-3], crc == packet_crc)\n except socket.timeout:\n return None","def recv(self) -> Optional[bytes]:\n ready, _, _ = select.select([self.socket], [], [], 0)\n if len(ready) != 0:\n new_bytes = self.socket.recv(self.BUFFER_SIZE)\n self.__recv_buffer = self.__recv_buffer + new_bytes\n return self.__parse_one_message()","async def read_one_message(self):\n if not self.connected:\n return None\n\n try:\n header = await self.reader.readexactly(2)\n except SocketError as err:\n if err.errno == errno.ECONNRESET:\n self.log.error('Connection reset by peer')\n self.connected = False\n if err.errno == errno.EHOSTUNREACH:\n self.log.error('Spa unreachable')\n self.connected = False\n else:\n self.log.error('Spa socket error: {0}'.format(str(err)))\n return None\n except Exception as e:\n self.log.error('Spa read failed: {0}'.format(str(e)))\n return None\n\n if header[0] == M_START:\n # header[1] is size, + checksum + M_END (we already read 2 tho!)\n rlen = header[1]\n else:\n return None\n\n # now get the rest of the data\n try:\n data = await self.reader.readexactly(rlen)\n except Exception as e:\n self.log.errpr('Spa read failed: {0}'.format(str(e)))\n return None\n\n full_data = header + data\n # don't count M_START, M_END or CHKSUM (remember that rlen is 2 short)\n crc = messages.Message.crc(full_data[1:rlen - 1])\n if crc != full_data[-2]:\n self.log.error('Message had bad CRC, discarding')\n return None\n\n # self.log.error('got update: {}'.format(full_data.hex()))\n return full_data","def recv_bundle(self):\n hdr_raw = sock_recv_raw(self.sock, 6, self.timeout)\n data_length, has_secondary = SPPPacketHeader.preparse_data_length(\n hdr_raw\n )\n data_plus_secondary = sock_recv_raw(\n self.sock,\n data_length,\n self.timeout,\n )\n packet, _ = SPPPacket.parse(\n hdr_raw + data_plus_secondary,\n timecode_used=True,\n has_crc=self.use_crc,\n )\n if self.use_crc:\n assert packet.crc_provided == packet.crc()\n return packet.payload","def read_until(self, data):\n\n while not data in self.buff:\n self.buff += self.socket.recv(1024)\n\n pos = self.buff.find(data)\n rval = self.buff[: pos + len(data)]\n self.buff = self.buff[pos + len(data) :]\n\n return rval","def peek(self):\n if len(self) == 0:\n if self.none_for_empty:\n return None\n raise ValueError(\"Buffer is empty\")\n return self.buf[self.front]","def read_until(self, data):\n\n while not data in self.buff:\n self.buff += self.socket.recv(1024)\n \n pos = self.buff.find(data)\n rval = self.buff[:pos + len(data)]\n self.buff = self.buff[pos + len(data):]\n \n return rval","def read_until(self, data):\n\n while not data in self.buff:\n self.buff += self.socket.recv(1024)\n \n pos = self.buff.find(data)\n rval = self.buff[:pos + len(data)]\n self.buff = self.buff[pos + len(data):]\n \n return rval","def get_packet(self):\n if len(self._read_queue) == 0:\n raise NoPacketException()\n\n return self._read_queue.popleft()","def recv(self):\n self.buf = self.sock_in.recvfrom(65565)\n p = Packet(data=self.buf)\n return p","def read_pdu(self):\n\n logging.debug('Waiting for PDU...')\n\n try:\n raw_len = self._socket.recv(4)\n except socket.timeout:\n raise\n except socket.error as e:\n logging.warning(e)\n raise exceptions.ConnectionError()\n if not raw_len:\n raise exceptions.ConnectionError()\n\n try:\n length = struct.unpack('>L', raw_len)[0]\n except struct.error:\n logging.warning('Receive broken pdu... {raw_len}'.format(raw_len=repr(raw_len)))\n raise exceptions.PDUError('Broken PDU')\n\n raw_pdu = raw_len\n while len(raw_pdu) < length:\n raw_pdu += self._socket.recv(length - len(raw_pdu))\n\n logging.debug('<<{pdu} ({length} bytes) ({uid})'.format(pdu=binascii.b2a_hex(raw_pdu),\n length=len(raw_pdu),\n uid=self.uid))\n p = smpp.parse_pdu(raw_pdu, client=self)\n\n logging.debug('Read {command} PDU from {host} ({uid})'.format(command=p.command,\n host=self.host,\n uid=self.uid))\n if p.is_error():\n return p\n elif p.command in consts.STATE_SETTERS:\n self.state = consts.STATE_SETTERS[p.command]\n\n return p","def recvData(self) -> bytes:\n \n packet = self.recvPacket()\n if(packet.seq == Rudp.ackPlusOne(self.ack)):\n self.ack = Rudp.ackPlusOne(self.ack)\n self.acknowledgePacket(packet)\n return packet.payload\n else:\n return None","def peek_rear(self):\n if len(self) == 0:\n if self.none_for_empty:\n return None\n raise ValueError(\"Buffer is empty\")\n return self.buf[self.rear]","def read_until_null(self):\r\n # Check socket connection\r\n if self.connected:\r\n # Get result data from debugger engine\r\n try:\r\n while not '\\x00' in self.buffer:\r\n self.buffer += H.data_read(self.socket.recv(self.read_size))\r\n data, self.buffer = self.buffer.split('\\x00', 1)\r\n return data\r\n except:\r\n e = sys.exc_info()[1]\r\n raise ProtocolConnectionException(e)\r\n else:\r\n raise ProtocolConnectionException(\"Xdebug is not connected\")","def receive(self) -> Packet:\n try:\n return packet_from_bytes(self._socket.recvfrom(MAX_PACKET_SIZE)[0])\n except socket.timeout:\n raise racetools.errors.Timeout('timeout reached waiting for UDP packet') from None","def try_read(self):\r\n pos = self._fp.tell()\r\n try:\r\n return self.read()\r\n except RecordIO.PrematureEndOfStream as e:\r\n log.debug('Got premature end of stream [%s], skipping - %s' % (self._fp.name, e))\r\n self._fp.seek(pos)\r\n return None","def _read(self, timeout=None):\n\n # Developer notes:\n #\n # Packet data read from Serial is in this format:\n # [HDLC_FLAG_BYTE][Escaped data][HDLC_FLAG_BYTE]\n #\n # [Escaped data] is encoded so that [HDLC_FLAG_BYTE] byte\n # values cannot occur within it. When [Escaped data] has been\n # unescaped, the last 2 bytes are a 16-bit CRC of the earlier\n # part of the packet (excluding the initial HDLC_FLAG_BYTE\n # byte)\n #\n # It's also possible that the serial device was half-way\n # through transmitting a packet when this function was called\n # (app was just started). So we also neeed to handle this case:\n #\n # [Incomplete escaped data][HDLC_FLAG_BYTE][HDLC_FLAG_BYTE][Escaped data][HDLC_FLAG_BYTE]\n #\n # In this case we skip over the first (incomplete) packet.\n #\n\n if self._s.timeout != timeout and timeout != None:\n if self._debug:\n print \"Set the timeout to %s, previous one was %s\" % (timeout, self._s.timeout)\n self._s.timeout = timeout\n\n try:\n # Read bytes until we get to a HDLC_FLAG_BYTE value\n # (either the end of a packet, or the start of a new one)\n d = self._get_byte(timeout)\n ts = time.time()\n if self._debug and d != self.HDLC_FLAG_BYTE:\n print \"Skipping incomplete packet\"\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte(timeout)\n ts = time.time()\n\n # Store HDLC_FLAG_BYTE at the start of the retrieved packet\n # data:\n packet = [d]\n\n # Is the next byte also HDLC_FLAG_BYTE?\n d = self._get_byte(timeout)\n if d == self.HDLC_FLAG_BYTE:\n # Yes. This means that the previous byte was for\n # the end of the previous packet, and this byte is for\n # the start of the next packet.\n\n # Get the 2nd byte of the new packet:\n d = self._get_byte(timeout)\n ts = time.time()\n\n # We are now on the 2nd byte of the packet. Add it to\n # our retrieved packet data:\n packet.append(d)\n\n # Read bytes from serial until we read another\n # HDLC_FLAG_BYTE value (end of the current packet):\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte(timeout)\n packet.append(d)\n\n # Done reading a whole packet from serial\n if self._debug:\n print \"SimpleSerial:_read: unescaped\", packet\n\n # Decode the packet, and check CRC:\n packet = self._unescape(packet)\n\n crc = self._crc16(0, packet[1:-3])\n packet_crc = self._decode(packet[-3:-1])\n\n if crc != packet_crc:\n print \"Warning: wrong CRC! %x != %x %s\" % (crc, packet_crc, [\"%2x\" % i for i in packet])\n raise ReadCRCError\n if self._debug:\n if self._ts == None:\n self._ts = ts\n else:\n print \"Serial:_read: %.4f (%.4f) Recv:\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\n self._ts = ts\n\n # Packet was successfully retrieved, so return it in a\n # RawPacket wrapper object (but leave out the\n # HDLC_FLAG_BYTE and CRC bytes)\n return RawPacket(ts, packet[1:-3])\n except socket.timeout:\n raise ReadTimeoutError","def read(self, size=-1):\n\n if size < 0:\n raise NotImplementedError(\"Don't be greedy, that could be massive!\")\n elif size == 0:\n if self._text:\n return \"\"\n else:\n return b\"\"\n elif self._within_block_offset + size <= len(self._buffer):\n # This may leave us right at the end of a block\n # (lazy loading, don't load the next block unless we have too)\n data = self._buffer[self._within_block_offset:self._within_block_offset + size]\n self._within_block_offset += size\n assert data # Must be at least 1 byte\n return data\n else:\n # if read data overflows to next block\n # pull in rest of data in current block\n data = self._buffer[self._within_block_offset:]\n\n # decrement size so that we only pull the rest of the data\n # from next block\n size -= len(data)\n self._load_block() # will reset offsets\n\n if not self._buffer:\n return data # EOF\n\n # if there is still more to read\n elif size:\n # pull rest of data from next block\n return data + self.read(size)\n else:\n # Only needed the end of the last block\n return data","def get_data(self):\n\n data = self.socket.recv(BUFFER_SIZE)\n\n if not data:\n return None\n\n if len(data) == BUFFER_SIZE:\n while True:\n try:\n data += self.socket.recv(BUFFER_SIZE)\n except:\n break\n \n return data","def decode(self, buf=None):\n if buf is None:\n buf = self.receive()\n \n return decode_network_packet(buf)","def read_one(self, timeout=None):\n self._fill_one(timeout)\n if not self.buf and timeout != 0:\n raise EOFError(\"Connection closed\")\n res = self.buf\n self.buf = \"\"\n return res","def read(self, length=-1):\n if length == 0:\n return b''\n if length < -1:\n raise IOError(\"invalid read length: %r\" % length)\n if self.at_eof():\n raise IOError(\n \"Attempted to read from the buffer but already at the end\")\n\n if length == -1:\n return self._buf.read()\n else:\n if self._buf.tell() + length > len(self):\n raise IOError(\n \"Attempted to read %d bytes from the buffer but only %d \"\n \"remain\" % (length, len(self) - self.tell())\n )\n return self._buf.read(length)","def _get_message(self):\n if not self.opened: return None\n \n # read as much as possible\n read = 0\n try: \n chars = [b'0']\n addr = None\n logger.debug(\"%s: Socket read started...\" % \\\n self.__class__.__name__)\n while(len(chars) > 0):\n try:\n chars, addr = self._udp_socket.recvfrom(1)\n except socket.error:\n logger.debug(\"%s: ...Socket read complete.\" % \\\n self.__class__.__name__)\n break\n except socket.timeout:\n logger.debug(\"%s: ...Socket read complete.\" % \\\n self.__class__.__name__)\n break\n if len(chars) > 0:\n if addr not in self._rbuff:\n self._rbuff[addr] = []\n if sys.version_info[0] > 2:\n self._rbuff[addr] += chars\n else:\n self._rbuff[addr] += map(ord,chars)\n read += len(chars)\n else:\n logger.error(\"%s: ...Socket has been closed.\" % \\\n (self.__class__.__name__))\n self.close()\n return None\n logger.debug(\"%s: ...Socket read complete.\" % \\\n self.__class__.__name__)\n except Exception as ex:\n logger.error(\"%s: ...Socket read failed:\\n%s\" % \\\n (self.__class__.__name__,str(ex)))\n raise utils.TransportError \\\n (\"Socket Message get failed!\\n\" + str(ex))\n if read > 0 :\n logger.info(\"%s: Read %d bytes.\" % (self.__class__.__name__, read))\n \n # Check all Clients\n for addr in self._rbuff.keys():\n \n # Look for message start (SOH XX ~XX)\n disc = []\n while(len(self._rbuff[addr]) > 3 and (\n self._rbuff[addr][0] != messages.HorizonMessage.SOH or\n self._rbuff[addr][1] != 0xFF&(~self._rbuff[addr][2]) or\n self._rbuff[addr][1] == 0)):\n disc.append(self._rbuff[addr].pop(0))\n if len(disc) > 0:\n logger.info(\"%s: Discarded %d bytes:\\n%s\" % (\n self.__class__.__name__, len(disc), \n ' '.join(map(utils.hex,disc))))\n if len(self._rbuff[addr]) < 3:\n continue\n \n # Extract Expected Message Length\n length = self._rbuff[addr][1] + 3 \n \n # Look for next message start\n for i in range(1,len(self._rbuff[addr])-2):\n if self._rbuff[addr][i] == messages.HorizonMessage.SOH and \\\n self._rbuff[addr][1]==0xFF&(~self._rbuff[addr][2]) and \\\n self._rbuff[addr][1] != 0:\n if i < length:\n length = i\n break\n \n # Not all read yet\n if len(self._rbuff[addr]) < length:\n continue\n \n # Extract Message\n raw = self._rbuff[addr][0:length]\n self._rbuff[addr] = self._rbuff[addr][length:]\n logger.info(\"%s: Message of %d bytes found:\\n%s\" % (\n self.__class__.__name__, len(raw), \n ' '.join(map(utils.hex,raw))))\n msg = messages.HorizonMessage(version = self._version, \n payload_type = payloads.HorizonPayload,\n raw = raw, store_error = True)\n \n # update timestamp\n t = datetime.datetime.today()\n timestamp = t.microsecond/1000 + t.second*1000 + \\\n t.minute*60*1000 + t.hour*60*60*1000 + \\\n t.day*24*60*60*1000\n while timestamp > 4294967295: timestamp -= 4294967295\n \n # find connection\n for client in self._clients:\n if client.address == addr:\n client._last = timestamp\n client.route_message(msg)\n continue\n \n # new connection\n if len(self._clients) >= self._max:\n continue\n self._clients.append(HorizonTransport_Socket(\n sock = self._udp_socket,\n host = addr[0],\n port = addr[1],\n name = \"%s:%d\" % addr,\n store_timeout = 1,\n version = self._version))\n self._clients[-1].opened = True\n self._router.add_client(self._clients[-1])\n logger.info(\"%s: New connection to %s:%d.\" % \\\n (self.__class__.__name__,self._clients[-1].address[0],\n self._clients[-1].address[1]))\n client._last = timestamp\n client.route_message(msg)\n \n \n # update timestamp\n t = datetime.datetime.today()\n timestamp = t.microsecond/1000 + t.second*1000 + \\\n t.minute*60*1000 + t.hour*60*60*1000 + \\\n t.day*24*60*60*1000\n while timestamp > 4294967295: timestamp -= 4294967295\n \n # Connection Timeout?\n for i in range(len(self._clients),0,-1):\n last = self._clients[i-1].get_last_time()\n if ((timestamp - last >= self._rec_timeout) or\\\n (timestamp < last and 4294967295 - \\\n last + timestamp >= self._rec_timeout)):\n logger.warning(\"%s: Connection to %s timed-out!\" % \\\n (self.__class__.__name__,self._clients[i-1].name))\n self._router.remove_client(self._clients[i-1])\n self._clients[i-1].opened = False\n self._clients.remove(self._clients[i-1])\n \n return None","def baseRecv(self, buflen):\n\n # Attempts to retrieve a message from the queue initilized in bind, returns None if there are no messages\n data = r.popMessage(); \n\n # Checks to see if a message was retrieved\n if data is None:\n return None; # Not certain if this is the correct return for this...\n else:\n dest_mac = data[0];\n source_mac = data[1];\n length = data[2];\n payload = data[3];\n mac_header = dest_mac+source_mac+length;\n\n ip_header = payload[:7];\n udp_header = payload[7:9];\n message = payload[9:];\n\n # If the message is not addressed to this computer's MAC, discard the message\n if dest_mac != self.my_mac: return None;\n\n if (buflen<len(message)): return None;\n else: return message, mac_header, ip_header, udp_header;","def _get_message(self):\n read = 0\n try:\n \n # read as much as possible\n chars = [b'0']\n addr = None\n logger.debug(\"%s: Socket read started...\" % \\\n self.__class__.__name__)\n while(len(chars) > 0):\n try:\n chars, addr = self._socket.recvfrom(1)\n except socket.error:\n logger.debug(\"%s: ...Socket read complete.\" % \\\n self.__class__.__name__)\n break\n except socket.timeout:\n logger.debug(\"%s: ...Socket read complete.\" % \\\n self.__class__.__name__)\n break\n if len(chars) > 0 and (self._addr == None or addr == None or \n addr ==self._addr):\n \n # Encryption???\n if self._crypt != None:\n self._ubuff += chars\n if len(self._ubuff) >= self._crypt.block_size:\n logger.debug(\"%s: Decryption started...\" % \\\n self.__class__.__name__)\n \n # perform the decryption\n chars = self._crypt.decrypt(self._ubuff[:\n self._crypt.block_size])\n logger.debug(\"%s: ...decryption complete.\" % \\\n self.__class__.__name__)\n else:\n return None\n \n if sys.version_info[0] > 2:\n self._rbuff += chars\n else:\n self._rbuff += map(ord,chars)\n read += len(chars)\n else:\n logger.error(\"%s: ...Socket has been closed.\" % \\\n (self.__class__.__name__))\n self.close()\n return None\n logger.debug(\"%s: ...Socket read complete.\" % \\\n self.__class__.__name__)\n \n # Read Failed\n except Exception as ex:\n logger.error(\"%s: ...Socket read failed:\\n%s\" % \\\n (self.__class__.__name__,str(ex)))\n raise utils.TransportError \\\n (\"Socket Message get failed!\\n\" + str(ex))\n if read > 0 :\n logger.info(\"%s: Read %d bytes.\" % (self.__class__.__name__, read))\n \n # Look for message start (SOH XX ~XX)\n disc = []\n while(len(self._rbuff) > 3 and (\n self._rbuff[0] != messages.HorizonMessage.SOH or\n self._rbuff[1] != 0xFF&(~self._rbuff[2]) or\n self._rbuff[1] == 0)):\n disc.append(self._rbuff.pop(0))\n if len(disc) > 0:\n logger.info(\"%s: Discarded %d bytes:\\n%s\" % (\n self.__class__.__name__, len(disc), \n ' '.join(map(utils.hex,disc))))\n if len(self._rbuff) < 3:\n return None\n \n # Extract Expected Message Length\n length = self._rbuff[1] + 3 \n \n # Look for next message start\n for i in range(1,len(self._rbuff)-2):\n if self._rbuff[i] == messages.HorizonMessage.SOH and \\\n self._rbuff[1] == 0xFF&(~self._rbuff[2]) and \\\n self._rbuff[1] != 0:\n if i < length:\n length = i\n break\n \n # Not all read yet\n if len(self._rbuff) < length:\n return None\n \n # Return Message\n raw = self._rbuff[0:length]\n self._rbuff = self._rbuff[length:]\n logger.info(\"%s: Message of %d bytes found:\\n%s\" % (\n self.__class__.__name__, len(raw), \n ' '.join(map(utils.hex,raw))))\n t = datetime.datetime.today()\n timestamp = t.microsecond/1000 + t.second*1000 + \\\n t.minute*60*1000 + t.hour*60*60*1000 + \\\n t.day*24*60*60*1000\n while timestamp > 4294967295: timestamp -= 4294967295\n self._last = timestamp\n return messages.HorizonMessage(payload_type = payloads.HorizonPayload,\n raw = raw, store_error = True)","def fetch_packet_from_analyzer(self):\n\n try:\n # Read a packet from the backend, and add it to our analysis queue.\n return self.read_packet(timeout=self.PACKET_READ_TIMEOUT, blocking=False)\n\n except queue.Empty:\n # If no packets were available, return without error; we'll wait again next time.\n return None","def parseBuffer(self):\n idx = self.buf.find(DELIMITER)\n while idx > -1:\n packet = self.buf[0:idx]\n if len(packet) > 4:\n if packet[0:3] == 'DATA':\n self.factory.setData(packet[4:idx])\n else:\n print \"%s is a malformed packet, header %s not recognized\" % (packet, packet[0:3])\n else:\n print \"%s attempting to send a packet of invalid length %s\" % (packet, len(packet))\n self.buf = self.buf[(idx + len(DELIMITER)):]\n idx = self.buf.find(DELIMITER)","def _get_data(self):\n while True:\n # self.logger.debug(\"data queue size is: {}\".format(len(self._dataqueue)))\n ans = self._parser.find_first_packet(self._dataqueue[:])\n if ans:\n self._dataqueue = ans[1]\n # self.logger.debug(\"found packet of size {}\".format(len(ans[0])))\n return ans[0]\n else:\n # self.logger.debug(\"Could not find packet in received data\")\n tmp = self.conn.recv(1024)\n self._dataqueue += tmp","def recv(self):\r\n try:\r\n self.lock.acquire()\r\n length, = struct.unpack(self.HEADER_FORMAT, self.stream.read(self.HEADER_SIZE))\r\n return self.stream.read(length)\r\n finally:\r\n self.lock.release()","def parsePacket(self, packet):\n \n pcktParts = packet.split()\n \n # needs exactly 4 parts\n if len(pcktParts) != 4:\n raise PacketException(\"Packet malformed.\")\n \n direction = pcktParts[0]\n ip = pcktParts[1]\n port = pcktParts[2]\n flag = pcktParts[3]\n\n try:\n pckt = Packet(direction, ip, port, flag)\n except Exception as ex:\n eprint(\"Corrupt Packet:{0} Ignoring packet:\\n{1}\".format(ex, packet.__str__()))\n return None\n \n return pckt","def read_packet(self, blocking=True, timeout=None):\n return self.data_queue.get(blocking, timeout=timeout)","def Read(self):\n if not self._mem: return self.data\n\n logger.info(\"Read %s\" % self)\n self.data = self.hostmemmgr.read(self._mem, self.size)\n\n logger.info(\"=\" * 30, \"READ BUFFER\", \"=\" * 30)\n scapyfactory.Parse(self.data).Show()\n logger.info(\"=\" * 30, \"END READ BUFFER\", \"=\" * 30)\n\n return self.data","def get(self, length):\n if length > self.remaining():\n raise BufferError(\"Not enough bytes [remaining=%d,requested=%d]\" %\n (self.remaining(), length))\n start = self.offset\n end = self.offset + length\n self.offset += length\n return self.data[start:end]","def get_packet(self):\n msg_type = ''\n msg = ''\n try:\n msg_type = self.sock.recv(4)\n data = self.sock.recv(4)\n msg_len = int(struct.unpack('!L', data)[0])\n\n while len(msg) != msg_len:\n data = self.sock.recv(min(2048, msg_len - len(msg)))\n if not len(data):\n break\n msg += data\n\n if len(msg) != msg_len:\n return [None, None]\n\n except KeyboardInterrupt:\n raise\n except:\n traceback.print_exc()\n\n return Packet(type=msg_type, payload=json.loads(msg), handler=self.handler, connection=self)","def read(self, size=-1):\n if not self._buf:\n self._buf.append(next(self._iter, b''))\n if len(self._buf[0]) < size or size < 0:\n return self._buf.pop(0)\n block = self._buf.pop(0)\n self._buf.insert(0, block[size:])\n return block[:size]","def peek(self):\n if self.size == 0:\n return None\n return self.first.data","def read(self, msg, ans_len):\n self.write(msg)\n # Length is sum of header(2), length, check, cmd, ans_len and end\n length = 6 + ans_len\n ans = self.sock.recv(length)\n if self.__check(ans):\n return ans[4:-2]\n return None","def recv_data(self):\n data = \"\"\n size = 0\n\n try:\n size = self.sockObj.recv(4) #Get metadata\n except:\n raise Exception(\"Error while receiving data. Probably broken pipe\")\n\n if len(size) == 0:\n raise Exception(\"No data recivied. Probably broken pipe\")\n\n size = struct.unpack('>I',size)[0]\n\n data = self.sockObj.recv(size)\n\n if len(data) != size:\n raise Exception(\"Partiala data recivied\")\n\n return self.decode(data)","def read_raw_packet(self):\n\n size = 0\n\n # Read our two-byte header from the debugger...\n while not size:\n size = (self._get_next_byte() << 16) | self._get_next_byte()\n\n # ... and read our packet.\n packet = bytearray([self._get_next_byte() for _ in range(size)])\n\n # Return our packet.\n # TODO: extract and provide status flags\n # TODO: generate a timestamp on-device\n return packet, datetime.now(), None","def read_msg(self, _mid_exp):\n tStart = time.time()\n _in = self.waitforAndRead(4)\n while (time.time()-tStart) < self._timeout:\n # search for preamble\n if not _in[:-1] == self._preamble+_mid_exp:\n _in = _in[2:] + self.device.read(2)\n else:\n # if the header if found, proceed on reading ID and length\n mid = ord(_in[2])\n length = ord(_in[3])\n # read contents and checksum\n _in += self.waitforAndRead(length+1)\n\n if length == 0:\n data = ''\n else:\n data = _in[4:-1]\n\n \"\"\"If checksum is not zero, the packet is invalid.\"\"\"\n if 0xFF & (sum([ord(c) for c in _in[1:]])):\n _in = self.waitforAndRead(4)\n continue # start over from the while loop\n\n # return mid and the data\n return data\n\n else:\n return -1","def recv_frame(self):\r\n header_bytes = self._recv_strict(2)\r\n if not header_bytes:\r\n return None\r\n b1 = ord(header_bytes[0])\r\n fin = b1 >> 7 & 1\r\n rsv1 = b1 >> 6 & 1\r\n rsv2 = b1 >> 5 & 1\r\n rsv3 = b1 >> 4 & 1\r\n opcode = b1 & 0xf\r\n b2 = ord(header_bytes[1])\r\n mask = b2 >> 7 & 1\r\n length = b2 & 0x7f\r\n\r\n length_data = \"\"\r\n if length == 0x7e:\r\n length_data = self._recv_strict(2)\r\n length = struct.unpack(\"!H\", length_data)[0]\r\n elif length == 0x7f:\r\n length_data = self._recv_strict(8)\r\n length = struct.unpack(\"!Q\", length_data)[0]\r\n\r\n mask_key = \"\"\r\n if mask:\r\n mask_key = self._recv_strict(4)\r\n data = self._recv_strict(length)\r\n if traceEnabled:\r\n recieved = header_bytes + length_data + mask_key + data\r\n logger.debug(\"recv: \" + repr(recieved))\r\n\r\n if mask:\r\n data = ABNF.mask(mask_key, data)\r\n\r\n frame = ABNF(fin, rsv1, rsv2, rsv3, opcode, mask, data)\r\n return frame","def peek_byte(self):\n try:\n return self._buffer[self.pos]\n except IndexError:\n raise self._eof","def receive(self):\n raw_msglen = self.recvall(4)\n if not raw_msglen:\n return None\n msglen = stc.unpack('>I', raw_msglen)[0]\n # Read the message data\n return self.recvall(msglen)","def peek(self) -> t.Optional[Record]:\n self._buffer(1)\n if self._record_buffer:\n return self._record_buffer[0]\n return None","def _read_fixed(buf, length):\n result = buf.read(length)\n actual = len(result)\n if actual != length:\n raise EndOfMessage(False if actual == 0 else True)\n return result","def receive(self) -> [Packet, None]:\n packet_size_data = self._stream.read(2)\n if not packet_size_data:\n return None\n packet_size = int.from_bytes(packet_size_data, 'little')\n packet_data = self._stream.read(packet_size)\n return packet_from_bytes(packet_data)","def packet_read(self):\n bytes_received = 0\n \n if self.sock == NC.INVALID_SOCKET:\n return NC.ERR_NO_CONN\n \n if self.in_packet.command == 0:\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\n if errnum == 0 and len(ba_data) == 1:\n bytes_received += 1\n byte = ba_data[0]\n self.in_packet.command = byte\n \n if self.as_broker:\n if self.bridge is None and self.state == NC.CS_NEW and (byte & 0xF0) != NC.CMD_CONNECT:\n print \"RETURN ERR_PROTOCOL\"\n return NC.ERR_PROTOCOL, bytes_received\n else:\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\n return NC.ERR_SUCCESS, bytes_received\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\n return NC.ERR_CONN_LOST, bytes_received\n else:\n evt = event.EventNeterr(errnum, errmsg)\n self.push_event(evt)\n return NC.ERR_UNKNOWN, bytes_received\n \n if not self.in_packet.have_remaining:\n loop_flag = True\n while loop_flag:\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\n \n if errnum == 0 and len(ba_data) == 1: \n byte = ba_data[0]\n bytes_received += 1\n self.in_packet.remaining_count += 1\n if self.in_packet.remaining_count > 4:\n return NC.ERR_PROTOCOL, bytes_received\n \n self.in_packet.remaining_length += (byte & 127) * self.in_packet.remaining_mult\n self.in_packet.remaining_mult *= 128\n else:\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\n return NC.ERR_SUCCESS, bytes_received\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\n return NC.ERR_CONN_LOST, bytes_received\n else:\n evt = event.EventNeterr(errnum, errmsg)\n self.push_event(evt)\n return NC.ERR_UNKNOWN, bytes_received\n \n if (byte & 128) == 0:\n loop_flag = False\n \n if self.in_packet.remaining_length > 0:\n self.in_packet.payload = bytearray(self.in_packet.remaining_length)\n if self.in_packet.payload is None:\n return NC.ERR_NO_MEM, bytes_received\n self.in_packet.to_process = self.in_packet.remaining_length\n \n self.in_packet.have_remaining = True\n \n if self.in_packet.to_process > 0:\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, self.in_packet.to_process)\n if errnum == 0 and len(ba_data) > 0:\n readlen = len(ba_data)\n bytes_received += readlen\n for idx in xrange(0, readlen):\n self.in_packet.payload[self.in_packet.pos] = ba_data[idx]\n self.in_packet.pos += 1\n self.in_packet.to_process -= 1\n else:\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\n return NC.ERR_SUCCESS, bytes_received\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\n return NC.ERR_CONN_LOST, bytes_received\n else:\n evt = event.EventNeterr(errnum, errmsg)\n self.push_event(evt)\n return NC.ERR_UNKNOWN, bytes_received\n\n #all data for this packet is read\n self.in_packet.pos = 0\n \n ret = self.packet_handle()\n \n self.in_packet.packet_cleanup()\n \n self.last_msg_in = time.time()\n \n return ret, bytes_received","def read(self, max_length=None):\n if max_length is None and self._chunk is None:\n # Fast path.\n return self._queue.popleft()\n\n if max_length == 0:\n return memoryview(b\"\")\n\n if self._chunk is None:\n self._chunk = self._queue.popleft()\n self._offset = 0\n\n if max_length is None:\n result = self._chunk[self._offset:]\n else:\n result = self._chunk[self._offset:self._offset + max_length]\n\n if self._offset + len(result) == len(self._chunk):\n self._chunk = None\n else:\n self._offset += len(result)\n\n return result","def recv(self):\n msg = b''\n try:\n msg = self.socket.recv(self.BUFFER_SIZE)\n except:pass\n finally:\n return msg.decode(self.ENCODING)","def pop(self):\n if len(self) == 0:\n if self.none_for_empty:\n return None\n raise ValueError(\"Buffer is empty\")\n pt = self.buf[self.front]\n if self.rear == self.front:\n self.rear = None\n else:\n self.front = self.length - 1 if self.front == 0 else self.front - 1\n return pt","def recv(self):\n return from_bytes(self.sock.recv(512))","def readpacket(self, n):\n try:\n msg = self.sock.recv(n)\n except BaseException:\n msg = ''\n return msg","def peek(self, size=1):\n if size < -1:\n raise ValueError(\"Cannot peek backwards\")\n\n if size == 0:\n return b''\n\n if size == -1:\n size = self.remaining()\n\n peeked = b''\n with Excursion(self._buf):\n while len(peeked) < size:\n c = self._buf.read(1)\n if not c:\n break\n peeked += c\n\n return peeked","def read(self, length=None):\r\n try:\r\n if length is not None:\r\n return self._fp.read(length)\r\n return self._fp.readline()\r\n except socket.error, e:\r\n self.disconnect()\r\n if e.args and e.args[0] == errno.EAGAIN:\r\n raise ConnectionError(\"Error while reading from socket: %s\" % \\\r\n e.args[1])\r\n return ''","def _readBytes(self, len):\n return self.socket.recv(len)","def recv_protocol_message(self):\n msg = \"\"\n \n while True:\n index = self.buff.find('\\0')\n if index != -1:\n msg = self.buff[:index]\n self.buff = self.buff[index + 1:]\n break\n\n data = self.conn.recv(self.recvsize)\n if not data:\n break\n\n self.buff += data\n \n return msg","def _read_data_into_packet(self, p):\n\n length = p.length * self.disc.audio_format.bytes_per_frame\n\n if p.file_pos is None:\n # Silence, so send on null bytes to player\n p.data = '\\0' * length\n\n else:\n file_pos = p.file_pos * self.disc.audio_format.bytes_per_frame\n self.audio_file.seek(file_pos)\n\n p.data = self.audio_file.read(length)\n length -= len(p.data)\n file_pos += len(p.data)\n\n # If we didn't get all data, iterate with a timeout until\n # it's all been read or the ripping process has stopped.\n # This is not very efficient, and there's a small race\n # condition at the end of the disc, but this should be\n # very rare so keep it unoptimised for now.\n\n while length > 0 and self.is_ripping and self.is_ripping.is_set():\n time.sleep(1)\n\n self.audio_file.seek(file_pos)\n d = self.audio_file.read(length)\n\n length -= len(d)\n file_pos += len(d)\n\n p.data += d\n\n # Still didn't get all data, treat it as an exception\n if length > 0:\n raise SourceError('unexpected end of file, expected at least {0} bytes'\n .format(length))","def readCommand(self):\n while (True):\n time.sleep(1)\n # At least a package of 4 bytes (minimum)\n # [ Head | Length | Address | Data[0…N] | Check ]\n if (self._serial.inWaiting()>=4):\n # Gets only the first byte of the packet (it should be HEAD)\n packet_header = self._serial.read(1)\n if (packet_header != Ind903Packet.PACKET_HEAD):\n # the next one is the length of the packet\n packet_length_bytes = self._serial.read(1)\n packet_length = int.from_bytes(packet_length_bytes, byteorder='big')\n if (packet_length > 0):\n raw_packet = b\"\".join([packet_header, packet_length_bytes, self._serial.read(packet_length)]) \n result_packet = Ind903Packet.parsePacket(raw_packet)\n return (result_packet)","def _read_string(bs):\n result = bs.readto('0x00', bytealigned=True).bytes.decode(\"utf-8\")[:-1]\n return result if result else None","def read_until(self, s, timeout=None):\n self.read_cond(lambda x: s in x.buf, timeout)\n end = self.buf.find(s) + len(s)\n res = self.buf[:end]\n self.buf = self.buf[end:]\n return res","def read(self, l):\n\t\twhile l > len(self.buf):\n\t\t\tself.buf += self.conn.recv(4096)\n\n\t\tobuf = self.buf\n\t\tself.buf = obuf[l:]\n\t\treturn obuf[:l]","def from_ring_buffer(cls, buf):\n if len(buf) < cls.MESSAGE_LENGTH_SIZE:\n return None\n \n message_length_bytes = buf.peek(cls.MESSAGE_LENGTH_SIZE)\n message_length = int.from_bytes(message_length_bytes, byteorder='big')\n\n if message_length == 0:\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\n return cls(cls.Id.KEEP_ALIVE, 0)\n \n #print('message length {}'.format(message_length))\n if len(buf) < message_length + cls.MESSAGE_LENGTH_SIZE:\n # Incomplete header\n # Don't remove anything from the buffer, wait for next byte to get a full header\n #print('incomplete header: buffer needs {} bytes but only has {}'.format(message_length + 4,\n # len(buf)))\n return None\n\n\n # Have a full header (length + message id)\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\n message_id = cls.Id(buf.read(1)[0])\n\n payload_length = message_length - 1\n assert(len(buf) >= payload_length)\n\n payload = buf.read(payload_length)\n return cls(message_id, payload)","def read1(self, bytecount: int = -1) -> bytes:\n try:\n out = self._buffer or next(self)\n if bytecount and bytecount > 0:\n out, self._buffer = out[:bytecount], out[bytecount:]\n elif self._buffer:\n self._buffer = B''\n return out\n except StopIteration:\n return B''","def next_chunk(self):\n data = None\n if self.pos == self.data_encap.size:\n return None\n end_pos = self.pos + self.chunk_size\n end_pos = min(end_pos, self.data_encap.size)\n\n data = self.data_encap.get_chunk(self.pos, end_pos)\n self.pos = end_pos\n return data","def read_data(self):\r\n # Verify length of response data\r\n length = self.read_until_null()\r\n message = self.read_until_null()\r\n if int(length) == len(message):\r\n return message\r\n else:\r\n raise ProtocolException(\"Length mismatch encountered while reading the Xdebug message\")","def recv_raw(self) -> Dict[str, Any]:\n while True:\n try:\n packet = self.__recv_frame()\n except UnknownPacketException:\n continue\n\n # Hack for sniffing on localhost\n if packet['address']['interface'] == 'lo' and packet['address']['type'] != 4:\n continue\n\n if self.address and self.port:\n if (\n packet['ip_header']['source_address'] == self.address and\n packet['tcp_header']['source_port'] == self.port\n ):\n return packet\n if (\n packet['ip_header']['destination_address'] == self.address and\n packet['tcp_header']['destination_port'] == self.port\n ):\n return packet\n elif self.address:\n if (\n packet['ip_header']['source_address'] == self.address or\n packet['ip_header']['destination_address'] == self.address\n ):\n return packet\n elif self.port:\n if (\n packet['tcp_header']['source_port'] == self.port or\n packet['tcp_header']['destination_port'] == self.port\n ):\n return packet\n else:\n return packet","def read(self) -> Optional[bytes]:","def read(self):\r\n assert self.status in (WAIT_LEN, WAIT_MESSAGE)\r\n if self.status == WAIT_LEN:\r\n self._read_len()\r\n # go back to the main loop here for simplicity instead of\r\n # falling through, even though there is a good chance that\r\n # the message is already available\r\n elif self.status == WAIT_MESSAGE:\r\n read = self.socket.recv(self.len - len(self.message))\r\n if len(read) == 0:\r\n logging.error(\"can't read frame from socket (get %d of %d bytes)\" %\r\n (len(self.message), self.len))\r\n self.close()\r\n return\r\n self.message += read\r\n if len(self.message) == self.len:\r\n self.status = WAIT_PROCESS","def _recv(self):\n msg = b''\n try:\n count = 0\n while count < self.RECV_LIMIT:\n data = self.socket.recv(self.BUFFER_SIZE)\n \n if not data: break\n msg += data\n count+=1\n except: pass \n finally:\n return msg.decode(self.ENCODING)","def _pop_received_packet(self):\n fragments = self._receive_heap.pop_min_and_all_fragments()\n if fragments is None:\n self._attempt_disabling_looping_receive()\n else:\n last_seqnum = fragments[-1].sequence_number\n self._update_next_expected_seqnum(last_seqnum)\n self._update_next_delivered_seqnum(last_seqnum)\n payload = b''.join(f.payload for f in fragments)\n self.handler.receive_message(payload)\n\n if self._next_delivered_seqnum not in self._receive_heap:\n self._attempt_disabling_looping_receive()","def conv_bytes_to_str(self, rcv: bytes, read_until: t.Union[str, None] = None, strip: bool = True) -> t.Union[str, None]:\n\n if (rcv is None):\n return None\n\n res = rcv.decode(\"utf-8\")\n\n try:\n ret = res[0:res.index(str(read_until))] # sliced string\n if (strip):\n return ret.strip()\n else:\n return ret\n\n except (ValueError, TypeError):\n # read_until does not exist or it is None, so return the entire thing\n if (strip):\n return res.strip()\n else:\n return res","def extract_packet(_buffer):\n if len(_buffer)>=5:\n mtype=_buffer[0]\n msglen=struct.unpack('!L',_buffer[1:5])[0]\n if len(_buffer)>=msglen+1:\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\n return None,None,_buffer","def _receive_packet(self):\n report = self._serial_read(1)\n if len(report) != 1:\n self.log(\"ERROR: Didn't read back a report!\")\n report = -1\n else:\n report = report[0]\n retval = self._serial_read(1)\n if len(retval) != 1:\n self.log(\"ERROR: Didn't read back a return value!\")\n retval = -1\n else:\n retval = retval[0]\n\n return_payload_len = self._serial_read(1)\n if len(return_payload_len) != 1:\n self.log(\"ERROR: Didn't read back a return payload length!\")\n return_payload_len = 0\n else:\n return_payload_len = return_payload_len[0]\n\n if return_payload_len != 0:\n return_payload = self._serial_read(return_payload_len)\n else:\n return_payload = []\n checksum = self._serial_read(1)\n if len(checksum) != 1:\n self.log(\"ERROR: Didn't read back a checksum!\")\n checksum = -1\n else:\n checksum = checksum[0]\n\n data = self.MAGIC_HEADER + [report, retval, return_payload_len] + return_payload\n data.append(checksum)\n\n our_checksum = self.generate_checksum(data[:-1])\n if our_checksum != checksum:\n self.log(\"ERROR: Our checksum didn't calculate properly! \"\n \"(Calculated {}, expected {})\".format(our_checksum, checksum))\n return -1, checksum, []\n else:\n if self.verbose:\n self.log(\"Checksum match! ({} == {})\".format(our_checksum, checksum))\n\n return report, retval, return_payload","def read_message_from_connection(self, conn):\n raw_msglen = self._recvall(conn, 4)\n if not raw_msglen:\n return None\n\n # We are unpacking a big endian struct which includes\n # the length of the packet, struct makes sure that the header\n # which includes the length is always 4 bytes in length. '>I'\n # indicates that the struct is a unsigned integer big endian\n # CS2110 game strong\n\n msglen = struct.unpack('>I', raw_msglen)[0]\n # Read the message data\n return self._recvall(conn, msglen)","def Peek(self):\n\t\tif not self.first:\n\t\t\traise ValueError(\"Empty Queue\")\n\t\treturn self.first.data","def parse_payload(self):\n while len(self.buffer) >= 10:\n \"\"\" check magic word \"\"\"\n if self.buffer[0:2] != self.mw:\n #LogDebug(\"drop all buffer due to incorrect magic word\")\n self.buffer = b\"\" # drop entire buffer\n\n \"\"\" extract the value from length field \"\"\"\n length = struct.unpack(\"I\", self.buffer[2:6])[0] + 1\n #print \"packet len\", length, \"buffer len\", len(self.buffer)\n if len(self.buffer) < length:\n #LogDebug(\"imcompleted packet will be processed later\")\n break\n\n \"\"\" verify the packet CRC \"\"\"\n calculated_crc = struct.pack(\"I\", binascii.crc32(self.buffer[:length-4]) & 0xFFFFFFFF)\n if calculated_crc != self.buffer[length-4:length]:\n pass\n else:\n payload = self.buffer[6:length-4]\n self.payloads.append(payload)\n self.buffer = self.buffer[length:]","def flush(self):\n if not self._last_tag:\n raise ASN1Error('Nothing to flush.')\n\n remaining = self._last_tag.length - self._flush_size\n\n if not remaining:\n self._resetTag()\n return None\n\n chunk = self._buffer[:remaining]\n read_size = len(chunk)\n self._flush_size += read_size\n self._buffer = self._buffer[read_size:]\n return chunk","def _get_next_packet(self):\n offset_check = self.packet_counter * CsvAbstractReader.BUFFER_SIZE\n header = {'Range': 'bytes={}-{}'.format(offset_check, offset_check + CsvAbstractReader.BUFFER_SIZE - 1)}\n try:\n packet = self.s3_file.get_contents_as_string(headers=header, encoding='utf-8')\n return True, packet\n except:\n return False, \"\"","def _decode_str(self, buf):\n length = self._decode_vint(buf)\n result = buf.read(length)\n if len(result) != length:\n raise EndOfMessage(True)\n return result","def _getStr(self, length):\n element, n = self._buf.pop(length)\n \n if n != length:\n raise SerializationError('There is not enough data left.')\n \n return element","def read_msg(self):\n if self.state == 'connected':\n if 0 == len(self.buf):\n self.buf = self.inout.recv(Mtcpfns.TCP_MAX_PACKET)\n if 0 == (self.buf):\n self.state = 'disconnected'\n raise EOFError\n pass\n self.buf, data = Mtcpfns.unpack_msg(self.buf)\n return data\n else:\n raise IOError(\"read_msg called in state: %s.\" % self.state)","def recvPacket(self) -> Rudp.Packet:\n (packet, validity, c) = self.recv()\n if(c != self.client):\n raise Rudp.WrongClient(\"Wrong Package from \" + c)\n return packet","def read(self):\n assert self.status in (WAIT_LEN, WAIT_MESSAGE)\n\n if self.status == WAIT_LEN:\n self._read_len()\n # go back to the main loop here for simplicity instead of\n # falling through, even though there is a good chance that\n # the message is already available\n elif self.status == WAIT_MESSAGE:\n read = self.socket.recv(self.len - len(self.message))\n if len(read) == 0:\n logging.error(\"can't read frame from socket\" +\n \" (got %d of %d bytes)\" %\n (len(self.message), self.len))\n self.close()\n return\n self.message += read\n if len(self.message) == self.len:\n self._set_status(WAIT_PROCESS)","def _recv(self):\n result = self._con.receive()\n if result.startswith(Parser.NOT_OK_MSG) or len(result) == 0:\n return result\n while not result.endswith(Parser.OK_MSG + '\\n') and not result.startswith(Parser.OK_MSG):\n result += self._con.receive()\n return result","def blocking_read_elem(self):\n _, read_str = self.redis_client.blpop(self.buffer_name)\n return self.deserialize_elem(read_str)","def get_udp_packet(self, sock, size=0):\n\n pkt = ''\n while True:\n buf = ''\n try:\n buf = sock.recvfrom(64)[0]\n except socket.timeout:\n break\n if size and len(pkt) >= size:\n break\n if not buf:\n break\n pkt += buf\n return pkt","def read_bytes(self) -> bytes:\n t = self.pc\n while self.data[self.pc] != 0:\n self.pc += 1\n result = self.data[t:self.pc]\n self.pc += 1 # jump '\\0'\n return result","def readuntil(self, separator=b'\\n'):\n seplen = len(separator)\n if seplen == 0:\n raise ValueError('Separator should be at least one-byte string')\n\n if self._exception is not None:\n raise self._exception\n\n # Consume whole buffer except last bytes, which length is\n # one less than seplen. Let's check corner cases with\n # separator='SEPARATOR':\n # * we have received almost complete separator (without last\n # byte). i.e buffer='some textSEPARATO'. In this case we\n # can safely consume len(separator) - 1 bytes.\n # * last byte of buffer is first byte of separator, i.e.\n # buffer='abcdefghijklmnopqrS'. We may safely consume\n # everything except that last byte, but this require to\n # analyze bytes of buffer that match partial separator.\n # This is slow and/or require FSM. For this case our\n # implementation is not optimal, since require rescanning\n # of data that is known to not belong to separator. In\n # real world, separator will not be so long to notice\n # performance problems. Even when reading MIME-encoded\n # messages :)\n\n # `offset` is the number of bytes from the beginning of the buffer\n # where there is no occurrence of `separator`.\n offset = 0\n\n # Loop until we find `separator` in the buffer, exceed the buffer size,\n # or an EOF has happened.\n while True:\n buflen = len(self._buffer)\n\n # Check if we now have enough data in the buffer for `separator` to\n # fit.\n if buflen - offset >= seplen:\n isep = self._buffer.find(separator, offset)\n\n if isep != -1:\n # `separator` is in the buffer. `isep` will be used later\n # to retrieve the data.\n break\n\n # see upper comment for explanation.\n offset = buflen + 1 - seplen\n if offset > self._limit:\n raise LimitOverrunError(\n 'Separator is not found, and chunk exceed the limit',\n offset)\n\n # Complete message (with full separator) may be present in buffer\n # even when EOF flag is set. This may happen when the last chunk\n # adds data which makes separator be found. That's why we check for\n # EOF *ater* inspecting the buffer.\n if self._eof:\n chunk = bytes(self._buffer)\n self._buffer.clear()\n raise IncompleteReadError(chunk, None)\n\n # _wait_for_data() will resume reading if stream was paused.\n yield from self._wait_for_data('readuntil')\n\n if isep > self._limit:\n raise LimitOverrunError(\n 'Separator is found, but chunk is longer than limit', isep)\n\n chunk = self._buffer[:isep + seplen]\n del self._buffer[:isep + seplen]\n self._maybe_resume_transport()\n return bytes(chunk)","def readinto(self, buf: bytes, nack: bool = True, /) -> None:","def readinto(self, buf: bytes, nack: bool = True, /) -> None:","def recieve_data(self):\r\n try:\r\n while True:\r\n try:\r\n data, self.addr = self.sock.recvfrom(1024)\r\n return data\r\n except socket.timeout:\r\n print(\"There is no packet at all!\")\r\n break\r\n except Exception:\r\n print(\"Can't recieve a package\")","def peek(self, size, timeout=_UNSET):\n with self._recv_lock:\n if len(self.rbuf) >= size:\n return self.rbuf[:size]\n data = self.recv_size(size, timeout=timeout)\n self.rbuf = data + self.rbuf\n return data","def wait_packet(self, clazz):\n while True:\n pkt = PacketRegistry.decode(self.read())\n if isinstance(pkt, clazz):\n return pkt","def get_tcp_packet(self, sock):\n\n # the first? byte indicates the fragment status (last fragament==1?)\n # after that goes the packet size\n pkt = ''\n try:\n while True:\n psize = ''\n while True:\n psize += sock.recv(1)\n if len(psize) == 4:\n break\n p0 = psize[0]\n psize = '\\0' + psize[1:4] # remove packet number\n psize = int(struct.unpack('!I', psize)[0])\n # read actual pkt\n while True:\n pkt += sock.recv(1)\n if len(pkt) == psize:\n break\n if binascii.hexlify(p0) == '80':\n break\n except socket.timeout:\n pass\n return pkt","def _read(self, valid):\n start = self.pos\n while valid(self.char) and self.pos < self.length:\n self._read_char()\n\n return self.data[start : self.pos]","def grab_frame(self):\n with self._buflock:\n if self._buffer is None:\n return None\n buf = self._buffer.tostring()\n return buf"],"string":"[\n \"def recv_packet(self):\\r\\n self.recv_bytes()\\r\\n\\r\\n packet_length_index = 0\\r\\n \\r\\n amount_data = len(self.recvBuffer) # available amount of data to read\\r\\n \\r\\n if amount_data <= packet_length_index: # just 0's in the buffer\\r\\n return None\\r\\n\\r\\n if len(self.recvBuffer) <= packet_length_index + 2: # length not received\\r\\n return None\\r\\n \\r\\n packet_length = unpack(self.recvBuffer, packet_length_index, 'H')\\r\\n \\r\\n if packet_length > len(self.recvBuffer): # packet not fully received\\r\\n return None\\r\\n \\r\\n if packet_length == 0: # some wrong generated packet by server, inc position of reading packet length\\r\\n packet_length_index += 1\\r\\n return None\\r\\n\\r\\n\\t\\t# extract packet data\\r\\n packet = self.recvBuffer[packet_length_index:packet_length_index+packet_length]\\r\\n\\r\\n # remaining recv buffer\\r\\n self.recvBuffer = self.recvBuffer[packet_length_index + packet_length:]\\r\\n packet_length_index = 0 # next packet length should be at pos 0 again\\r\\n\\r\\n return packet\",\n \"def async_read(self):\\n self.lock.acquire()\\n\\n # append data\\n self.rx_buffer += self.interface.read()\\n\\n # ensure first byte start with 0xbc\\n if len(self.rx_buffer) > 0:\\n if self.rx_buffer[0] != 0xbc:\\n try:\\n pkt_start = self.rx_buffer.index(0xbc)\\n self.rx_buffer = self.rx_buffer[pkt_start:]\\n except ValueError:\\n self.rx_buffer = bytes()\\n\\n # check if we got a valid packet\\n if len(self.rx_buffer) >= 4:\\n pkt_size = unpack('<H', self.rx_buffer[2:4])[0]\\n # check if we got a complete packet\\n if len(self.rx_buffer) >= (pkt_size + 5):\\n # yep, parse this packet\\n packet = Packet.fromBytes(self.rx_buffer[:pkt_size+5])\\n self.rx_buffer = self.rx_buffer[pkt_size+5:]\\n self.lock.release()\\n return packet\\n\\n # otherwise, return None\\n self.lock.release()\\n return None\",\n \"def read(self):\\n packet = None\\n while packet is None:\\n packet = self.async_read()\\n return packet\",\n \"def read_pkt_line(self):\\n if self._readahead is None:\\n read = self.read\\n else:\\n read = self._readahead.read\\n self._readahead = None\\n\\n try:\\n sizestr = read(4)\\n if not sizestr:\\n raise HangupException()\\n size = int(sizestr, 16)\\n if size == 0:\\n if self.report_activity:\\n self.report_activity(4, \\\"read\\\")\\n return None\\n if self.report_activity:\\n self.report_activity(size, \\\"read\\\")\\n pkt_contents = read(size - 4)\\n except socket.error as e:\\n raise GitProtocolError(e)\\n else:\\n if len(pkt_contents) + 4 != size:\\n raise GitProtocolError(\\n \\\"Length of pkt read %04x does not match length prefix %04x\\\"\\n % (len(pkt_contents) + 4, size)\\n )\\n return pkt_contents\",\n \"def _read(self):\\n \\n try:\\n d = self._get_byte()\\n ts = time.time()\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n ts = time.time()\\n packet = [d]\\n d = self._get_byte()\\n if d == self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n ts = time.time()\\n else:\\n packet.append(d)\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n packet.append(d)\\n if self._debug == True:\\n print \\\"Serial:_read: unescaped\\\", packet\\n packet = self._unescape(packet)\\n \\n crc = self._crc16(0, packet[1:-3])\\n packet_crc = self._decode(packet[-3:-1])\\n \\n if crc != packet_crc:\\n print \\\"Warning: wrong CRC! %x != %x %s\\\" % (crc, packet_crc, [\\\"%2x\\\" % i for i in packet])\\n if self._debug:\\n if self._ts == None:\\n self._ts = ts\\n else:\\n print \\\"Serial:_read: %.4f (%.4f) Recv:\\\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\\n self._ts = ts\\n return RawPacket(ts, packet[1:-3], crc == packet_crc)\\n except socket.timeout:\\n return None\",\n \"def recv(self) -> Optional[bytes]:\\n ready, _, _ = select.select([self.socket], [], [], 0)\\n if len(ready) != 0:\\n new_bytes = self.socket.recv(self.BUFFER_SIZE)\\n self.__recv_buffer = self.__recv_buffer + new_bytes\\n return self.__parse_one_message()\",\n \"async def read_one_message(self):\\n if not self.connected:\\n return None\\n\\n try:\\n header = await self.reader.readexactly(2)\\n except SocketError as err:\\n if err.errno == errno.ECONNRESET:\\n self.log.error('Connection reset by peer')\\n self.connected = False\\n if err.errno == errno.EHOSTUNREACH:\\n self.log.error('Spa unreachable')\\n self.connected = False\\n else:\\n self.log.error('Spa socket error: {0}'.format(str(err)))\\n return None\\n except Exception as e:\\n self.log.error('Spa read failed: {0}'.format(str(e)))\\n return None\\n\\n if header[0] == M_START:\\n # header[1] is size, + checksum + M_END (we already read 2 tho!)\\n rlen = header[1]\\n else:\\n return None\\n\\n # now get the rest of the data\\n try:\\n data = await self.reader.readexactly(rlen)\\n except Exception as e:\\n self.log.errpr('Spa read failed: {0}'.format(str(e)))\\n return None\\n\\n full_data = header + data\\n # don't count M_START, M_END or CHKSUM (remember that rlen is 2 short)\\n crc = messages.Message.crc(full_data[1:rlen - 1])\\n if crc != full_data[-2]:\\n self.log.error('Message had bad CRC, discarding')\\n return None\\n\\n # self.log.error('got update: {}'.format(full_data.hex()))\\n return full_data\",\n \"def recv_bundle(self):\\n hdr_raw = sock_recv_raw(self.sock, 6, self.timeout)\\n data_length, has_secondary = SPPPacketHeader.preparse_data_length(\\n hdr_raw\\n )\\n data_plus_secondary = sock_recv_raw(\\n self.sock,\\n data_length,\\n self.timeout,\\n )\\n packet, _ = SPPPacket.parse(\\n hdr_raw + data_plus_secondary,\\n timecode_used=True,\\n has_crc=self.use_crc,\\n )\\n if self.use_crc:\\n assert packet.crc_provided == packet.crc()\\n return packet.payload\",\n \"def read_until(self, data):\\n\\n while not data in self.buff:\\n self.buff += self.socket.recv(1024)\\n\\n pos = self.buff.find(data)\\n rval = self.buff[: pos + len(data)]\\n self.buff = self.buff[pos + len(data) :]\\n\\n return rval\",\n \"def peek(self):\\n if len(self) == 0:\\n if self.none_for_empty:\\n return None\\n raise ValueError(\\\"Buffer is empty\\\")\\n return self.buf[self.front]\",\n \"def read_until(self, data):\\n\\n while not data in self.buff:\\n self.buff += self.socket.recv(1024)\\n \\n pos = self.buff.find(data)\\n rval = self.buff[:pos + len(data)]\\n self.buff = self.buff[pos + len(data):]\\n \\n return rval\",\n \"def read_until(self, data):\\n\\n while not data in self.buff:\\n self.buff += self.socket.recv(1024)\\n \\n pos = self.buff.find(data)\\n rval = self.buff[:pos + len(data)]\\n self.buff = self.buff[pos + len(data):]\\n \\n return rval\",\n \"def get_packet(self):\\n if len(self._read_queue) == 0:\\n raise NoPacketException()\\n\\n return self._read_queue.popleft()\",\n \"def recv(self):\\n self.buf = self.sock_in.recvfrom(65565)\\n p = Packet(data=self.buf)\\n return p\",\n \"def read_pdu(self):\\n\\n logging.debug('Waiting for PDU...')\\n\\n try:\\n raw_len = self._socket.recv(4)\\n except socket.timeout:\\n raise\\n except socket.error as e:\\n logging.warning(e)\\n raise exceptions.ConnectionError()\\n if not raw_len:\\n raise exceptions.ConnectionError()\\n\\n try:\\n length = struct.unpack('>L', raw_len)[0]\\n except struct.error:\\n logging.warning('Receive broken pdu... {raw_len}'.format(raw_len=repr(raw_len)))\\n raise exceptions.PDUError('Broken PDU')\\n\\n raw_pdu = raw_len\\n while len(raw_pdu) < length:\\n raw_pdu += self._socket.recv(length - len(raw_pdu))\\n\\n logging.debug('<<{pdu} ({length} bytes) ({uid})'.format(pdu=binascii.b2a_hex(raw_pdu),\\n length=len(raw_pdu),\\n uid=self.uid))\\n p = smpp.parse_pdu(raw_pdu, client=self)\\n\\n logging.debug('Read {command} PDU from {host} ({uid})'.format(command=p.command,\\n host=self.host,\\n uid=self.uid))\\n if p.is_error():\\n return p\\n elif p.command in consts.STATE_SETTERS:\\n self.state = consts.STATE_SETTERS[p.command]\\n\\n return p\",\n \"def recvData(self) -> bytes:\\n \\n packet = self.recvPacket()\\n if(packet.seq == Rudp.ackPlusOne(self.ack)):\\n self.ack = Rudp.ackPlusOne(self.ack)\\n self.acknowledgePacket(packet)\\n return packet.payload\\n else:\\n return None\",\n \"def peek_rear(self):\\n if len(self) == 0:\\n if self.none_for_empty:\\n return None\\n raise ValueError(\\\"Buffer is empty\\\")\\n return self.buf[self.rear]\",\n \"def read_until_null(self):\\r\\n # Check socket connection\\r\\n if self.connected:\\r\\n # Get result data from debugger engine\\r\\n try:\\r\\n while not '\\\\x00' in self.buffer:\\r\\n self.buffer += H.data_read(self.socket.recv(self.read_size))\\r\\n data, self.buffer = self.buffer.split('\\\\x00', 1)\\r\\n return data\\r\\n except:\\r\\n e = sys.exc_info()[1]\\r\\n raise ProtocolConnectionException(e)\\r\\n else:\\r\\n raise ProtocolConnectionException(\\\"Xdebug is not connected\\\")\",\n \"def receive(self) -> Packet:\\n try:\\n return packet_from_bytes(self._socket.recvfrom(MAX_PACKET_SIZE)[0])\\n except socket.timeout:\\n raise racetools.errors.Timeout('timeout reached waiting for UDP packet') from None\",\n \"def try_read(self):\\r\\n pos = self._fp.tell()\\r\\n try:\\r\\n return self.read()\\r\\n except RecordIO.PrematureEndOfStream as e:\\r\\n log.debug('Got premature end of stream [%s], skipping - %s' % (self._fp.name, e))\\r\\n self._fp.seek(pos)\\r\\n return None\",\n \"def _read(self, timeout=None):\\n\\n # Developer notes:\\n #\\n # Packet data read from Serial is in this format:\\n # [HDLC_FLAG_BYTE][Escaped data][HDLC_FLAG_BYTE]\\n #\\n # [Escaped data] is encoded so that [HDLC_FLAG_BYTE] byte\\n # values cannot occur within it. When [Escaped data] has been\\n # unescaped, the last 2 bytes are a 16-bit CRC of the earlier\\n # part of the packet (excluding the initial HDLC_FLAG_BYTE\\n # byte)\\n #\\n # It's also possible that the serial device was half-way\\n # through transmitting a packet when this function was called\\n # (app was just started). So we also neeed to handle this case:\\n #\\n # [Incomplete escaped data][HDLC_FLAG_BYTE][HDLC_FLAG_BYTE][Escaped data][HDLC_FLAG_BYTE]\\n #\\n # In this case we skip over the first (incomplete) packet.\\n #\\n\\n if self._s.timeout != timeout and timeout != None:\\n if self._debug:\\n print \\\"Set the timeout to %s, previous one was %s\\\" % (timeout, self._s.timeout)\\n self._s.timeout = timeout\\n\\n try:\\n # Read bytes until we get to a HDLC_FLAG_BYTE value\\n # (either the end of a packet, or the start of a new one)\\n d = self._get_byte(timeout)\\n ts = time.time()\\n if self._debug and d != self.HDLC_FLAG_BYTE:\\n print \\\"Skipping incomplete packet\\\"\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte(timeout)\\n ts = time.time()\\n\\n # Store HDLC_FLAG_BYTE at the start of the retrieved packet\\n # data:\\n packet = [d]\\n\\n # Is the next byte also HDLC_FLAG_BYTE?\\n d = self._get_byte(timeout)\\n if d == self.HDLC_FLAG_BYTE:\\n # Yes. This means that the previous byte was for\\n # the end of the previous packet, and this byte is for\\n # the start of the next packet.\\n\\n # Get the 2nd byte of the new packet:\\n d = self._get_byte(timeout)\\n ts = time.time()\\n\\n # We are now on the 2nd byte of the packet. Add it to\\n # our retrieved packet data:\\n packet.append(d)\\n\\n # Read bytes from serial until we read another\\n # HDLC_FLAG_BYTE value (end of the current packet):\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte(timeout)\\n packet.append(d)\\n\\n # Done reading a whole packet from serial\\n if self._debug:\\n print \\\"SimpleSerial:_read: unescaped\\\", packet\\n\\n # Decode the packet, and check CRC:\\n packet = self._unescape(packet)\\n\\n crc = self._crc16(0, packet[1:-3])\\n packet_crc = self._decode(packet[-3:-1])\\n\\n if crc != packet_crc:\\n print \\\"Warning: wrong CRC! %x != %x %s\\\" % (crc, packet_crc, [\\\"%2x\\\" % i for i in packet])\\n raise ReadCRCError\\n if self._debug:\\n if self._ts == None:\\n self._ts = ts\\n else:\\n print \\\"Serial:_read: %.4f (%.4f) Recv:\\\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\\n self._ts = ts\\n\\n # Packet was successfully retrieved, so return it in a\\n # RawPacket wrapper object (but leave out the\\n # HDLC_FLAG_BYTE and CRC bytes)\\n return RawPacket(ts, packet[1:-3])\\n except socket.timeout:\\n raise ReadTimeoutError\",\n \"def read(self, size=-1):\\n\\n if size < 0:\\n raise NotImplementedError(\\\"Don't be greedy, that could be massive!\\\")\\n elif size == 0:\\n if self._text:\\n return \\\"\\\"\\n else:\\n return b\\\"\\\"\\n elif self._within_block_offset + size <= len(self._buffer):\\n # This may leave us right at the end of a block\\n # (lazy loading, don't load the next block unless we have too)\\n data = self._buffer[self._within_block_offset:self._within_block_offset + size]\\n self._within_block_offset += size\\n assert data # Must be at least 1 byte\\n return data\\n else:\\n # if read data overflows to next block\\n # pull in rest of data in current block\\n data = self._buffer[self._within_block_offset:]\\n\\n # decrement size so that we only pull the rest of the data\\n # from next block\\n size -= len(data)\\n self._load_block() # will reset offsets\\n\\n if not self._buffer:\\n return data # EOF\\n\\n # if there is still more to read\\n elif size:\\n # pull rest of data from next block\\n return data + self.read(size)\\n else:\\n # Only needed the end of the last block\\n return data\",\n \"def get_data(self):\\n\\n data = self.socket.recv(BUFFER_SIZE)\\n\\n if not data:\\n return None\\n\\n if len(data) == BUFFER_SIZE:\\n while True:\\n try:\\n data += self.socket.recv(BUFFER_SIZE)\\n except:\\n break\\n \\n return data\",\n \"def decode(self, buf=None):\\n if buf is None:\\n buf = self.receive()\\n \\n return decode_network_packet(buf)\",\n \"def read_one(self, timeout=None):\\n self._fill_one(timeout)\\n if not self.buf and timeout != 0:\\n raise EOFError(\\\"Connection closed\\\")\\n res = self.buf\\n self.buf = \\\"\\\"\\n return res\",\n \"def read(self, length=-1):\\n if length == 0:\\n return b''\\n if length < -1:\\n raise IOError(\\\"invalid read length: %r\\\" % length)\\n if self.at_eof():\\n raise IOError(\\n \\\"Attempted to read from the buffer but already at the end\\\")\\n\\n if length == -1:\\n return self._buf.read()\\n else:\\n if self._buf.tell() + length > len(self):\\n raise IOError(\\n \\\"Attempted to read %d bytes from the buffer but only %d \\\"\\n \\\"remain\\\" % (length, len(self) - self.tell())\\n )\\n return self._buf.read(length)\",\n \"def _get_message(self):\\n if not self.opened: return None\\n \\n # read as much as possible\\n read = 0\\n try: \\n chars = [b'0']\\n addr = None\\n logger.debug(\\\"%s: Socket read started...\\\" % \\\\\\n self.__class__.__name__)\\n while(len(chars) > 0):\\n try:\\n chars, addr = self._udp_socket.recvfrom(1)\\n except socket.error:\\n logger.debug(\\\"%s: ...Socket read complete.\\\" % \\\\\\n self.__class__.__name__)\\n break\\n except socket.timeout:\\n logger.debug(\\\"%s: ...Socket read complete.\\\" % \\\\\\n self.__class__.__name__)\\n break\\n if len(chars) > 0:\\n if addr not in self._rbuff:\\n self._rbuff[addr] = []\\n if sys.version_info[0] > 2:\\n self._rbuff[addr] += chars\\n else:\\n self._rbuff[addr] += map(ord,chars)\\n read += len(chars)\\n else:\\n logger.error(\\\"%s: ...Socket has been closed.\\\" % \\\\\\n (self.__class__.__name__))\\n self.close()\\n return None\\n logger.debug(\\\"%s: ...Socket read complete.\\\" % \\\\\\n self.__class__.__name__)\\n except Exception as ex:\\n logger.error(\\\"%s: ...Socket read failed:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__,str(ex)))\\n raise utils.TransportError \\\\\\n (\\\"Socket Message get failed!\\\\n\\\" + str(ex))\\n if read > 0 :\\n logger.info(\\\"%s: Read %d bytes.\\\" % (self.__class__.__name__, read))\\n \\n # Check all Clients\\n for addr in self._rbuff.keys():\\n \\n # Look for message start (SOH XX ~XX)\\n disc = []\\n while(len(self._rbuff[addr]) > 3 and (\\n self._rbuff[addr][0] != messages.HorizonMessage.SOH or\\n self._rbuff[addr][1] != 0xFF&(~self._rbuff[addr][2]) or\\n self._rbuff[addr][1] == 0)):\\n disc.append(self._rbuff[addr].pop(0))\\n if len(disc) > 0:\\n logger.info(\\\"%s: Discarded %d bytes:\\\\n%s\\\" % (\\n self.__class__.__name__, len(disc), \\n ' '.join(map(utils.hex,disc))))\\n if len(self._rbuff[addr]) < 3:\\n continue\\n \\n # Extract Expected Message Length\\n length = self._rbuff[addr][1] + 3 \\n \\n # Look for next message start\\n for i in range(1,len(self._rbuff[addr])-2):\\n if self._rbuff[addr][i] == messages.HorizonMessage.SOH and \\\\\\n self._rbuff[addr][1]==0xFF&(~self._rbuff[addr][2]) and \\\\\\n self._rbuff[addr][1] != 0:\\n if i < length:\\n length = i\\n break\\n \\n # Not all read yet\\n if len(self._rbuff[addr]) < length:\\n continue\\n \\n # Extract Message\\n raw = self._rbuff[addr][0:length]\\n self._rbuff[addr] = self._rbuff[addr][length:]\\n logger.info(\\\"%s: Message of %d bytes found:\\\\n%s\\\" % (\\n self.__class__.__name__, len(raw), \\n ' '.join(map(utils.hex,raw))))\\n msg = messages.HorizonMessage(version = self._version, \\n payload_type = payloads.HorizonPayload,\\n raw = raw, store_error = True)\\n \\n # update timestamp\\n t = datetime.datetime.today()\\n timestamp = t.microsecond/1000 + t.second*1000 + \\\\\\n t.minute*60*1000 + t.hour*60*60*1000 + \\\\\\n t.day*24*60*60*1000\\n while timestamp > 4294967295: timestamp -= 4294967295\\n \\n # find connection\\n for client in self._clients:\\n if client.address == addr:\\n client._last = timestamp\\n client.route_message(msg)\\n continue\\n \\n # new connection\\n if len(self._clients) >= self._max:\\n continue\\n self._clients.append(HorizonTransport_Socket(\\n sock = self._udp_socket,\\n host = addr[0],\\n port = addr[1],\\n name = \\\"%s:%d\\\" % addr,\\n store_timeout = 1,\\n version = self._version))\\n self._clients[-1].opened = True\\n self._router.add_client(self._clients[-1])\\n logger.info(\\\"%s: New connection to %s:%d.\\\" % \\\\\\n (self.__class__.__name__,self._clients[-1].address[0],\\n self._clients[-1].address[1]))\\n client._last = timestamp\\n client.route_message(msg)\\n \\n \\n # update timestamp\\n t = datetime.datetime.today()\\n timestamp = t.microsecond/1000 + t.second*1000 + \\\\\\n t.minute*60*1000 + t.hour*60*60*1000 + \\\\\\n t.day*24*60*60*1000\\n while timestamp > 4294967295: timestamp -= 4294967295\\n \\n # Connection Timeout?\\n for i in range(len(self._clients),0,-1):\\n last = self._clients[i-1].get_last_time()\\n if ((timestamp - last >= self._rec_timeout) or\\\\\\n (timestamp < last and 4294967295 - \\\\\\n last + timestamp >= self._rec_timeout)):\\n logger.warning(\\\"%s: Connection to %s timed-out!\\\" % \\\\\\n (self.__class__.__name__,self._clients[i-1].name))\\n self._router.remove_client(self._clients[i-1])\\n self._clients[i-1].opened = False\\n self._clients.remove(self._clients[i-1])\\n \\n return None\",\n \"def baseRecv(self, buflen):\\n\\n # Attempts to retrieve a message from the queue initilized in bind, returns None if there are no messages\\n data = r.popMessage(); \\n\\n # Checks to see if a message was retrieved\\n if data is None:\\n return None; # Not certain if this is the correct return for this...\\n else:\\n dest_mac = data[0];\\n source_mac = data[1];\\n length = data[2];\\n payload = data[3];\\n mac_header = dest_mac+source_mac+length;\\n\\n ip_header = payload[:7];\\n udp_header = payload[7:9];\\n message = payload[9:];\\n\\n # If the message is not addressed to this computer's MAC, discard the message\\n if dest_mac != self.my_mac: return None;\\n\\n if (buflen<len(message)): return None;\\n else: return message, mac_header, ip_header, udp_header;\",\n \"def _get_message(self):\\n read = 0\\n try:\\n \\n # read as much as possible\\n chars = [b'0']\\n addr = None\\n logger.debug(\\\"%s: Socket read started...\\\" % \\\\\\n self.__class__.__name__)\\n while(len(chars) > 0):\\n try:\\n chars, addr = self._socket.recvfrom(1)\\n except socket.error:\\n logger.debug(\\\"%s: ...Socket read complete.\\\" % \\\\\\n self.__class__.__name__)\\n break\\n except socket.timeout:\\n logger.debug(\\\"%s: ...Socket read complete.\\\" % \\\\\\n self.__class__.__name__)\\n break\\n if len(chars) > 0 and (self._addr == None or addr == None or \\n addr ==self._addr):\\n \\n # Encryption???\\n if self._crypt != None:\\n self._ubuff += chars\\n if len(self._ubuff) >= self._crypt.block_size:\\n logger.debug(\\\"%s: Decryption started...\\\" % \\\\\\n self.__class__.__name__)\\n \\n # perform the decryption\\n chars = self._crypt.decrypt(self._ubuff[:\\n self._crypt.block_size])\\n logger.debug(\\\"%s: ...decryption complete.\\\" % \\\\\\n self.__class__.__name__)\\n else:\\n return None\\n \\n if sys.version_info[0] > 2:\\n self._rbuff += chars\\n else:\\n self._rbuff += map(ord,chars)\\n read += len(chars)\\n else:\\n logger.error(\\\"%s: ...Socket has been closed.\\\" % \\\\\\n (self.__class__.__name__))\\n self.close()\\n return None\\n logger.debug(\\\"%s: ...Socket read complete.\\\" % \\\\\\n self.__class__.__name__)\\n \\n # Read Failed\\n except Exception as ex:\\n logger.error(\\\"%s: ...Socket read failed:\\\\n%s\\\" % \\\\\\n (self.__class__.__name__,str(ex)))\\n raise utils.TransportError \\\\\\n (\\\"Socket Message get failed!\\\\n\\\" + str(ex))\\n if read > 0 :\\n logger.info(\\\"%s: Read %d bytes.\\\" % (self.__class__.__name__, read))\\n \\n # Look for message start (SOH XX ~XX)\\n disc = []\\n while(len(self._rbuff) > 3 and (\\n self._rbuff[0] != messages.HorizonMessage.SOH or\\n self._rbuff[1] != 0xFF&(~self._rbuff[2]) or\\n self._rbuff[1] == 0)):\\n disc.append(self._rbuff.pop(0))\\n if len(disc) > 0:\\n logger.info(\\\"%s: Discarded %d bytes:\\\\n%s\\\" % (\\n self.__class__.__name__, len(disc), \\n ' '.join(map(utils.hex,disc))))\\n if len(self._rbuff) < 3:\\n return None\\n \\n # Extract Expected Message Length\\n length = self._rbuff[1] + 3 \\n \\n # Look for next message start\\n for i in range(1,len(self._rbuff)-2):\\n if self._rbuff[i] == messages.HorizonMessage.SOH and \\\\\\n self._rbuff[1] == 0xFF&(~self._rbuff[2]) and \\\\\\n self._rbuff[1] != 0:\\n if i < length:\\n length = i\\n break\\n \\n # Not all read yet\\n if len(self._rbuff) < length:\\n return None\\n \\n # Return Message\\n raw = self._rbuff[0:length]\\n self._rbuff = self._rbuff[length:]\\n logger.info(\\\"%s: Message of %d bytes found:\\\\n%s\\\" % (\\n self.__class__.__name__, len(raw), \\n ' '.join(map(utils.hex,raw))))\\n t = datetime.datetime.today()\\n timestamp = t.microsecond/1000 + t.second*1000 + \\\\\\n t.minute*60*1000 + t.hour*60*60*1000 + \\\\\\n t.day*24*60*60*1000\\n while timestamp > 4294967295: timestamp -= 4294967295\\n self._last = timestamp\\n return messages.HorizonMessage(payload_type = payloads.HorizonPayload,\\n raw = raw, store_error = True)\",\n \"def fetch_packet_from_analyzer(self):\\n\\n try:\\n # Read a packet from the backend, and add it to our analysis queue.\\n return self.read_packet(timeout=self.PACKET_READ_TIMEOUT, blocking=False)\\n\\n except queue.Empty:\\n # If no packets were available, return without error; we'll wait again next time.\\n return None\",\n \"def parseBuffer(self):\\n idx = self.buf.find(DELIMITER)\\n while idx > -1:\\n packet = self.buf[0:idx]\\n if len(packet) > 4:\\n if packet[0:3] == 'DATA':\\n self.factory.setData(packet[4:idx])\\n else:\\n print \\\"%s is a malformed packet, header %s not recognized\\\" % (packet, packet[0:3])\\n else:\\n print \\\"%s attempting to send a packet of invalid length %s\\\" % (packet, len(packet))\\n self.buf = self.buf[(idx + len(DELIMITER)):]\\n idx = self.buf.find(DELIMITER)\",\n \"def _get_data(self):\\n while True:\\n # self.logger.debug(\\\"data queue size is: {}\\\".format(len(self._dataqueue)))\\n ans = self._parser.find_first_packet(self._dataqueue[:])\\n if ans:\\n self._dataqueue = ans[1]\\n # self.logger.debug(\\\"found packet of size {}\\\".format(len(ans[0])))\\n return ans[0]\\n else:\\n # self.logger.debug(\\\"Could not find packet in received data\\\")\\n tmp = self.conn.recv(1024)\\n self._dataqueue += tmp\",\n \"def recv(self):\\r\\n try:\\r\\n self.lock.acquire()\\r\\n length, = struct.unpack(self.HEADER_FORMAT, self.stream.read(self.HEADER_SIZE))\\r\\n return self.stream.read(length)\\r\\n finally:\\r\\n self.lock.release()\",\n \"def parsePacket(self, packet):\\n \\n pcktParts = packet.split()\\n \\n # needs exactly 4 parts\\n if len(pcktParts) != 4:\\n raise PacketException(\\\"Packet malformed.\\\")\\n \\n direction = pcktParts[0]\\n ip = pcktParts[1]\\n port = pcktParts[2]\\n flag = pcktParts[3]\\n\\n try:\\n pckt = Packet(direction, ip, port, flag)\\n except Exception as ex:\\n eprint(\\\"Corrupt Packet:{0} Ignoring packet:\\\\n{1}\\\".format(ex, packet.__str__()))\\n return None\\n \\n return pckt\",\n \"def read_packet(self, blocking=True, timeout=None):\\n return self.data_queue.get(blocking, timeout=timeout)\",\n \"def Read(self):\\n if not self._mem: return self.data\\n\\n logger.info(\\\"Read %s\\\" % self)\\n self.data = self.hostmemmgr.read(self._mem, self.size)\\n\\n logger.info(\\\"=\\\" * 30, \\\"READ BUFFER\\\", \\\"=\\\" * 30)\\n scapyfactory.Parse(self.data).Show()\\n logger.info(\\\"=\\\" * 30, \\\"END READ BUFFER\\\", \\\"=\\\" * 30)\\n\\n return self.data\",\n \"def get(self, length):\\n if length > self.remaining():\\n raise BufferError(\\\"Not enough bytes [remaining=%d,requested=%d]\\\" %\\n (self.remaining(), length))\\n start = self.offset\\n end = self.offset + length\\n self.offset += length\\n return self.data[start:end]\",\n \"def get_packet(self):\\n msg_type = ''\\n msg = ''\\n try:\\n msg_type = self.sock.recv(4)\\n data = self.sock.recv(4)\\n msg_len = int(struct.unpack('!L', data)[0])\\n\\n while len(msg) != msg_len:\\n data = self.sock.recv(min(2048, msg_len - len(msg)))\\n if not len(data):\\n break\\n msg += data\\n\\n if len(msg) != msg_len:\\n return [None, None]\\n\\n except KeyboardInterrupt:\\n raise\\n except:\\n traceback.print_exc()\\n\\n return Packet(type=msg_type, payload=json.loads(msg), handler=self.handler, connection=self)\",\n \"def read(self, size=-1):\\n if not self._buf:\\n self._buf.append(next(self._iter, b''))\\n if len(self._buf[0]) < size or size < 0:\\n return self._buf.pop(0)\\n block = self._buf.pop(0)\\n self._buf.insert(0, block[size:])\\n return block[:size]\",\n \"def peek(self):\\n if self.size == 0:\\n return None\\n return self.first.data\",\n \"def read(self, msg, ans_len):\\n self.write(msg)\\n # Length is sum of header(2), length, check, cmd, ans_len and end\\n length = 6 + ans_len\\n ans = self.sock.recv(length)\\n if self.__check(ans):\\n return ans[4:-2]\\n return None\",\n \"def recv_data(self):\\n data = \\\"\\\"\\n size = 0\\n\\n try:\\n size = self.sockObj.recv(4) #Get metadata\\n except:\\n raise Exception(\\\"Error while receiving data. Probably broken pipe\\\")\\n\\n if len(size) == 0:\\n raise Exception(\\\"No data recivied. Probably broken pipe\\\")\\n\\n size = struct.unpack('>I',size)[0]\\n\\n data = self.sockObj.recv(size)\\n\\n if len(data) != size:\\n raise Exception(\\\"Partiala data recivied\\\")\\n\\n return self.decode(data)\",\n \"def read_raw_packet(self):\\n\\n size = 0\\n\\n # Read our two-byte header from the debugger...\\n while not size:\\n size = (self._get_next_byte() << 16) | self._get_next_byte()\\n\\n # ... and read our packet.\\n packet = bytearray([self._get_next_byte() for _ in range(size)])\\n\\n # Return our packet.\\n # TODO: extract and provide status flags\\n # TODO: generate a timestamp on-device\\n return packet, datetime.now(), None\",\n \"def read_msg(self, _mid_exp):\\n tStart = time.time()\\n _in = self.waitforAndRead(4)\\n while (time.time()-tStart) < self._timeout:\\n # search for preamble\\n if not _in[:-1] == self._preamble+_mid_exp:\\n _in = _in[2:] + self.device.read(2)\\n else:\\n # if the header if found, proceed on reading ID and length\\n mid = ord(_in[2])\\n length = ord(_in[3])\\n # read contents and checksum\\n _in += self.waitforAndRead(length+1)\\n\\n if length == 0:\\n data = ''\\n else:\\n data = _in[4:-1]\\n\\n \\\"\\\"\\\"If checksum is not zero, the packet is invalid.\\\"\\\"\\\"\\n if 0xFF & (sum([ord(c) for c in _in[1:]])):\\n _in = self.waitforAndRead(4)\\n continue # start over from the while loop\\n\\n # return mid and the data\\n return data\\n\\n else:\\n return -1\",\n \"def recv_frame(self):\\r\\n header_bytes = self._recv_strict(2)\\r\\n if not header_bytes:\\r\\n return None\\r\\n b1 = ord(header_bytes[0])\\r\\n fin = b1 >> 7 & 1\\r\\n rsv1 = b1 >> 6 & 1\\r\\n rsv2 = b1 >> 5 & 1\\r\\n rsv3 = b1 >> 4 & 1\\r\\n opcode = b1 & 0xf\\r\\n b2 = ord(header_bytes[1])\\r\\n mask = b2 >> 7 & 1\\r\\n length = b2 & 0x7f\\r\\n\\r\\n length_data = \\\"\\\"\\r\\n if length == 0x7e:\\r\\n length_data = self._recv_strict(2)\\r\\n length = struct.unpack(\\\"!H\\\", length_data)[0]\\r\\n elif length == 0x7f:\\r\\n length_data = self._recv_strict(8)\\r\\n length = struct.unpack(\\\"!Q\\\", length_data)[0]\\r\\n\\r\\n mask_key = \\\"\\\"\\r\\n if mask:\\r\\n mask_key = self._recv_strict(4)\\r\\n data = self._recv_strict(length)\\r\\n if traceEnabled:\\r\\n recieved = header_bytes + length_data + mask_key + data\\r\\n logger.debug(\\\"recv: \\\" + repr(recieved))\\r\\n\\r\\n if mask:\\r\\n data = ABNF.mask(mask_key, data)\\r\\n\\r\\n frame = ABNF(fin, rsv1, rsv2, rsv3, opcode, mask, data)\\r\\n return frame\",\n \"def peek_byte(self):\\n try:\\n return self._buffer[self.pos]\\n except IndexError:\\n raise self._eof\",\n \"def receive(self):\\n raw_msglen = self.recvall(4)\\n if not raw_msglen:\\n return None\\n msglen = stc.unpack('>I', raw_msglen)[0]\\n # Read the message data\\n return self.recvall(msglen)\",\n \"def peek(self) -> t.Optional[Record]:\\n self._buffer(1)\\n if self._record_buffer:\\n return self._record_buffer[0]\\n return None\",\n \"def _read_fixed(buf, length):\\n result = buf.read(length)\\n actual = len(result)\\n if actual != length:\\n raise EndOfMessage(False if actual == 0 else True)\\n return result\",\n \"def receive(self) -> [Packet, None]:\\n packet_size_data = self._stream.read(2)\\n if not packet_size_data:\\n return None\\n packet_size = int.from_bytes(packet_size_data, 'little')\\n packet_data = self._stream.read(packet_size)\\n return packet_from_bytes(packet_data)\",\n \"def packet_read(self):\\n bytes_received = 0\\n \\n if self.sock == NC.INVALID_SOCKET:\\n return NC.ERR_NO_CONN\\n \\n if self.in_packet.command == 0:\\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\\n if errnum == 0 and len(ba_data) == 1:\\n bytes_received += 1\\n byte = ba_data[0]\\n self.in_packet.command = byte\\n \\n if self.as_broker:\\n if self.bridge is None and self.state == NC.CS_NEW and (byte & 0xF0) != NC.CMD_CONNECT:\\n print \\\"RETURN ERR_PROTOCOL\\\"\\n return NC.ERR_PROTOCOL, bytes_received\\n else:\\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\\n return NC.ERR_SUCCESS, bytes_received\\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\\n return NC.ERR_CONN_LOST, bytes_received\\n else:\\n evt = event.EventNeterr(errnum, errmsg)\\n self.push_event(evt)\\n return NC.ERR_UNKNOWN, bytes_received\\n \\n if not self.in_packet.have_remaining:\\n loop_flag = True\\n while loop_flag:\\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\\n \\n if errnum == 0 and len(ba_data) == 1: \\n byte = ba_data[0]\\n bytes_received += 1\\n self.in_packet.remaining_count += 1\\n if self.in_packet.remaining_count > 4:\\n return NC.ERR_PROTOCOL, bytes_received\\n \\n self.in_packet.remaining_length += (byte & 127) * self.in_packet.remaining_mult\\n self.in_packet.remaining_mult *= 128\\n else:\\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\\n return NC.ERR_SUCCESS, bytes_received\\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\\n return NC.ERR_CONN_LOST, bytes_received\\n else:\\n evt = event.EventNeterr(errnum, errmsg)\\n self.push_event(evt)\\n return NC.ERR_UNKNOWN, bytes_received\\n \\n if (byte & 128) == 0:\\n loop_flag = False\\n \\n if self.in_packet.remaining_length > 0:\\n self.in_packet.payload = bytearray(self.in_packet.remaining_length)\\n if self.in_packet.payload is None:\\n return NC.ERR_NO_MEM, bytes_received\\n self.in_packet.to_process = self.in_packet.remaining_length\\n \\n self.in_packet.have_remaining = True\\n \\n if self.in_packet.to_process > 0:\\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, self.in_packet.to_process)\\n if errnum == 0 and len(ba_data) > 0:\\n readlen = len(ba_data)\\n bytes_received += readlen\\n for idx in xrange(0, readlen):\\n self.in_packet.payload[self.in_packet.pos] = ba_data[idx]\\n self.in_packet.pos += 1\\n self.in_packet.to_process -= 1\\n else:\\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\\n return NC.ERR_SUCCESS, bytes_received\\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\\n return NC.ERR_CONN_LOST, bytes_received\\n else:\\n evt = event.EventNeterr(errnum, errmsg)\\n self.push_event(evt)\\n return NC.ERR_UNKNOWN, bytes_received\\n\\n #all data for this packet is read\\n self.in_packet.pos = 0\\n \\n ret = self.packet_handle()\\n \\n self.in_packet.packet_cleanup()\\n \\n self.last_msg_in = time.time()\\n \\n return ret, bytes_received\",\n \"def read(self, max_length=None):\\n if max_length is None and self._chunk is None:\\n # Fast path.\\n return self._queue.popleft()\\n\\n if max_length == 0:\\n return memoryview(b\\\"\\\")\\n\\n if self._chunk is None:\\n self._chunk = self._queue.popleft()\\n self._offset = 0\\n\\n if max_length is None:\\n result = self._chunk[self._offset:]\\n else:\\n result = self._chunk[self._offset:self._offset + max_length]\\n\\n if self._offset + len(result) == len(self._chunk):\\n self._chunk = None\\n else:\\n self._offset += len(result)\\n\\n return result\",\n \"def recv(self):\\n msg = b''\\n try:\\n msg = self.socket.recv(self.BUFFER_SIZE)\\n except:pass\\n finally:\\n return msg.decode(self.ENCODING)\",\n \"def pop(self):\\n if len(self) == 0:\\n if self.none_for_empty:\\n return None\\n raise ValueError(\\\"Buffer is empty\\\")\\n pt = self.buf[self.front]\\n if self.rear == self.front:\\n self.rear = None\\n else:\\n self.front = self.length - 1 if self.front == 0 else self.front - 1\\n return pt\",\n \"def recv(self):\\n return from_bytes(self.sock.recv(512))\",\n \"def readpacket(self, n):\\n try:\\n msg = self.sock.recv(n)\\n except BaseException:\\n msg = ''\\n return msg\",\n \"def peek(self, size=1):\\n if size < -1:\\n raise ValueError(\\\"Cannot peek backwards\\\")\\n\\n if size == 0:\\n return b''\\n\\n if size == -1:\\n size = self.remaining()\\n\\n peeked = b''\\n with Excursion(self._buf):\\n while len(peeked) < size:\\n c = self._buf.read(1)\\n if not c:\\n break\\n peeked += c\\n\\n return peeked\",\n \"def read(self, length=None):\\r\\n try:\\r\\n if length is not None:\\r\\n return self._fp.read(length)\\r\\n return self._fp.readline()\\r\\n except socket.error, e:\\r\\n self.disconnect()\\r\\n if e.args and e.args[0] == errno.EAGAIN:\\r\\n raise ConnectionError(\\\"Error while reading from socket: %s\\\" % \\\\\\r\\n e.args[1])\\r\\n return ''\",\n \"def _readBytes(self, len):\\n return self.socket.recv(len)\",\n \"def recv_protocol_message(self):\\n msg = \\\"\\\"\\n \\n while True:\\n index = self.buff.find('\\\\0')\\n if index != -1:\\n msg = self.buff[:index]\\n self.buff = self.buff[index + 1:]\\n break\\n\\n data = self.conn.recv(self.recvsize)\\n if not data:\\n break\\n\\n self.buff += data\\n \\n return msg\",\n \"def _read_data_into_packet(self, p):\\n\\n length = p.length * self.disc.audio_format.bytes_per_frame\\n\\n if p.file_pos is None:\\n # Silence, so send on null bytes to player\\n p.data = '\\\\0' * length\\n\\n else:\\n file_pos = p.file_pos * self.disc.audio_format.bytes_per_frame\\n self.audio_file.seek(file_pos)\\n\\n p.data = self.audio_file.read(length)\\n length -= len(p.data)\\n file_pos += len(p.data)\\n\\n # If we didn't get all data, iterate with a timeout until\\n # it's all been read or the ripping process has stopped.\\n # This is not very efficient, and there's a small race\\n # condition at the end of the disc, but this should be\\n # very rare so keep it unoptimised for now.\\n\\n while length > 0 and self.is_ripping and self.is_ripping.is_set():\\n time.sleep(1)\\n\\n self.audio_file.seek(file_pos)\\n d = self.audio_file.read(length)\\n\\n length -= len(d)\\n file_pos += len(d)\\n\\n p.data += d\\n\\n # Still didn't get all data, treat it as an exception\\n if length > 0:\\n raise SourceError('unexpected end of file, expected at least {0} bytes'\\n .format(length))\",\n \"def readCommand(self):\\n while (True):\\n time.sleep(1)\\n # At least a package of 4 bytes (minimum)\\n # [ Head | Length | Address | Data[0…N] | Check ]\\n if (self._serial.inWaiting()>=4):\\n # Gets only the first byte of the packet (it should be HEAD)\\n packet_header = self._serial.read(1)\\n if (packet_header != Ind903Packet.PACKET_HEAD):\\n # the next one is the length of the packet\\n packet_length_bytes = self._serial.read(1)\\n packet_length = int.from_bytes(packet_length_bytes, byteorder='big')\\n if (packet_length > 0):\\n raw_packet = b\\\"\\\".join([packet_header, packet_length_bytes, self._serial.read(packet_length)]) \\n result_packet = Ind903Packet.parsePacket(raw_packet)\\n return (result_packet)\",\n \"def _read_string(bs):\\n result = bs.readto('0x00', bytealigned=True).bytes.decode(\\\"utf-8\\\")[:-1]\\n return result if result else None\",\n \"def read_until(self, s, timeout=None):\\n self.read_cond(lambda x: s in x.buf, timeout)\\n end = self.buf.find(s) + len(s)\\n res = self.buf[:end]\\n self.buf = self.buf[end:]\\n return res\",\n \"def read(self, l):\\n\\t\\twhile l > len(self.buf):\\n\\t\\t\\tself.buf += self.conn.recv(4096)\\n\\n\\t\\tobuf = self.buf\\n\\t\\tself.buf = obuf[l:]\\n\\t\\treturn obuf[:l]\",\n \"def from_ring_buffer(cls, buf):\\n if len(buf) < cls.MESSAGE_LENGTH_SIZE:\\n return None\\n \\n message_length_bytes = buf.peek(cls.MESSAGE_LENGTH_SIZE)\\n message_length = int.from_bytes(message_length_bytes, byteorder='big')\\n\\n if message_length == 0:\\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\\n return cls(cls.Id.KEEP_ALIVE, 0)\\n \\n #print('message length {}'.format(message_length))\\n if len(buf) < message_length + cls.MESSAGE_LENGTH_SIZE:\\n # Incomplete header\\n # Don't remove anything from the buffer, wait for next byte to get a full header\\n #print('incomplete header: buffer needs {} bytes but only has {}'.format(message_length + 4,\\n # len(buf)))\\n return None\\n\\n\\n # Have a full header (length + message id)\\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\\n message_id = cls.Id(buf.read(1)[0])\\n\\n payload_length = message_length - 1\\n assert(len(buf) >= payload_length)\\n\\n payload = buf.read(payload_length)\\n return cls(message_id, payload)\",\n \"def read1(self, bytecount: int = -1) -> bytes:\\n try:\\n out = self._buffer or next(self)\\n if bytecount and bytecount > 0:\\n out, self._buffer = out[:bytecount], out[bytecount:]\\n elif self._buffer:\\n self._buffer = B''\\n return out\\n except StopIteration:\\n return B''\",\n \"def next_chunk(self):\\n data = None\\n if self.pos == self.data_encap.size:\\n return None\\n end_pos = self.pos + self.chunk_size\\n end_pos = min(end_pos, self.data_encap.size)\\n\\n data = self.data_encap.get_chunk(self.pos, end_pos)\\n self.pos = end_pos\\n return data\",\n \"def read_data(self):\\r\\n # Verify length of response data\\r\\n length = self.read_until_null()\\r\\n message = self.read_until_null()\\r\\n if int(length) == len(message):\\r\\n return message\\r\\n else:\\r\\n raise ProtocolException(\\\"Length mismatch encountered while reading the Xdebug message\\\")\",\n \"def recv_raw(self) -> Dict[str, Any]:\\n while True:\\n try:\\n packet = self.__recv_frame()\\n except UnknownPacketException:\\n continue\\n\\n # Hack for sniffing on localhost\\n if packet['address']['interface'] == 'lo' and packet['address']['type'] != 4:\\n continue\\n\\n if self.address and self.port:\\n if (\\n packet['ip_header']['source_address'] == self.address and\\n packet['tcp_header']['source_port'] == self.port\\n ):\\n return packet\\n if (\\n packet['ip_header']['destination_address'] == self.address and\\n packet['tcp_header']['destination_port'] == self.port\\n ):\\n return packet\\n elif self.address:\\n if (\\n packet['ip_header']['source_address'] == self.address or\\n packet['ip_header']['destination_address'] == self.address\\n ):\\n return packet\\n elif self.port:\\n if (\\n packet['tcp_header']['source_port'] == self.port or\\n packet['tcp_header']['destination_port'] == self.port\\n ):\\n return packet\\n else:\\n return packet\",\n \"def read(self) -> Optional[bytes]:\",\n \"def read(self):\\r\\n assert self.status in (WAIT_LEN, WAIT_MESSAGE)\\r\\n if self.status == WAIT_LEN:\\r\\n self._read_len()\\r\\n # go back to the main loop here for simplicity instead of\\r\\n # falling through, even though there is a good chance that\\r\\n # the message is already available\\r\\n elif self.status == WAIT_MESSAGE:\\r\\n read = self.socket.recv(self.len - len(self.message))\\r\\n if len(read) == 0:\\r\\n logging.error(\\\"can't read frame from socket (get %d of %d bytes)\\\" %\\r\\n (len(self.message), self.len))\\r\\n self.close()\\r\\n return\\r\\n self.message += read\\r\\n if len(self.message) == self.len:\\r\\n self.status = WAIT_PROCESS\",\n \"def _recv(self):\\n msg = b''\\n try:\\n count = 0\\n while count < self.RECV_LIMIT:\\n data = self.socket.recv(self.BUFFER_SIZE)\\n \\n if not data: break\\n msg += data\\n count+=1\\n except: pass \\n finally:\\n return msg.decode(self.ENCODING)\",\n \"def _pop_received_packet(self):\\n fragments = self._receive_heap.pop_min_and_all_fragments()\\n if fragments is None:\\n self._attempt_disabling_looping_receive()\\n else:\\n last_seqnum = fragments[-1].sequence_number\\n self._update_next_expected_seqnum(last_seqnum)\\n self._update_next_delivered_seqnum(last_seqnum)\\n payload = b''.join(f.payload for f in fragments)\\n self.handler.receive_message(payload)\\n\\n if self._next_delivered_seqnum not in self._receive_heap:\\n self._attempt_disabling_looping_receive()\",\n \"def conv_bytes_to_str(self, rcv: bytes, read_until: t.Union[str, None] = None, strip: bool = True) -> t.Union[str, None]:\\n\\n if (rcv is None):\\n return None\\n\\n res = rcv.decode(\\\"utf-8\\\")\\n\\n try:\\n ret = res[0:res.index(str(read_until))] # sliced string\\n if (strip):\\n return ret.strip()\\n else:\\n return ret\\n\\n except (ValueError, TypeError):\\n # read_until does not exist or it is None, so return the entire thing\\n if (strip):\\n return res.strip()\\n else:\\n return res\",\n \"def extract_packet(_buffer):\\n if len(_buffer)>=5:\\n mtype=_buffer[0]\\n msglen=struct.unpack('!L',_buffer[1:5])[0]\\n if len(_buffer)>=msglen+1:\\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\\n return None,None,_buffer\",\n \"def _receive_packet(self):\\n report = self._serial_read(1)\\n if len(report) != 1:\\n self.log(\\\"ERROR: Didn't read back a report!\\\")\\n report = -1\\n else:\\n report = report[0]\\n retval = self._serial_read(1)\\n if len(retval) != 1:\\n self.log(\\\"ERROR: Didn't read back a return value!\\\")\\n retval = -1\\n else:\\n retval = retval[0]\\n\\n return_payload_len = self._serial_read(1)\\n if len(return_payload_len) != 1:\\n self.log(\\\"ERROR: Didn't read back a return payload length!\\\")\\n return_payload_len = 0\\n else:\\n return_payload_len = return_payload_len[0]\\n\\n if return_payload_len != 0:\\n return_payload = self._serial_read(return_payload_len)\\n else:\\n return_payload = []\\n checksum = self._serial_read(1)\\n if len(checksum) != 1:\\n self.log(\\\"ERROR: Didn't read back a checksum!\\\")\\n checksum = -1\\n else:\\n checksum = checksum[0]\\n\\n data = self.MAGIC_HEADER + [report, retval, return_payload_len] + return_payload\\n data.append(checksum)\\n\\n our_checksum = self.generate_checksum(data[:-1])\\n if our_checksum != checksum:\\n self.log(\\\"ERROR: Our checksum didn't calculate properly! \\\"\\n \\\"(Calculated {}, expected {})\\\".format(our_checksum, checksum))\\n return -1, checksum, []\\n else:\\n if self.verbose:\\n self.log(\\\"Checksum match! ({} == {})\\\".format(our_checksum, checksum))\\n\\n return report, retval, return_payload\",\n \"def read_message_from_connection(self, conn):\\n raw_msglen = self._recvall(conn, 4)\\n if not raw_msglen:\\n return None\\n\\n # We are unpacking a big endian struct which includes\\n # the length of the packet, struct makes sure that the header\\n # which includes the length is always 4 bytes in length. '>I'\\n # indicates that the struct is a unsigned integer big endian\\n # CS2110 game strong\\n\\n msglen = struct.unpack('>I', raw_msglen)[0]\\n # Read the message data\\n return self._recvall(conn, msglen)\",\n \"def Peek(self):\\n\\t\\tif not self.first:\\n\\t\\t\\traise ValueError(\\\"Empty Queue\\\")\\n\\t\\treturn self.first.data\",\n \"def parse_payload(self):\\n while len(self.buffer) >= 10:\\n \\\"\\\"\\\" check magic word \\\"\\\"\\\"\\n if self.buffer[0:2] != self.mw:\\n #LogDebug(\\\"drop all buffer due to incorrect magic word\\\")\\n self.buffer = b\\\"\\\" # drop entire buffer\\n\\n \\\"\\\"\\\" extract the value from length field \\\"\\\"\\\"\\n length = struct.unpack(\\\"I\\\", self.buffer[2:6])[0] + 1\\n #print \\\"packet len\\\", length, \\\"buffer len\\\", len(self.buffer)\\n if len(self.buffer) < length:\\n #LogDebug(\\\"imcompleted packet will be processed later\\\")\\n break\\n\\n \\\"\\\"\\\" verify the packet CRC \\\"\\\"\\\"\\n calculated_crc = struct.pack(\\\"I\\\", binascii.crc32(self.buffer[:length-4]) & 0xFFFFFFFF)\\n if calculated_crc != self.buffer[length-4:length]:\\n pass\\n else:\\n payload = self.buffer[6:length-4]\\n self.payloads.append(payload)\\n self.buffer = self.buffer[length:]\",\n \"def flush(self):\\n if not self._last_tag:\\n raise ASN1Error('Nothing to flush.')\\n\\n remaining = self._last_tag.length - self._flush_size\\n\\n if not remaining:\\n self._resetTag()\\n return None\\n\\n chunk = self._buffer[:remaining]\\n read_size = len(chunk)\\n self._flush_size += read_size\\n self._buffer = self._buffer[read_size:]\\n return chunk\",\n \"def _get_next_packet(self):\\n offset_check = self.packet_counter * CsvAbstractReader.BUFFER_SIZE\\n header = {'Range': 'bytes={}-{}'.format(offset_check, offset_check + CsvAbstractReader.BUFFER_SIZE - 1)}\\n try:\\n packet = self.s3_file.get_contents_as_string(headers=header, encoding='utf-8')\\n return True, packet\\n except:\\n return False, \\\"\\\"\",\n \"def _decode_str(self, buf):\\n length = self._decode_vint(buf)\\n result = buf.read(length)\\n if len(result) != length:\\n raise EndOfMessage(True)\\n return result\",\n \"def _getStr(self, length):\\n element, n = self._buf.pop(length)\\n \\n if n != length:\\n raise SerializationError('There is not enough data left.')\\n \\n return element\",\n \"def read_msg(self):\\n if self.state == 'connected':\\n if 0 == len(self.buf):\\n self.buf = self.inout.recv(Mtcpfns.TCP_MAX_PACKET)\\n if 0 == (self.buf):\\n self.state = 'disconnected'\\n raise EOFError\\n pass\\n self.buf, data = Mtcpfns.unpack_msg(self.buf)\\n return data\\n else:\\n raise IOError(\\\"read_msg called in state: %s.\\\" % self.state)\",\n \"def recvPacket(self) -> Rudp.Packet:\\n (packet, validity, c) = self.recv()\\n if(c != self.client):\\n raise Rudp.WrongClient(\\\"Wrong Package from \\\" + c)\\n return packet\",\n \"def read(self):\\n assert self.status in (WAIT_LEN, WAIT_MESSAGE)\\n\\n if self.status == WAIT_LEN:\\n self._read_len()\\n # go back to the main loop here for simplicity instead of\\n # falling through, even though there is a good chance that\\n # the message is already available\\n elif self.status == WAIT_MESSAGE:\\n read = self.socket.recv(self.len - len(self.message))\\n if len(read) == 0:\\n logging.error(\\\"can't read frame from socket\\\" +\\n \\\" (got %d of %d bytes)\\\" %\\n (len(self.message), self.len))\\n self.close()\\n return\\n self.message += read\\n if len(self.message) == self.len:\\n self._set_status(WAIT_PROCESS)\",\n \"def _recv(self):\\n result = self._con.receive()\\n if result.startswith(Parser.NOT_OK_MSG) or len(result) == 0:\\n return result\\n while not result.endswith(Parser.OK_MSG + '\\\\n') and not result.startswith(Parser.OK_MSG):\\n result += self._con.receive()\\n return result\",\n \"def blocking_read_elem(self):\\n _, read_str = self.redis_client.blpop(self.buffer_name)\\n return self.deserialize_elem(read_str)\",\n \"def get_udp_packet(self, sock, size=0):\\n\\n pkt = ''\\n while True:\\n buf = ''\\n try:\\n buf = sock.recvfrom(64)[0]\\n except socket.timeout:\\n break\\n if size and len(pkt) >= size:\\n break\\n if not buf:\\n break\\n pkt += buf\\n return pkt\",\n \"def read_bytes(self) -> bytes:\\n t = self.pc\\n while self.data[self.pc] != 0:\\n self.pc += 1\\n result = self.data[t:self.pc]\\n self.pc += 1 # jump '\\\\0'\\n return result\",\n \"def readuntil(self, separator=b'\\\\n'):\\n seplen = len(separator)\\n if seplen == 0:\\n raise ValueError('Separator should be at least one-byte string')\\n\\n if self._exception is not None:\\n raise self._exception\\n\\n # Consume whole buffer except last bytes, which length is\\n # one less than seplen. Let's check corner cases with\\n # separator='SEPARATOR':\\n # * we have received almost complete separator (without last\\n # byte). i.e buffer='some textSEPARATO'. In this case we\\n # can safely consume len(separator) - 1 bytes.\\n # * last byte of buffer is first byte of separator, i.e.\\n # buffer='abcdefghijklmnopqrS'. We may safely consume\\n # everything except that last byte, but this require to\\n # analyze bytes of buffer that match partial separator.\\n # This is slow and/or require FSM. For this case our\\n # implementation is not optimal, since require rescanning\\n # of data that is known to not belong to separator. In\\n # real world, separator will not be so long to notice\\n # performance problems. Even when reading MIME-encoded\\n # messages :)\\n\\n # `offset` is the number of bytes from the beginning of the buffer\\n # where there is no occurrence of `separator`.\\n offset = 0\\n\\n # Loop until we find `separator` in the buffer, exceed the buffer size,\\n # or an EOF has happened.\\n while True:\\n buflen = len(self._buffer)\\n\\n # Check if we now have enough data in the buffer for `separator` to\\n # fit.\\n if buflen - offset >= seplen:\\n isep = self._buffer.find(separator, offset)\\n\\n if isep != -1:\\n # `separator` is in the buffer. `isep` will be used later\\n # to retrieve the data.\\n break\\n\\n # see upper comment for explanation.\\n offset = buflen + 1 - seplen\\n if offset > self._limit:\\n raise LimitOverrunError(\\n 'Separator is not found, and chunk exceed the limit',\\n offset)\\n\\n # Complete message (with full separator) may be present in buffer\\n # even when EOF flag is set. This may happen when the last chunk\\n # adds data which makes separator be found. That's why we check for\\n # EOF *ater* inspecting the buffer.\\n if self._eof:\\n chunk = bytes(self._buffer)\\n self._buffer.clear()\\n raise IncompleteReadError(chunk, None)\\n\\n # _wait_for_data() will resume reading if stream was paused.\\n yield from self._wait_for_data('readuntil')\\n\\n if isep > self._limit:\\n raise LimitOverrunError(\\n 'Separator is found, but chunk is longer than limit', isep)\\n\\n chunk = self._buffer[:isep + seplen]\\n del self._buffer[:isep + seplen]\\n self._maybe_resume_transport()\\n return bytes(chunk)\",\n \"def readinto(self, buf: bytes, nack: bool = True, /) -> None:\",\n \"def readinto(self, buf: bytes, nack: bool = True, /) -> None:\",\n \"def recieve_data(self):\\r\\n try:\\r\\n while True:\\r\\n try:\\r\\n data, self.addr = self.sock.recvfrom(1024)\\r\\n return data\\r\\n except socket.timeout:\\r\\n print(\\\"There is no packet at all!\\\")\\r\\n break\\r\\n except Exception:\\r\\n print(\\\"Can't recieve a package\\\")\",\n \"def peek(self, size, timeout=_UNSET):\\n with self._recv_lock:\\n if len(self.rbuf) >= size:\\n return self.rbuf[:size]\\n data = self.recv_size(size, timeout=timeout)\\n self.rbuf = data + self.rbuf\\n return data\",\n \"def wait_packet(self, clazz):\\n while True:\\n pkt = PacketRegistry.decode(self.read())\\n if isinstance(pkt, clazz):\\n return pkt\",\n \"def get_tcp_packet(self, sock):\\n\\n # the first? byte indicates the fragment status (last fragament==1?)\\n # after that goes the packet size\\n pkt = ''\\n try:\\n while True:\\n psize = ''\\n while True:\\n psize += sock.recv(1)\\n if len(psize) == 4:\\n break\\n p0 = psize[0]\\n psize = '\\\\0' + psize[1:4] # remove packet number\\n psize = int(struct.unpack('!I', psize)[0])\\n # read actual pkt\\n while True:\\n pkt += sock.recv(1)\\n if len(pkt) == psize:\\n break\\n if binascii.hexlify(p0) == '80':\\n break\\n except socket.timeout:\\n pass\\n return pkt\",\n \"def _read(self, valid):\\n start = self.pos\\n while valid(self.char) and self.pos < self.length:\\n self._read_char()\\n\\n return self.data[start : self.pos]\",\n \"def grab_frame(self):\\n with self._buflock:\\n if self._buffer is None:\\n return None\\n buf = self._buffer.tostring()\\n return buf\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7178027","0.67700803","0.6706211","0.66330725","0.645455","0.6333611","0.62824416","0.6110825","0.6101818","0.60921735","0.60903865","0.60903865","0.6066746","0.60435694","0.60384893","0.6006668","0.5956292","0.5912572","0.5874441","0.5867553","0.5858808","0.58582914","0.5854895","0.5812866","0.58109945","0.57881314","0.575981","0.57438415","0.5738988","0.5704263","0.56953937","0.5694752","0.56864864","0.56843036","0.56685793","0.5666039","0.5652177","0.5646462","0.56227624","0.56211823","0.5599073","0.5587713","0.5582525","0.558239","0.5577765","0.55588186","0.55574304","0.55554605","0.5552167","0.55490154","0.5528244","0.5527157","0.552386","0.552005","0.55182743","0.5515073","0.55099446","0.5503171","0.5469659","0.5465669","0.5461551","0.5458697","0.545418","0.5453942","0.54529583","0.5443841","0.54433334","0.5437667","0.5437597","0.543441","0.54225993","0.54160476","0.54033524","0.5400669","0.539828","0.5390946","0.53849113","0.5369697","0.53656334","0.53579855","0.53536093","0.5346797","0.5344436","0.5329234","0.53264576","0.5318775","0.53185636","0.5314316","0.53142315","0.5306539","0.52993274","0.5299147","0.52826834","0.52826834","0.5281628","0.5279948","0.527905","0.5271182","0.52679956","0.5262285"],"string":"[\n \"0.7178027\",\n \"0.67700803\",\n \"0.6706211\",\n \"0.66330725\",\n \"0.645455\",\n \"0.6333611\",\n \"0.62824416\",\n \"0.6110825\",\n \"0.6101818\",\n \"0.60921735\",\n \"0.60903865\",\n \"0.60903865\",\n \"0.6066746\",\n \"0.60435694\",\n \"0.60384893\",\n \"0.6006668\",\n \"0.5956292\",\n \"0.5912572\",\n \"0.5874441\",\n \"0.5867553\",\n \"0.5858808\",\n \"0.58582914\",\n \"0.5854895\",\n \"0.5812866\",\n \"0.58109945\",\n \"0.57881314\",\n \"0.575981\",\n \"0.57438415\",\n \"0.5738988\",\n \"0.5704263\",\n \"0.56953937\",\n \"0.5694752\",\n \"0.56864864\",\n \"0.56843036\",\n \"0.56685793\",\n \"0.5666039\",\n \"0.5652177\",\n \"0.5646462\",\n \"0.56227624\",\n \"0.56211823\",\n \"0.5599073\",\n \"0.5587713\",\n \"0.5582525\",\n \"0.558239\",\n \"0.5577765\",\n \"0.55588186\",\n \"0.55574304\",\n \"0.55554605\",\n \"0.5552167\",\n \"0.55490154\",\n \"0.5528244\",\n \"0.5527157\",\n \"0.552386\",\n \"0.552005\",\n \"0.55182743\",\n \"0.5515073\",\n \"0.55099446\",\n \"0.5503171\",\n \"0.5469659\",\n \"0.5465669\",\n \"0.5461551\",\n \"0.5458697\",\n \"0.545418\",\n \"0.5453942\",\n \"0.54529583\",\n \"0.5443841\",\n \"0.54433334\",\n \"0.5437667\",\n \"0.5437597\",\n \"0.543441\",\n \"0.54225993\",\n \"0.54160476\",\n \"0.54033524\",\n \"0.5400669\",\n \"0.539828\",\n \"0.5390946\",\n \"0.53849113\",\n \"0.5369697\",\n \"0.53656334\",\n \"0.53579855\",\n \"0.53536093\",\n \"0.5346797\",\n \"0.5344436\",\n \"0.5329234\",\n \"0.53264576\",\n \"0.5318775\",\n \"0.53185636\",\n \"0.5314316\",\n \"0.53142315\",\n \"0.5306539\",\n \"0.52993274\",\n \"0.5299147\",\n \"0.52826834\",\n \"0.52826834\",\n \"0.5281628\",\n \"0.5279948\",\n \"0.527905\",\n \"0.5271182\",\n \"0.52679956\",\n \"0.5262285\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6022976"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":90588,"cells":{"query":{"kind":"string","value":"Takes a packet, and returns the encoded bytestring representing it."},"document":{"kind":"string","value":"def encode_packet(self, packet):\n\n\t\ttry:\n\t\t\toutput = self.pack('ubyte', packet.ident)\n\t\t\tappend = ''\n\t\t\t#0x17\n\t\t\tif packet.ident == 0x17:\n\t\t\t\tif packet.data['unknown'] > 0:\n\t\t\t\t\tfor i in ('x2','y2','z2'):\n\t\t\t\t\t\tappend += self.pack('short', packet.data[i])\n\t\t\t#0x33\n\t\t\tif packet.ident in (0x33, 0x34):\n\t\t\t\tpacket.data['data_size'] = len(packet.data['data'])\n\t\t\t\tappend += self.pack_array_fast('byte', packet.data['data'])\n\t\t\t\n#\t\t\t#0x34\n#\t\t\tif packet.ident == 0x34:\n#\t\t\t\tcoords = []\n#\t\t\t\tbtypes = []\n#\t\t\t\tmetadata = []\n#\t\t\t\tfor i in packet.data['blocks']:\n#\t\t\t\t\tcoords.append(i['x'] << 12 | i['z'] << 8 | i['y'])\n#\t\t\t\t\tbtypes.append(i['type'])\n#\t\t\t\t\tmetadata.append(i['metadata'])\n#\t\t\t\t\n#\t\t\t\tpacket.data['data_size'] = len(coords)\n#\t\t\t\tappend += self.pack_array_fast('short', coords)\n#\t\t\t\tappend += self.pack_array_fast('byte', btypes)\n#\t\t\t\tappend += self.pack_array_fast('byte', metadata)\n\t\t\t\n\t\t\t#0x3C\n\t\t\tif packet.ident == 0x3C:\n\t\t\t\tarray = []\n\t\t\t\tfor i in packet.data['blocks']:\n\t\t\t\t\tarray += [i['x'], i['y'], i['z']]\n\t\t\t\tpacket.data['data_size'] = len(packet.data['blocks'])\n\t\t\t\tappend += self.pack_array_fast('byte', array)\n\t\t\t\n\t\t\t#0x68\n\t\t\tif packet.ident == 0x68:\n\t\t\t\tpacket.data['data_size'] = len(packet.data['slots_data'])\n\t\t\t\tappend += self.pack_array('slot', packet.data['slots_data'])\n\t\t\t#0x82: Sign\n\t\t\tif packet.ident == 0x82:\n\t\t\t\tfor i in range(4):\n\t\t\t\t\tpacket.data[\"line_%s\" % (i+1)] = packet.data[\"text\"][i]\n\t\t\t#0x83\n\t\t\tif packet.ident == 0x83:\n\t\t\t\tpacket.data['data_size'] = len(packet.data['data'])\n\t\t\t\tappend += self.pack_array_fast('byte', packet.data['data'])\n\t\t\n\t\t\tfor i in self.get_struct(packet):\n\t\t\t\toutput += self.pack(i[0], packet.data[i[1]])\n\t\t\t\n\t\t\toutput += append\n\t\t\treturn output\n\t\texcept Exception:\n\t\t\traise"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def encode_packet(self, packet, b64=False):\n if packet.binary and not b64:\n bytes = six.int2byte(packet.type)\n else:\n bytes = six.binary_type(packet.type)\n if packet.binary and b64:\n bytes = 'b' + bytes\n\n if packet.binary and b64:\n bytes += base64.b64encode(packet.data).decode('utf-8')\n else:\n bytes += six.binary_type(packet.data)\n\n return bytes","def bytes(self):\n return bytes(self._packet)","def packetDump(packet):\n hex = ''\n start = 0\n size = 16\n ln = len(packet)\n while start < ln:\n # print line number\n line = '%04x ' % start\n #print hex representation\n c = 0\n asc = packet[start:min(start+size, ln)]\n for b in asc:\n if c == 8:\n line = line + ' '\n line = line + '%02x ' % ord(b)\n c = c + 1\n line = ljust(line, 58) + '\"'\n # print ascii representation, replace unprintable characters with spaces\n for i in range(len(asc)):\n if ord(asc[i])<32 or ord(asc[i]) == 209:\n asc = replace(asc, asc[i], ' ')\n line = line + asc + '\"\\n' \n hex = hex + line\n start = start + size\n return hex.rstrip('\\n'), ln","def packetize(self):\n byte_str = b''\n\n # Bit string to accumulate bit values until we are ready to convert it into bytes\n bit_str = \"\"\n\n for field in self.fields:\n #if the current field is a special type, the bit_str value to the byte string and clear the accumulated bit_str.\n if not isinstance(field.size, int) and len(bit_str) != 0:\n byte_str += self.encode_bit_str(bit_str)\n bit_str = \"\"\n if field.size == NULL_TERMINATE:\n byte_str += self.encode_null_term(field.value)\n elif field.size == PREFIX_LENGTH:\n byte_str += self.encode_prefix_length(field.value)\n elif field.size == PREFIX_LEN_NULL_TERM:\n byte_str += self.encode_prefix_length_null_term(field.value)\n elif field.size == IPv4:\n byte_str += self.encode_ipv4(field.value)\n elif field.size == 1: # One bit, just add it to our bit string.\n bit_str += \"0\" if field.value == 0 else \"1\"\n else:\n if isinstance(field.value, int):\n bit_str += \"0\" * (field.size - len(bin(field.value)[2:])) + bin(field.value)[2:]\n elif isinstance(field.value, bytes):\n bit_str += field.value.decode('latin-1')\n #clear the bit string one last time\n if len(bit_str) != 0:\n byte_str += self.encode_bit_str(bit_str)\n bit_str = \"\"\n\n return byte_str","def get_byte_string(self):\n return \"\".join(['%02X' % i for i in self._data]).decode('hex')","def encode(self) -> bytes:\n\n # unsigned char dmac[6];\n # unsigned char smac[6];\n # uint16_t ethertype;\n # unsigned char payload[];\n\n t = struct.pack(\"H\", socket.htons(self.typ))\n return self.dmac + self.smac + t + self.payload","def encode(self) -> bytes:\n version_ihl = self._version << 4 | self._ihl\n flags_fragoffset = self._flags << 13 | self._frag_offset\n\n raw = struct.pack(\n IPHeader.fmt,\n version_ihl,\n self._tos,\n self.len,\n self.id,\n flags_fragoffset,\n self._ttl,\n self.proto,\n self._csum,\n self.saddr,\n self.daddr,\n )\n return raw + self.payload","def _finalize_packet(self, rudp_packet):\n return rudp_packet.to_bytes()","def encode_payload(self, packets, b64=False):\n bytes = b''\n for packet in packets:\n packet_bytes = self.encode_packet(packet, b64)\n packet_len = len(packet_bytes)\n if b64:\n bytes += str(packet_len) + b':' + packet_bytes\n else:\n binary_len = b''\n while packet_len != 0:\n binary_len = six.int2byte(packet_len % 10) + binary_len\n packet_len = int(packet_len / 10)\n bytes += b'\\x01' if packet.binary else b'\\x00'\n bytes += binary_len + b'\\xff' + packet_bytes\n\n return bytes","def bytes_packet(_bytes, termination_string=']'):\n\n return '{}{}'.format(len(_bytes), termination_string)","def stateless_pack(packet, to_server):\n\tdecoder = PacketDecoder(to_server)\n\treturn decoder.encode_packet(packet)","def encode(self):\r\n data = ''\r\n if self.id == PUSH_ACK:\r\n data = pack('<BHB', self.version, self.token, self.id)\r\n elif self.id == PULL_ACK:\r\n data = pack('<BHB', self.version, self.token, self.id)\r\n elif self.id == PULL_RESP:\r\n if self.version == 1:\r\n self.token = 0\r\n self.payload = self.txpk.encode()\r\n print(str(self.payload))\r\n data = pack('<BHB', self.version, self.token, self.id) + \\\r\n bytearray(self.payload,'utf-8')\r\n return data","def encoded_string(self) -> bytes:\n return self.string.encode(self.encoding)","def make_packet(self, type, data): \n return (\"{}\\x00{}\\x00{}\".format(type, data, self.ID)).encode()","def to_string(data):\n return to_bytes(data)","def _packet_string(self):\n return 'Packet (Length: %s)%s' % (self.length, os.linesep)","def _encode_bytes(source: bytes) -> bytes:\n return str(len(source)).encode(\"ascii\") + b\":\" + source","def encode(self):\n packed = struct.pack(\"<2Bl\",\n self.device_number,\n self.command_number,\n self.data)\n if self.message_id is not None:\n packed = packed[:5] + struct.pack(\"B\", self.message_id)\n return packed","def frame_packet(message):\n if message in one_char_packets:\n return message\n return \"$%s#%02x\" % (message, checksum(message))","def encodebytes(s):\n\n _check_bytes_type(s)\n return encode(bytes_to_int(s))","def string_raw(self):\n return \"x%x\" % self.encoded","def tree_to_bytes(tree: HuffmanTree) -> bytes:\n if tree.is_leaf() and tree.symbol is None:\n return bytes([])\n else:\n return bytes(_traverse_post_order(tree))","def bytes_to_str(b, encoding='ascii'):\n return b.decode(encoding)","def _create_packet(self, request):\n\n data_len = struct.pack('<Q', len(request))\n packet = b'ZBXD\\x01' + data_len + request\n\n def ord23(x):\n if not isinstance(x, int):\n return ord(x)\n else:\n return x\n\n logger.debug('Packet [str]: %s', packet)\n logger.debug('Packet [hex]: %s', ':'.join(hex(ord23(x))[2:] for x in packet))\n return packet","def get_tcp_packet_payload(pkt: dpkt.ethernet.Ethernet) -> bytes:\n eth = dpkt.ethernet.Ethernet(pkt)\n if isinstance(eth.data, dpkt.ip.IP) and isinstance(eth.data.data, dpkt.tcp.TCP):\n return eth.data.data.data","def ether_btoa(bytes):\n\n pretty = \"\"\n for i in (range(5)):\n pretty += hex(bytes[i])[2:4] # Strip the 0x from the string\n pretty += ':'\n \n pretty += hex(bytes[5])[2:4] # Strip the 0x from the string\n\n return pretty","def __bytes__(self):\n # Mac address case\n if self.subtype == 3:\n return bytes([self.type * 2, 1 + 6, self.subtype]) + self.value\n # ip address case\n elif self.subtype == 4:\n if self.value.version == 4:\n # ipv4 case\n return bytes([self.type * 2, 1 + 5, self.subtype ,1]) + self.value.packed\n else:\n # ipv6 case\n return bytes([self.type * 2, 1 + 17, self.subtype, 2]) + self.value.packed\n\n #all other cases:\n else:\n if len(self.value) > 255:\n return bytes([(self.type * 2) + 1, len(self.value) - 256, self.subtype]) + bytes(self.value, 'utf-8')\n else:\n return bytes([self.type * 2, len(self.value) + 1, self.subtype]) + bytes(self.value,'utf-8')","def _encoded_string_to_string(encoded_blob):\n try:\n return encoded_blob.decode(\"base64\")\n except Exception:\n raise InvalidDeckDataException(\"Cannot decode deck data into anything readable.\")","def _bytes_bytearray_to_str(s):\n if isinstance(s, (bytes, bytearray)):\n return s.decode()\n return s","def make_packet(self, string):\n\n string = string[:2] + \"checksum:,\" + string[2:]\n chksum = hashlib.sha256(string.encode()).hexdigest()\n string = string[:11] + chksum + string[11:]\n return string","def _encode(self) -> bytearray:\n return bytearray((self.tp,))","def packet(self):\n return self.server.packet(context=self.ctx)","def __bytes__(self):\n return pack(\"<HH\", self._packet_len, self._control_ctr)","def convert_to_string(_bytes: bytes)-> str:\n # print('input bytes: ', _bytes)\n # print('string: ', binascii.hexlify(_bytes))\n # print('string2: ', _bytes.hex())\n # print('string3: ', \" \".join([\"{:02x}\".format(x) for x in _bytes]))\n return \" \".join([\"{:02x}\".format(x) for x in _bytes])","def create_magic_packet(macaddress: str) -> bytes:\n if len(macaddress) == 17:\n sep = macaddress[2]\n macaddress = macaddress.replace(sep, \"\")\n elif len(macaddress) == 14:\n sep = macaddress[4]\n macaddress = macaddress.replace(sep, \"\")\n if len(macaddress) != 12:\n raise ValueError(\"Incorrect MAC address format\")\n return bytes.fromhex(\"F\" * 12 + macaddress * 16)","def _Encode(msgtype, transaction_id, *attrs):\n transaction_id = str(transaction_id)\n if len(transaction_id) != 12:\n raise ValueError('transactionid %r must be exactly 12 bytes'\n % transaction_id)\n print(attrs)\n for attrtype, attrval in attrs:\n print(attrtype,attrval)\n\n attrtext = ''.join(_EncodeAttr(attrtype, attrval) for attrtype, attrval in attrs)\n pkt = (struct.pack('!HHI', msgtype, len(attrtext), MAGIC_COOKIE) +\n transaction_id +\n attrtext)\n return pkt","def create_message(self, packet):\n self._header.packet_len = len(bytes(packet))\n \n frame_bytes = super(EthernetTransport, self).create_message(packet) \n \n # Update control counter for next frame\n self._header.update_control()\n \n return bytes(frame_bytes)","def to_bytes(self) -> bytes:","def huffman_data_encode(huff: huffman.HuffmanTree) -> hic.Payload:\n data = huff.encode_data()\n return hic.BitStringP(data)","def b64_of_bytes(data: bytes) -> str:\n return base64.b64encode(data).decode()","def get_payload(packet):\n #payload_len = get_payload_length(packet)\n adaptation_field_len = TS.get_adaptation_field_length(packet)\n header_size = 4 + adaptation_field_len\n return packet[header_size:]","def asbytes(s):\n if isinstance(s, bytes):\n return s\n else:\n return s.encode('utf-8')","def rawbytes(s):\r\n outlist = []\r\n for cp in s:\r\n num = ord(cp)\r\n if num < 255:\r\n outlist.append(struct.pack('B', num))\r\n elif num < 65535:\r\n outlist.append(struct.pack('>H', num))\r\n else:\r\n b = (num & 0xFF0000) >> 16\r\n H = num & 0xFFFF\r\n outlist.append(struct.pack('>bH', b, H))\r\n return b''.join(outlist)","def _as_bytes(s):\n if isinstance(s, bytes):\n return s\n return bytes(s, encoding='latin_1')","def obj2bytes(obj: StunPacket) -> bytes:\n\n message = bytes()\n for [attribute_type, attribute_val] in obj.message.items():\n message += pack(\n '{}{}s'.format(ATTRIBUTE_HEADER_FORMAT, len(attribute_val)),\n attribute_type,\n len(attribute_val),\n attribute_val,\n )\n\n type_bits = (\n '00'\n + obj.type_method[0:5]\n + obj.type_class[0]\n + obj.type_method[5:8]\n + obj.type_class[1]\n + obj.type_method[8:]\n )\n return pack(\n '{}{}s'.format(HEADER_FORMAT, len(message)),\n int(type_bits, 2),\n len(message),\n obj.magic_cookie,\n obj.transaction_id,\n message,\n )","def __bytes__(self):\n if self._header.value_type in b'ZH':\n value = self._buffer[:-1] # Omit the trailing Null\n elif self._header.value_type in b'AB':\n value = self._buffer\n else:\n value = str(self._buffer.value).encode('ASCII')\n return self._header.tag + b':' + (self._header.value_type if self._header.value_type in b'AifZHB' else b'i') + b':' + value","def to_bytes(self, ???):","def encode(self) -> bytes:\n return pack('<B' + self.fmt, *([self.type] + self.__args))","def tree_to_bytes(tree):\n\n if tree.left.symbol == \"dummy node\":\n return bytes([0, tree.right.symbol])\n else:\n if tree.left.is_leaf() and tree.right.is_leaf():\n return bytes([0, tree.left.symbol, 0, tree.right.symbol])\n elif tree.left.is_leaf():\n right = tree_to_bytes(tree.right)\n full = right + bytes([0, tree.left.symbol, 1, tree.right.number])\n return full\n elif tree.right.is_leaf():\n left = tree_to_bytes(tree.left)\n full = left + bytes([1, tree.left.number, 0, tree.right.symbol])\n return full\n else:\n left = tree_to_bytes(tree.left)\n right = tree_to_bytes(tree.right)\n full = left + right + bytes([1, tree.left.number, 1, tree.right.number])\n return full","def ntob(n, encoding):\n return n.encode(encoding)","def to_bytes(data):\n if isinstance(data, str):\n return data.encode(encoding='utf-8')\n else:\n return data","def encode_pck(pck: str) -> bytes:\n return (pck + PckGenerator.TERMINATION).encode()","def encode(self):\n data = self.fhdr.encode() + struct.pack('B', self.fport) + \\\n self.frmpayload\n return data","def encode_bit_str(self, input):\n byte_len = ceil(len(input) / 8)\n byte_ouput = int(input, 2).to_bytes(byte_len, \"big\")\n return byte_ouput","def Encode(chunk: bytes) -> bytes:\n return _UINT64.pack(len(chunk)) + chunk","def __bytes__(self):\n return (\n bytes(self.block_header) +\n pack_compact_int(len(self.txns)) +\n b''.join([bytes(t) for t in self.txns])\n )","def send_packet(self, packet, address, verbose=False):\n assert isinstance(packet, str)\n assert isinstance(address, tuple)\n assert isinstance(verbose, bool)\n if verbose:\n logger.debug(\"%d bytes to %s:%d\", len(packet), address[0], address[1])\n self._socket.sendto(packet, address)\n return packet","def to_bytes(data):\n if isinstance(data, unicode):\n return data.encode('utf-8')\n else:\n return data","def to_network_layer(packet):\r\n print(f\"[to_network_layer] packet:{packet}\")","def encode_bytes(value):\n if isinstance(value, bytearray):\n value = bytes(value)\n try:\n value = six.ensure_binary(value)\n except TypeError as exc:\n six.raise_from(EncoderException(\"Error encoding bytes to message: %r\" % value), exc)\n encoded_length = varint.encode_varint(len(value))\n return encoded_length + value","def usable_deck_to_encoded_string(usable_deck):\n return _string_to_encoded_string(_usable_deck_to_string(usable_deck))","def _as_bytes(s):\n if isinstance(s, bytes):\n return s\n # Assume it is a unicode string\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\n return codecs.latin_1_encode(s)[0]","def encode(self):\n return (struct.pack(b\"<iii\", self.size, self.id, self.type) +\n self.body.encode(\"ascii\") + b\"\\x00\\x00\")","def to_encoding(self):\n return \" \".join(self.b)","def bytes_to_escaped_str(data, keep_spacing=False, escape_single_quotes=False):\n\n if not isinstance(data, bytes):\n raise ValueError(\"data must be bytes, but is {}\".format(data.__class__.__name__))\n # We always insert a double-quote here so that we get a single-quoted string back\n # https://stackoverflow.com/questions/29019340/why-does-python-use-different-quotes-for-representing-strings-depending-on-their\n ret = repr(b'\"' + data).lstrip(\"b\")[2:-1]\n if not escape_single_quotes:\n ret = re.sub(r\"(?<!\\\\)(\\\\\\\\)*\\\\'\", lambda m: (m.group(1) or \"\") + \"'\", ret)\n if keep_spacing:\n ret = re.sub(\n r\"(?<!\\\\)(\\\\\\\\)*\\\\([nrt])\",\n lambda m: (m.group(1) or \"\") + dict(n=\"\\n\", r=\"\\r\", t=\"\\t\")[m.group(2)],\n ret\n )\n return ret","def enc(elements):\n encoded = ''\n for key, dtype, value in elements:\n binary = enc_elem(dtype, value)\n encoded += struct.pack('>HBH', key, dtype, len(binary)) + binary\n return encoded","def bytes_encoded(self):\n # type: () -> int\n return self._bytes_encoded","def tostring(b):\n if isinstance(b, bytes):\n return bytes2str(b)\n else:\n return b","def getPacketLengthBytes(self, packet):\n if sys.version[0] == \"2\":\n n = len(packet)\n a = array('c')\n a.append(chr((n >> 24) & 0xFF))\n a.append(chr((n >> 16) & 0xFF))\n a.append(chr((n >> 8) & 0xFF))\n a.append(chr(n & 0xFF))\n return a.tostring()\n elif sys.version[0] == \"3\":\n return (len(packet)).to_bytes(4, byteorder='big')\n else:\n return None","def encodeFrame(frame):\n return base64.b64encode(frame)","def rawbytes(s):\n outlist = []\n for cp in s:\n num = ord(cp)\n if num < 256:\n outlist.append(pack(\"b\", num))\n elif num < 65536:\n outlist.append(pack(\">H\", num))\n else:\n b = (num & 0xFF0000) >> 16\n H = num & 0xFFFF\n outlist.append(pack(\">bH\", b, H))\n return b\"\".join(outlist)","def binary_encoding(string, encoding = 'utf-8'):\n try:\n return bytes(string, encoding)\n except TypeError: # We are in Python 2\n return str(string)","def to_string(data):\n if isinstance(data, bytes):\n return data.decode('utf-8')\n else:\n return data","def ethernet_frame(packet):\n dest_mac, src_mac, proto = struct.unpack('! 6s 6s H', packet[:14])\n return get_mac_addr(dest_mac), get_mac_addr(src_mac), socket.htons(proto), packet[14:]","def get_encoded_bytes_string(self, target):\n pass","def _string_to_encoded_string(deck_string):\n return deck_string.encode(\"base64\")","def encode(value, encoding='utf-8') -> bytes:\n return value if isinstance(value, bytes) else str(value).encode(encoding)","def printing(packet):\n try:\n return packet[IP].src + \" ---> \"+packet[IP].dst\n except:\n return \"An error has accoured\"","def bytes_to_str(s, encoding='utf-8'):\n if isinstance(s, bytes):\n return s.decode(encoding)\n return s","def makePacket(bytes):\n header = makePacketHeader(bytes[0:8])\n md5 = bytes[8:24]\n data = bytes[24:24 + header.length]\n p = Packet(header, data)\n if p.md5.digest() != md5:\n raise errors.NetworkError(\n 'Wrong MD5-checksum! (expected: %s, got: %s)' % (\n p.md5.hexdigest(),\n binascii.b2a_hex(md5)))\n return p","def tcp_pkt_debug_info(pkt: dpkt.ip.IP) -> str:\n if isinstance(pkt, dpkt.ip.IP):\n paylod_len = pkt.len - (4 * pkt.hl) - (4 * pkt.data.off)\n return \"{}:{}-> {}:{}, seq: {}, ack:{}, flag:{}, payload len: {}, payload: {}, sum: {}\".format(\n inet_to_str(pkt.src), pkt.data.sport, inet_to_str(pkt.dst), pkt.data.dport, hex(pkt.data.seq),\n hex(pkt.data.ack), hex(pkt.data.flags), hex(paylod_len), pkt.data.data, hex(pkt.data.sum))","def dump(self, tag):\n length = tag.length\n result = self._read_bytes(0, length)\n self._buffer = self._buffer[length:]\n self._resetTag()\n return tag.raw + result","def encode(msg: str) -> str:\n\n msg_bytes = msg.encode(\"ascii\")\n b64_bytes = base64.b64encode(msg_bytes)\n return b64_bytes.decode(\"ascii\")","def encode(self):\n b = 0 | self.mtype << 5 | self.major\n data = struct.pack('B', b)\n return data","def encode(self):\n data = struct.pack('BBB', self.cid, self.margin, self.gwcnt)\n return data","def bytes_to_str(self, data):\n if isinstance(data, str):\n return data\n return data.decode(\"utf-8\")","def encode(self, message):\n return message.encode()","def bytes_to_str(s, encoding='utf-8'):\n if six.PY3 and isinstance(s, bytes):\n return s.decode(encoding)\n return s","def bytes_to_str(s, encoding='utf-8'):\n if six.PY3 and isinstance(s, bytes):\n return s.decode(encoding)\n return s","def toBytes(data):\n\tif isBytes(data):\n\t\treturn data\n\telse:\n\t\treturn data.encode(\"latin-1\")","def encode(self) -> bytes:\n code: str = str(self.id) + \" \" \\\n + str(self.time) + \" \" \\\n + str(self.action) + \" \" \\\n + str(self.was_success) + \" \" \\\n + self.acting_username + \" \" \\\n + str(self.source_account_id) + \" \" \\\n + str(self.destination_account_id) + \" \" \\\n + str(self.funds_amount)\n return code.encode()","def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n s = str(s)\n if isinstance(s, str):\n return s.encode(encoding, errors)\n return s","def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n s = str(s)\n if isinstance(s, str):\n return s.encode(encoding, errors)\n return s","def ser_string(s):\n if len(s) < 253:\n return struct.pack(\"B\", len(s)) + s\n elif len(s) < 0x10000:\n return struct.pack(\"<BH\", 253, len(s)) + s\n elif len(s) < 0x100000000:\n return struct.pack(\"<BI\", 254, len(s)) + s\n return struct.pack(\"<BQ\", 255, len(s)) + s","def to_buffer(self) -> bytearray:\n packet = bytearray()\n packet.extend(\n struct.pack(\n \"!ccccHH\",\n \"D\".encode(\"ascii\"),\n \"L\".encode(\"ascii\"),\n \"E\".encode(\"ascii\"),\n \"P\".encode(\"ascii\"),\n int(self.type),\n self.len,\n )\n )\n return packet","def _to_bytes(self, item):\n data = bytes(type(item).write_to_string(item)) if isinstance(item, Struct) else \\\n bytes(item.pack()) if isinstance(item, Buffer) else \\\n '' if item is None else bytes(item)\n return data","def encode(self):\n datarate_txpower = 0 | (self.datarate << 4) | self.txpower\n redundancy = 0 | (self.chmaskcntl << 4) | self.nbrep\n data = struct.pack('<BBHB', self.cid, datarate_txpower, self.chmask, redundancy)\n return data","def as_bytes(self) -> bytes:\n if isinstance(self.data, bytes):\n return self.data\n elif isinstance(self.data, str):\n return self.data.encode()\n else:\n return bytes(self.data)","def __bytes__(self):\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')","def __bytes__(self):\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')"],"string":"[\n \"def encode_packet(self, packet, b64=False):\\n if packet.binary and not b64:\\n bytes = six.int2byte(packet.type)\\n else:\\n bytes = six.binary_type(packet.type)\\n if packet.binary and b64:\\n bytes = 'b' + bytes\\n\\n if packet.binary and b64:\\n bytes += base64.b64encode(packet.data).decode('utf-8')\\n else:\\n bytes += six.binary_type(packet.data)\\n\\n return bytes\",\n \"def bytes(self):\\n return bytes(self._packet)\",\n \"def packetDump(packet):\\n hex = ''\\n start = 0\\n size = 16\\n ln = len(packet)\\n while start < ln:\\n # print line number\\n line = '%04x ' % start\\n #print hex representation\\n c = 0\\n asc = packet[start:min(start+size, ln)]\\n for b in asc:\\n if c == 8:\\n line = line + ' '\\n line = line + '%02x ' % ord(b)\\n c = c + 1\\n line = ljust(line, 58) + '\\\"'\\n # print ascii representation, replace unprintable characters with spaces\\n for i in range(len(asc)):\\n if ord(asc[i])<32 or ord(asc[i]) == 209:\\n asc = replace(asc, asc[i], ' ')\\n line = line + asc + '\\\"\\\\n' \\n hex = hex + line\\n start = start + size\\n return hex.rstrip('\\\\n'), ln\",\n \"def packetize(self):\\n byte_str = b''\\n\\n # Bit string to accumulate bit values until we are ready to convert it into bytes\\n bit_str = \\\"\\\"\\n\\n for field in self.fields:\\n #if the current field is a special type, the bit_str value to the byte string and clear the accumulated bit_str.\\n if not isinstance(field.size, int) and len(bit_str) != 0:\\n byte_str += self.encode_bit_str(bit_str)\\n bit_str = \\\"\\\"\\n if field.size == NULL_TERMINATE:\\n byte_str += self.encode_null_term(field.value)\\n elif field.size == PREFIX_LENGTH:\\n byte_str += self.encode_prefix_length(field.value)\\n elif field.size == PREFIX_LEN_NULL_TERM:\\n byte_str += self.encode_prefix_length_null_term(field.value)\\n elif field.size == IPv4:\\n byte_str += self.encode_ipv4(field.value)\\n elif field.size == 1: # One bit, just add it to our bit string.\\n bit_str += \\\"0\\\" if field.value == 0 else \\\"1\\\"\\n else:\\n if isinstance(field.value, int):\\n bit_str += \\\"0\\\" * (field.size - len(bin(field.value)[2:])) + bin(field.value)[2:]\\n elif isinstance(field.value, bytes):\\n bit_str += field.value.decode('latin-1')\\n #clear the bit string one last time\\n if len(bit_str) != 0:\\n byte_str += self.encode_bit_str(bit_str)\\n bit_str = \\\"\\\"\\n\\n return byte_str\",\n \"def get_byte_string(self):\\n return \\\"\\\".join(['%02X' % i for i in self._data]).decode('hex')\",\n \"def encode(self) -> bytes:\\n\\n # unsigned char dmac[6];\\n # unsigned char smac[6];\\n # uint16_t ethertype;\\n # unsigned char payload[];\\n\\n t = struct.pack(\\\"H\\\", socket.htons(self.typ))\\n return self.dmac + self.smac + t + self.payload\",\n \"def encode(self) -> bytes:\\n version_ihl = self._version << 4 | self._ihl\\n flags_fragoffset = self._flags << 13 | self._frag_offset\\n\\n raw = struct.pack(\\n IPHeader.fmt,\\n version_ihl,\\n self._tos,\\n self.len,\\n self.id,\\n flags_fragoffset,\\n self._ttl,\\n self.proto,\\n self._csum,\\n self.saddr,\\n self.daddr,\\n )\\n return raw + self.payload\",\n \"def _finalize_packet(self, rudp_packet):\\n return rudp_packet.to_bytes()\",\n \"def encode_payload(self, packets, b64=False):\\n bytes = b''\\n for packet in packets:\\n packet_bytes = self.encode_packet(packet, b64)\\n packet_len = len(packet_bytes)\\n if b64:\\n bytes += str(packet_len) + b':' + packet_bytes\\n else:\\n binary_len = b''\\n while packet_len != 0:\\n binary_len = six.int2byte(packet_len % 10) + binary_len\\n packet_len = int(packet_len / 10)\\n bytes += b'\\\\x01' if packet.binary else b'\\\\x00'\\n bytes += binary_len + b'\\\\xff' + packet_bytes\\n\\n return bytes\",\n \"def bytes_packet(_bytes, termination_string=']'):\\n\\n return '{}{}'.format(len(_bytes), termination_string)\",\n \"def stateless_pack(packet, to_server):\\n\\tdecoder = PacketDecoder(to_server)\\n\\treturn decoder.encode_packet(packet)\",\n \"def encode(self):\\r\\n data = ''\\r\\n if self.id == PUSH_ACK:\\r\\n data = pack('<BHB', self.version, self.token, self.id)\\r\\n elif self.id == PULL_ACK:\\r\\n data = pack('<BHB', self.version, self.token, self.id)\\r\\n elif self.id == PULL_RESP:\\r\\n if self.version == 1:\\r\\n self.token = 0\\r\\n self.payload = self.txpk.encode()\\r\\n print(str(self.payload))\\r\\n data = pack('<BHB', self.version, self.token, self.id) + \\\\\\r\\n bytearray(self.payload,'utf-8')\\r\\n return data\",\n \"def encoded_string(self) -> bytes:\\n return self.string.encode(self.encoding)\",\n \"def make_packet(self, type, data): \\n return (\\\"{}\\\\x00{}\\\\x00{}\\\".format(type, data, self.ID)).encode()\",\n \"def to_string(data):\\n return to_bytes(data)\",\n \"def _packet_string(self):\\n return 'Packet (Length: %s)%s' % (self.length, os.linesep)\",\n \"def _encode_bytes(source: bytes) -> bytes:\\n return str(len(source)).encode(\\\"ascii\\\") + b\\\":\\\" + source\",\n \"def encode(self):\\n packed = struct.pack(\\\"<2Bl\\\",\\n self.device_number,\\n self.command_number,\\n self.data)\\n if self.message_id is not None:\\n packed = packed[:5] + struct.pack(\\\"B\\\", self.message_id)\\n return packed\",\n \"def frame_packet(message):\\n if message in one_char_packets:\\n return message\\n return \\\"$%s#%02x\\\" % (message, checksum(message))\",\n \"def encodebytes(s):\\n\\n _check_bytes_type(s)\\n return encode(bytes_to_int(s))\",\n \"def string_raw(self):\\n return \\\"x%x\\\" % self.encoded\",\n \"def tree_to_bytes(tree: HuffmanTree) -> bytes:\\n if tree.is_leaf() and tree.symbol is None:\\n return bytes([])\\n else:\\n return bytes(_traverse_post_order(tree))\",\n \"def bytes_to_str(b, encoding='ascii'):\\n return b.decode(encoding)\",\n \"def _create_packet(self, request):\\n\\n data_len = struct.pack('<Q', len(request))\\n packet = b'ZBXD\\\\x01' + data_len + request\\n\\n def ord23(x):\\n if not isinstance(x, int):\\n return ord(x)\\n else:\\n return x\\n\\n logger.debug('Packet [str]: %s', packet)\\n logger.debug('Packet [hex]: %s', ':'.join(hex(ord23(x))[2:] for x in packet))\\n return packet\",\n \"def get_tcp_packet_payload(pkt: dpkt.ethernet.Ethernet) -> bytes:\\n eth = dpkt.ethernet.Ethernet(pkt)\\n if isinstance(eth.data, dpkt.ip.IP) and isinstance(eth.data.data, dpkt.tcp.TCP):\\n return eth.data.data.data\",\n \"def ether_btoa(bytes):\\n\\n pretty = \\\"\\\"\\n for i in (range(5)):\\n pretty += hex(bytes[i])[2:4] # Strip the 0x from the string\\n pretty += ':'\\n \\n pretty += hex(bytes[5])[2:4] # Strip the 0x from the string\\n\\n return pretty\",\n \"def __bytes__(self):\\n # Mac address case\\n if self.subtype == 3:\\n return bytes([self.type * 2, 1 + 6, self.subtype]) + self.value\\n # ip address case\\n elif self.subtype == 4:\\n if self.value.version == 4:\\n # ipv4 case\\n return bytes([self.type * 2, 1 + 5, self.subtype ,1]) + self.value.packed\\n else:\\n # ipv6 case\\n return bytes([self.type * 2, 1 + 17, self.subtype, 2]) + self.value.packed\\n\\n #all other cases:\\n else:\\n if len(self.value) > 255:\\n return bytes([(self.type * 2) + 1, len(self.value) - 256, self.subtype]) + bytes(self.value, 'utf-8')\\n else:\\n return bytes([self.type * 2, len(self.value) + 1, self.subtype]) + bytes(self.value,'utf-8')\",\n \"def _encoded_string_to_string(encoded_blob):\\n try:\\n return encoded_blob.decode(\\\"base64\\\")\\n except Exception:\\n raise InvalidDeckDataException(\\\"Cannot decode deck data into anything readable.\\\")\",\n \"def _bytes_bytearray_to_str(s):\\n if isinstance(s, (bytes, bytearray)):\\n return s.decode()\\n return s\",\n \"def make_packet(self, string):\\n\\n string = string[:2] + \\\"checksum:,\\\" + string[2:]\\n chksum = hashlib.sha256(string.encode()).hexdigest()\\n string = string[:11] + chksum + string[11:]\\n return string\",\n \"def _encode(self) -> bytearray:\\n return bytearray((self.tp,))\",\n \"def packet(self):\\n return self.server.packet(context=self.ctx)\",\n \"def __bytes__(self):\\n return pack(\\\"<HH\\\", self._packet_len, self._control_ctr)\",\n \"def convert_to_string(_bytes: bytes)-> str:\\n # print('input bytes: ', _bytes)\\n # print('string: ', binascii.hexlify(_bytes))\\n # print('string2: ', _bytes.hex())\\n # print('string3: ', \\\" \\\".join([\\\"{:02x}\\\".format(x) for x in _bytes]))\\n return \\\" \\\".join([\\\"{:02x}\\\".format(x) for x in _bytes])\",\n \"def create_magic_packet(macaddress: str) -> bytes:\\n if len(macaddress) == 17:\\n sep = macaddress[2]\\n macaddress = macaddress.replace(sep, \\\"\\\")\\n elif len(macaddress) == 14:\\n sep = macaddress[4]\\n macaddress = macaddress.replace(sep, \\\"\\\")\\n if len(macaddress) != 12:\\n raise ValueError(\\\"Incorrect MAC address format\\\")\\n return bytes.fromhex(\\\"F\\\" * 12 + macaddress * 16)\",\n \"def _Encode(msgtype, transaction_id, *attrs):\\n transaction_id = str(transaction_id)\\n if len(transaction_id) != 12:\\n raise ValueError('transactionid %r must be exactly 12 bytes'\\n % transaction_id)\\n print(attrs)\\n for attrtype, attrval in attrs:\\n print(attrtype,attrval)\\n\\n attrtext = ''.join(_EncodeAttr(attrtype, attrval) for attrtype, attrval in attrs)\\n pkt = (struct.pack('!HHI', msgtype, len(attrtext), MAGIC_COOKIE) +\\n transaction_id +\\n attrtext)\\n return pkt\",\n \"def create_message(self, packet):\\n self._header.packet_len = len(bytes(packet))\\n \\n frame_bytes = super(EthernetTransport, self).create_message(packet) \\n \\n # Update control counter for next frame\\n self._header.update_control()\\n \\n return bytes(frame_bytes)\",\n \"def to_bytes(self) -> bytes:\",\n \"def huffman_data_encode(huff: huffman.HuffmanTree) -> hic.Payload:\\n data = huff.encode_data()\\n return hic.BitStringP(data)\",\n \"def b64_of_bytes(data: bytes) -> str:\\n return base64.b64encode(data).decode()\",\n \"def get_payload(packet):\\n #payload_len = get_payload_length(packet)\\n adaptation_field_len = TS.get_adaptation_field_length(packet)\\n header_size = 4 + adaptation_field_len\\n return packet[header_size:]\",\n \"def asbytes(s):\\n if isinstance(s, bytes):\\n return s\\n else:\\n return s.encode('utf-8')\",\n \"def rawbytes(s):\\r\\n outlist = []\\r\\n for cp in s:\\r\\n num = ord(cp)\\r\\n if num < 255:\\r\\n outlist.append(struct.pack('B', num))\\r\\n elif num < 65535:\\r\\n outlist.append(struct.pack('>H', num))\\r\\n else:\\r\\n b = (num & 0xFF0000) >> 16\\r\\n H = num & 0xFFFF\\r\\n outlist.append(struct.pack('>bH', b, H))\\r\\n return b''.join(outlist)\",\n \"def _as_bytes(s):\\n if isinstance(s, bytes):\\n return s\\n return bytes(s, encoding='latin_1')\",\n \"def obj2bytes(obj: StunPacket) -> bytes:\\n\\n message = bytes()\\n for [attribute_type, attribute_val] in obj.message.items():\\n message += pack(\\n '{}{}s'.format(ATTRIBUTE_HEADER_FORMAT, len(attribute_val)),\\n attribute_type,\\n len(attribute_val),\\n attribute_val,\\n )\\n\\n type_bits = (\\n '00'\\n + obj.type_method[0:5]\\n + obj.type_class[0]\\n + obj.type_method[5:8]\\n + obj.type_class[1]\\n + obj.type_method[8:]\\n )\\n return pack(\\n '{}{}s'.format(HEADER_FORMAT, len(message)),\\n int(type_bits, 2),\\n len(message),\\n obj.magic_cookie,\\n obj.transaction_id,\\n message,\\n )\",\n \"def __bytes__(self):\\n if self._header.value_type in b'ZH':\\n value = self._buffer[:-1] # Omit the trailing Null\\n elif self._header.value_type in b'AB':\\n value = self._buffer\\n else:\\n value = str(self._buffer.value).encode('ASCII')\\n return self._header.tag + b':' + (self._header.value_type if self._header.value_type in b'AifZHB' else b'i') + b':' + value\",\n \"def to_bytes(self, ???):\",\n \"def encode(self) -> bytes:\\n return pack('<B' + self.fmt, *([self.type] + self.__args))\",\n \"def tree_to_bytes(tree):\\n\\n if tree.left.symbol == \\\"dummy node\\\":\\n return bytes([0, tree.right.symbol])\\n else:\\n if tree.left.is_leaf() and tree.right.is_leaf():\\n return bytes([0, tree.left.symbol, 0, tree.right.symbol])\\n elif tree.left.is_leaf():\\n right = tree_to_bytes(tree.right)\\n full = right + bytes([0, tree.left.symbol, 1, tree.right.number])\\n return full\\n elif tree.right.is_leaf():\\n left = tree_to_bytes(tree.left)\\n full = left + bytes([1, tree.left.number, 0, tree.right.symbol])\\n return full\\n else:\\n left = tree_to_bytes(tree.left)\\n right = tree_to_bytes(tree.right)\\n full = left + right + bytes([1, tree.left.number, 1, tree.right.number])\\n return full\",\n \"def ntob(n, encoding):\\n return n.encode(encoding)\",\n \"def to_bytes(data):\\n if isinstance(data, str):\\n return data.encode(encoding='utf-8')\\n else:\\n return data\",\n \"def encode_pck(pck: str) -> bytes:\\n return (pck + PckGenerator.TERMINATION).encode()\",\n \"def encode(self):\\n data = self.fhdr.encode() + struct.pack('B', self.fport) + \\\\\\n self.frmpayload\\n return data\",\n \"def encode_bit_str(self, input):\\n byte_len = ceil(len(input) / 8)\\n byte_ouput = int(input, 2).to_bytes(byte_len, \\\"big\\\")\\n return byte_ouput\",\n \"def Encode(chunk: bytes) -> bytes:\\n return _UINT64.pack(len(chunk)) + chunk\",\n \"def __bytes__(self):\\n return (\\n bytes(self.block_header) +\\n pack_compact_int(len(self.txns)) +\\n b''.join([bytes(t) for t in self.txns])\\n )\",\n \"def send_packet(self, packet, address, verbose=False):\\n assert isinstance(packet, str)\\n assert isinstance(address, tuple)\\n assert isinstance(verbose, bool)\\n if verbose:\\n logger.debug(\\\"%d bytes to %s:%d\\\", len(packet), address[0], address[1])\\n self._socket.sendto(packet, address)\\n return packet\",\n \"def to_bytes(data):\\n if isinstance(data, unicode):\\n return data.encode('utf-8')\\n else:\\n return data\",\n \"def to_network_layer(packet):\\r\\n print(f\\\"[to_network_layer] packet:{packet}\\\")\",\n \"def encode_bytes(value):\\n if isinstance(value, bytearray):\\n value = bytes(value)\\n try:\\n value = six.ensure_binary(value)\\n except TypeError as exc:\\n six.raise_from(EncoderException(\\\"Error encoding bytes to message: %r\\\" % value), exc)\\n encoded_length = varint.encode_varint(len(value))\\n return encoded_length + value\",\n \"def usable_deck_to_encoded_string(usable_deck):\\n return _string_to_encoded_string(_usable_deck_to_string(usable_deck))\",\n \"def _as_bytes(s):\\n if isinstance(s, bytes):\\n return s\\n # Assume it is a unicode string\\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\\n return codecs.latin_1_encode(s)[0]\",\n \"def encode(self):\\n return (struct.pack(b\\\"<iii\\\", self.size, self.id, self.type) +\\n self.body.encode(\\\"ascii\\\") + b\\\"\\\\x00\\\\x00\\\")\",\n \"def to_encoding(self):\\n return \\\" \\\".join(self.b)\",\n \"def bytes_to_escaped_str(data, keep_spacing=False, escape_single_quotes=False):\\n\\n if not isinstance(data, bytes):\\n raise ValueError(\\\"data must be bytes, but is {}\\\".format(data.__class__.__name__))\\n # We always insert a double-quote here so that we get a single-quoted string back\\n # https://stackoverflow.com/questions/29019340/why-does-python-use-different-quotes-for-representing-strings-depending-on-their\\n ret = repr(b'\\\"' + data).lstrip(\\\"b\\\")[2:-1]\\n if not escape_single_quotes:\\n ret = re.sub(r\\\"(?<!\\\\\\\\)(\\\\\\\\\\\\\\\\)*\\\\\\\\'\\\", lambda m: (m.group(1) or \\\"\\\") + \\\"'\\\", ret)\\n if keep_spacing:\\n ret = re.sub(\\n r\\\"(?<!\\\\\\\\)(\\\\\\\\\\\\\\\\)*\\\\\\\\([nrt])\\\",\\n lambda m: (m.group(1) or \\\"\\\") + dict(n=\\\"\\\\n\\\", r=\\\"\\\\r\\\", t=\\\"\\\\t\\\")[m.group(2)],\\n ret\\n )\\n return ret\",\n \"def enc(elements):\\n encoded = ''\\n for key, dtype, value in elements:\\n binary = enc_elem(dtype, value)\\n encoded += struct.pack('>HBH', key, dtype, len(binary)) + binary\\n return encoded\",\n \"def bytes_encoded(self):\\n # type: () -> int\\n return self._bytes_encoded\",\n \"def tostring(b):\\n if isinstance(b, bytes):\\n return bytes2str(b)\\n else:\\n return b\",\n \"def getPacketLengthBytes(self, packet):\\n if sys.version[0] == \\\"2\\\":\\n n = len(packet)\\n a = array('c')\\n a.append(chr((n >> 24) & 0xFF))\\n a.append(chr((n >> 16) & 0xFF))\\n a.append(chr((n >> 8) & 0xFF))\\n a.append(chr(n & 0xFF))\\n return a.tostring()\\n elif sys.version[0] == \\\"3\\\":\\n return (len(packet)).to_bytes(4, byteorder='big')\\n else:\\n return None\",\n \"def encodeFrame(frame):\\n return base64.b64encode(frame)\",\n \"def rawbytes(s):\\n outlist = []\\n for cp in s:\\n num = ord(cp)\\n if num < 256:\\n outlist.append(pack(\\\"b\\\", num))\\n elif num < 65536:\\n outlist.append(pack(\\\">H\\\", num))\\n else:\\n b = (num & 0xFF0000) >> 16\\n H = num & 0xFFFF\\n outlist.append(pack(\\\">bH\\\", b, H))\\n return b\\\"\\\".join(outlist)\",\n \"def binary_encoding(string, encoding = 'utf-8'):\\n try:\\n return bytes(string, encoding)\\n except TypeError: # We are in Python 2\\n return str(string)\",\n \"def to_string(data):\\n if isinstance(data, bytes):\\n return data.decode('utf-8')\\n else:\\n return data\",\n \"def ethernet_frame(packet):\\n dest_mac, src_mac, proto = struct.unpack('! 6s 6s H', packet[:14])\\n return get_mac_addr(dest_mac), get_mac_addr(src_mac), socket.htons(proto), packet[14:]\",\n \"def get_encoded_bytes_string(self, target):\\n pass\",\n \"def _string_to_encoded_string(deck_string):\\n return deck_string.encode(\\\"base64\\\")\",\n \"def encode(value, encoding='utf-8') -> bytes:\\n return value if isinstance(value, bytes) else str(value).encode(encoding)\",\n \"def printing(packet):\\n try:\\n return packet[IP].src + \\\" ---> \\\"+packet[IP].dst\\n except:\\n return \\\"An error has accoured\\\"\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def makePacket(bytes):\\n header = makePacketHeader(bytes[0:8])\\n md5 = bytes[8:24]\\n data = bytes[24:24 + header.length]\\n p = Packet(header, data)\\n if p.md5.digest() != md5:\\n raise errors.NetworkError(\\n 'Wrong MD5-checksum! (expected: %s, got: %s)' % (\\n p.md5.hexdigest(),\\n binascii.b2a_hex(md5)))\\n return p\",\n \"def tcp_pkt_debug_info(pkt: dpkt.ip.IP) -> str:\\n if isinstance(pkt, dpkt.ip.IP):\\n paylod_len = pkt.len - (4 * pkt.hl) - (4 * pkt.data.off)\\n return \\\"{}:{}-> {}:{}, seq: {}, ack:{}, flag:{}, payload len: {}, payload: {}, sum: {}\\\".format(\\n inet_to_str(pkt.src), pkt.data.sport, inet_to_str(pkt.dst), pkt.data.dport, hex(pkt.data.seq),\\n hex(pkt.data.ack), hex(pkt.data.flags), hex(paylod_len), pkt.data.data, hex(pkt.data.sum))\",\n \"def dump(self, tag):\\n length = tag.length\\n result = self._read_bytes(0, length)\\n self._buffer = self._buffer[length:]\\n self._resetTag()\\n return tag.raw + result\",\n \"def encode(msg: str) -> str:\\n\\n msg_bytes = msg.encode(\\\"ascii\\\")\\n b64_bytes = base64.b64encode(msg_bytes)\\n return b64_bytes.decode(\\\"ascii\\\")\",\n \"def encode(self):\\n b = 0 | self.mtype << 5 | self.major\\n data = struct.pack('B', b)\\n return data\",\n \"def encode(self):\\n data = struct.pack('BBB', self.cid, self.margin, self.gwcnt)\\n return data\",\n \"def bytes_to_str(self, data):\\n if isinstance(data, str):\\n return data\\n return data.decode(\\\"utf-8\\\")\",\n \"def encode(self, message):\\n return message.encode()\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if six.PY3 and isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if six.PY3 and isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def toBytes(data):\\n\\tif isBytes(data):\\n\\t\\treturn data\\n\\telse:\\n\\t\\treturn data.encode(\\\"latin-1\\\")\",\n \"def encode(self) -> bytes:\\n code: str = str(self.id) + \\\" \\\" \\\\\\n + str(self.time) + \\\" \\\" \\\\\\n + str(self.action) + \\\" \\\" \\\\\\n + str(self.was_success) + \\\" \\\" \\\\\\n + self.acting_username + \\\" \\\" \\\\\\n + str(self.source_account_id) + \\\" \\\" \\\\\\n + str(self.destination_account_id) + \\\" \\\" \\\\\\n + str(self.funds_amount)\\n return code.encode()\",\n \"def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n s = str(s)\\n if isinstance(s, str):\\n return s.encode(encoding, errors)\\n return s\",\n \"def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n s = str(s)\\n if isinstance(s, str):\\n return s.encode(encoding, errors)\\n return s\",\n \"def ser_string(s):\\n if len(s) < 253:\\n return struct.pack(\\\"B\\\", len(s)) + s\\n elif len(s) < 0x10000:\\n return struct.pack(\\\"<BH\\\", 253, len(s)) + s\\n elif len(s) < 0x100000000:\\n return struct.pack(\\\"<BI\\\", 254, len(s)) + s\\n return struct.pack(\\\"<BQ\\\", 255, len(s)) + s\",\n \"def to_buffer(self) -> bytearray:\\n packet = bytearray()\\n packet.extend(\\n struct.pack(\\n \\\"!ccccHH\\\",\\n \\\"D\\\".encode(\\\"ascii\\\"),\\n \\\"L\\\".encode(\\\"ascii\\\"),\\n \\\"E\\\".encode(\\\"ascii\\\"),\\n \\\"P\\\".encode(\\\"ascii\\\"),\\n int(self.type),\\n self.len,\\n )\\n )\\n return packet\",\n \"def _to_bytes(self, item):\\n data = bytes(type(item).write_to_string(item)) if isinstance(item, Struct) else \\\\\\n bytes(item.pack()) if isinstance(item, Buffer) else \\\\\\n '' if item is None else bytes(item)\\n return data\",\n \"def encode(self):\\n datarate_txpower = 0 | (self.datarate << 4) | self.txpower\\n redundancy = 0 | (self.chmaskcntl << 4) | self.nbrep\\n data = struct.pack('<BBHB', self.cid, datarate_txpower, self.chmask, redundancy)\\n return data\",\n \"def as_bytes(self) -> bytes:\\n if isinstance(self.data, bytes):\\n return self.data\\n elif isinstance(self.data, str):\\n return self.data.encode()\\n else:\\n return bytes(self.data)\",\n \"def __bytes__(self):\\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')\",\n \"def __bytes__(self):\\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7865717","0.6886599","0.67298377","0.6656107","0.63058937","0.62062097","0.61510146","0.6113067","0.6092784","0.60803","0.60527766","0.6038609","0.6027137","0.6022875","0.59639084","0.5963516","0.5936586","0.59108037","0.58827156","0.5860486","0.5859598","0.57995784","0.576686","0.57530296","0.5743763","0.57347494","0.5714057","0.5698994","0.5695114","0.56859976","0.56858206","0.56852335","0.56849295","0.5668039","0.56456465","0.5622179","0.56191075","0.5601621","0.5600001","0.5595907","0.55681926","0.55662376","0.5563345","0.5556569","0.5550874","0.5546386","0.5545603","0.55275023","0.55225974","0.55213314","0.55188286","0.55107486","0.5509624","0.54967296","0.5494827","0.54893905","0.54839903","0.54804194","0.5480204","0.54690593","0.5462033","0.54612815","0.544833","0.5447293","0.5446144","0.54373676","0.5432884","0.5424955","0.5415029","0.5414571","0.5407623","0.5398791","0.5394394","0.5386906","0.53865707","0.5381631","0.5365853","0.5360432","0.5358126","0.53559244","0.5350668","0.5340997","0.53361845","0.53346235","0.5334093","0.53330064","0.53290075","0.5327379","0.5327379","0.5326978","0.53264517","0.5323596","0.5323596","0.5313637","0.53093684","0.53067166","0.52991","0.5296066","0.52922934","0.52922934"],"string":"[\n \"0.7865717\",\n \"0.6886599\",\n \"0.67298377\",\n \"0.6656107\",\n \"0.63058937\",\n \"0.62062097\",\n \"0.61510146\",\n \"0.6113067\",\n \"0.6092784\",\n \"0.60803\",\n \"0.60527766\",\n \"0.6038609\",\n \"0.6027137\",\n \"0.6022875\",\n \"0.59639084\",\n \"0.5963516\",\n \"0.5936586\",\n \"0.59108037\",\n \"0.58827156\",\n \"0.5860486\",\n \"0.5859598\",\n \"0.57995784\",\n \"0.576686\",\n \"0.57530296\",\n \"0.5743763\",\n \"0.57347494\",\n \"0.5714057\",\n \"0.5698994\",\n \"0.5695114\",\n \"0.56859976\",\n \"0.56858206\",\n \"0.56852335\",\n \"0.56849295\",\n \"0.5668039\",\n \"0.56456465\",\n \"0.5622179\",\n \"0.56191075\",\n \"0.5601621\",\n \"0.5600001\",\n \"0.5595907\",\n \"0.55681926\",\n \"0.55662376\",\n \"0.5563345\",\n \"0.5556569\",\n \"0.5550874\",\n \"0.5546386\",\n \"0.5545603\",\n \"0.55275023\",\n \"0.55225974\",\n \"0.55213314\",\n \"0.55188286\",\n \"0.55107486\",\n \"0.5509624\",\n \"0.54967296\",\n \"0.5494827\",\n \"0.54893905\",\n \"0.54839903\",\n \"0.54804194\",\n \"0.5480204\",\n \"0.54690593\",\n \"0.5462033\",\n \"0.54612815\",\n \"0.544833\",\n \"0.5447293\",\n \"0.5446144\",\n \"0.54373676\",\n \"0.5432884\",\n \"0.5424955\",\n \"0.5415029\",\n \"0.5414571\",\n \"0.5407623\",\n \"0.5398791\",\n \"0.5394394\",\n \"0.5386906\",\n \"0.53865707\",\n \"0.5381631\",\n \"0.5365853\",\n \"0.5360432\",\n \"0.5358126\",\n \"0.53559244\",\n \"0.5350668\",\n \"0.5340997\",\n \"0.53361845\",\n \"0.53346235\",\n \"0.5334093\",\n \"0.53330064\",\n \"0.53290075\",\n \"0.5327379\",\n \"0.5327379\",\n \"0.5326978\",\n \"0.53264517\",\n \"0.5323596\",\n \"0.5323596\",\n \"0.5313637\",\n \"0.53093684\",\n \"0.53067166\",\n \"0.52991\",\n \"0.5296066\",\n \"0.52922934\",\n \"0.52922934\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7339893"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":90589,"cells":{"query":{"kind":"string","value":"A wrapper about the normal objects, that lets you unpack encoded packets easily. Returns (packet, remaining_buff), where remaining_buff is the given buffer without the bytes eaten by the packet. If no more packets can be read from buff, returns (None, buff)."},"document":{"kind":"string","value":"def stateless_unpack(buff, to_server):\n\tdecoder = PacketDecoder(to_server)\n\tdecoder.buff = buff\n\tpacket = decoder.read_packet()\n\treturn packet, decoder.buff"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def read_packet(self):\n\n\t\t#self.debug(\"READ BUFFER SIZE: %d\" % len(self.buff))\n\t\tbackup = self.buff[:]\n\t\tpacket = Packet()\n\t\ttry:\n\t\t\tpacket.direction = self.node\n\t\t\tpacket.ident = self.unpack('ubyte')\n\t\t\t\n\t\t\t#Defined structs from huge dict\n\t\t\tfor datatype, name in self.get_struct(packet):\n\t\t\t\t# this populates packet.data with {name: value}\n\t\t\t\tpacket.data[name] = self.unpack(datatype)\n\n\t\t\t# I believe the following are packet-type specific fixes for variable-length packets.\n\n\t\t\t#0x17\n\t\t\tif packet.ident == 0x17:\n\t\t\t\tif packet.data['unknown'] > 0:\n\t\t\t\t\tpacket.data['x2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['y2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['z2'] = self.unpack('short')\n\t\t\n\t\t\t#0x33\n\t\t\tif packet.ident in (0x33, 0x34):\n\t\t\t\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n#\t\t\t#0x34\n#\t\t\tif packet.ident == 0x34:\n#\t\t\t\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\n#\t\t\t\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tpacket.data[\"blocks\"] = []\n#\t\t\t\tfor i in zip(coords, btype, metadata):\n#\t\t\t\t\tblock = {}\n#\t\t\t\t\tblock[\"x\"] =\t\ti[0] >> 12\n#\t\t\t\t\tblock[\"z\"] = 0x0F & i[0] >> 8\n#\t\t\t\t\tblock[\"y\"] = 0xFF & i[0]\n#\t\t\t\t\tblock[\"type\"] = i[1]\n#\t\t\t\t\tblock[\"metadata\"] = i[2]\n#\t\t\t\t\tpacket.data[\"blocks\"].append(block)\n#\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x3C\n\t\t\tif packet.ident == 0x3C:\n\t\t\t\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\n\t\t\t\ti = 0\n\t\t\t\tpacket.data[\"blocks\"] = []\n\t\t\t\twhile i < packet.data['data_size']*3:\n\t\t\t\t\tpacket.data[\"blocks\"].append(dict(zip(('x','y','z'), records[i:i+3])))\n\t\t\t\t\ti+=3\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x68\n\t\t\tif packet.ident == 0x68:\n\t\t\t\tpacket.data[\"slots_data\"] = self.unpack_array('slot', packet.data[\"data_size\"])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\t#0x82:\n\t\t\tif packet.ident == 0x82:\n\t\t\t\tpacket.data[\"text\"] = []\n\t\t\t\tfor i in range(4):\n\t\t\t\t\tpacket.data[\"text\"].append(packet.data[\"line_%s\" % (i+1)])\n\t\t\t\t\t\n\t\t\t#0x83\n\t\t\tif packet.ident == 0x83:\n\t\t\t\tpacket.data[\"data\"] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\n\t\t\t# Sets packet.original to the byte string that the packet was decoded from.\n\t\t\tpacket.original = backup[:len(backup) - len(self.buff)]\n\n\t\t\treturn packet\n\n\t\texcept IncompleteData:\n\t\t\tself.buff = backup\n\t\t\treturn None\n\t\texcept Exception, ex:\n\t\t\tself.buff = backup\n\t\t\tex.args += (self.buff[20:],)\n\t\t\traise","def recv_packet(self):\r\n self.recv_bytes()\r\n\r\n packet_length_index = 0\r\n \r\n amount_data = len(self.recvBuffer) # available amount of data to read\r\n \r\n if amount_data <= packet_length_index: # just 0's in the buffer\r\n return None\r\n\r\n if len(self.recvBuffer) <= packet_length_index + 2: # length not received\r\n return None\r\n \r\n packet_length = unpack(self.recvBuffer, packet_length_index, 'H')\r\n \r\n if packet_length > len(self.recvBuffer): # packet not fully received\r\n return None\r\n \r\n if packet_length == 0: # some wrong generated packet by server, inc position of reading packet length\r\n packet_length_index += 1\r\n return None\r\n\r\n\t\t# extract packet data\r\n packet = self.recvBuffer[packet_length_index:packet_length_index+packet_length]\r\n\r\n # remaining recv buffer\r\n self.recvBuffer = self.recvBuffer[packet_length_index + packet_length:]\r\n packet_length_index = 0 # next packet length should be at pos 0 again\r\n\r\n return packet","def extract_packet(_buffer):\n if len(_buffer)>=5:\n mtype=_buffer[0]\n msglen=struct.unpack('!L',_buffer[1:5])[0]\n if len(_buffer)>=msglen+1:\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\n return None,None,_buffer","def recv(self) -> tuple:\n (data, c) = self.socket.recvfrom(Rudp.Packet.buffer())\n # print(data)\n (packet, validity) = Rudp.Packet.unpack(data)\n if(validity):\n print(\"Valid Packet Received From: \", c)\n else:\n raise Rudp.InvalidPacket(\"Invalid Packet Received\")\n\n return (packet, validity, c)","def recv_raw(self) -> Dict[str, Any]:\n while True:\n try:\n packet = self.__recv_frame()\n except UnknownPacketException:\n continue\n\n # Hack for sniffing on localhost\n if packet['address']['interface'] == 'lo' and packet['address']['type'] != 4:\n continue\n\n if self.address and self.port:\n if (\n packet['ip_header']['source_address'] == self.address and\n packet['tcp_header']['source_port'] == self.port\n ):\n return packet\n if (\n packet['ip_header']['destination_address'] == self.address and\n packet['tcp_header']['destination_port'] == self.port\n ):\n return packet\n elif self.address:\n if (\n packet['ip_header']['source_address'] == self.address or\n packet['ip_header']['destination_address'] == self.address\n ):\n return packet\n elif self.port:\n if (\n packet['tcp_header']['source_port'] == self.port or\n packet['tcp_header']['destination_port'] == self.port\n ):\n return packet\n else:\n return packet","def recv_bundle(self):\n hdr_raw = sock_recv_raw(self.sock, 6, self.timeout)\n data_length, has_secondary = SPPPacketHeader.preparse_data_length(\n hdr_raw\n )\n data_plus_secondary = sock_recv_raw(\n self.sock,\n data_length,\n self.timeout,\n )\n packet, _ = SPPPacket.parse(\n hdr_raw + data_plus_secondary,\n timecode_used=True,\n has_crc=self.use_crc,\n )\n if self.use_crc:\n assert packet.crc_provided == packet.crc()\n return packet.payload","def from_network_layer(buffer):\r\n packet = buffer.get_packet()\r\n # print(f'buffer.message:{buffer.message}')\r\n # if packet == None:\r\n # print(f\"[from_network_layer] packet:NULL\")\r\n print(f\"[from_network_layer] packet:{packet}\")\r\n return packet","def receive(self) -> [Packet, None]:\n packet_size_data = self._stream.read(2)\n if not packet_size_data:\n return None\n packet_size = int.from_bytes(packet_size_data, 'little')\n packet_data = self._stream.read(packet_size)\n return packet_from_bytes(packet_data)","def decode(self, buf=None):\n if buf is None:\n buf = self.receive()\n \n return decode_network_packet(buf)","def recv_data(self):\n data = \"\"\n size = 0\n\n try:\n size = self.sockObj.recv(4) #Get metadata\n except:\n raise Exception(\"Error while receiving data. Probably broken pipe\")\n\n if len(size) == 0:\n raise Exception(\"No data recivied. Probably broken pipe\")\n\n size = struct.unpack('>I',size)[0]\n\n data = self.sockObj.recv(size)\n\n if len(data) != size:\n raise Exception(\"Partiala data recivied\")\n\n return self.decode(data)","def recv(self):\n self.buf = self.sock_in.recvfrom(65565)\n p = Packet(data=self.buf)\n return p","def unpack(self, struct):\n if len(self.view) < struct.size:\n raise UnderflowDecodeError()\n\n v = struct.unpack(self.view[0:struct.size])\n self.num_bytes_consumed += struct.size\n self.view = self.view[struct.size:]\n return v","def read_raw_packet(self):\n\n size = 0\n\n # Read our two-byte header from the debugger...\n while not size:\n size = (self._get_next_byte() << 16) | self._get_next_byte()\n\n # ... and read our packet.\n packet = bytearray([self._get_next_byte() for _ in range(size)])\n\n # Return our packet.\n # TODO: extract and provide status flags\n # TODO: generate a timestamp on-device\n return packet, datetime.now(), None","def decode(cls, buffer):\n\n if len(buffer) < struct.calcsize(b\"<i\"):\n raise IncompleteMessageError\n size = struct.unpack(b\"<i\", buffer[:4])[0]\n if len(buffer) - struct.calcsize(b\"<i\") < size:\n raise IncompleteMessageError\n packet = buffer[:size + 4]\n buffer = buffer[size + 4:]\n id = struct.unpack(b\"<i\", packet[4:8])[0]\n type = struct.unpack(b\"<i\", packet[8:12])[0]\n body = packet[12:][:-2].decode(\"ascii\")\n return cls(id, type, body), buffer","def read(self):\n packet = None\n while packet is None:\n packet = self.async_read()\n return packet","def handle_receive(self, data):\n alldata = \"\"\n for item in data:\n alldata += item\n\n # Wrap data in a StringIO buffer\n cur_buffer = stringio.StringIO(alldata)\n\n with self.__buffer_lock:\n # While the buffer is not fully processed\n while True:\n # Read header, if no length for metadata and binary data is\n # available\n if self.__meta_length is None:\n if self.read_part(cur_buffer, \"__header_buffer\", self.__header_length):\n header = struct.unpack(\"!II?\", self.__header_buffer)\n self.__meta_length, self.__binary_length, self.__binary_compressed = header\n total = len(self.__header_buffer) + self.__meta_length + self.__binary_length\n else:\n break\n\n # Read metadata bytes when the metadata buffer does not have the\n # correct length yet.\n if len(self.__meta_buffer) < self.__meta_length:\n if not self.read_part(cur_buffer, \"__meta_buffer\", self.__meta_length):\n break\n\n # Read binary bytes when the binary buffer does not have the\n # correct length yet.\n if len(self.__binary_buffer) < self.__binary_length:\n if not self.read_part(cur_buffer, \"__binary_buffer\", self.__binary_length):\n break\n\n # Read a complete 'packet', unpack\n if self.__binary_compressed:\n self.__binary_buffer = zlib.decompress(self.__binary_buffer, 15, self.__binary_length * 2)\n self.__meta_buffer = zlib.decompress(self.__meta_buffer, 15, self.__meta_length * 2)\n\n binary_data = self.__binary_buffer\n meta_data = pickle.loads(self.__meta_buffer)\n self.__binary_buffer = \"\"\n self.__meta_buffer = \"\"\n self.__header_buffer = \"\"\n self.__meta_length = None\n self.__binary_length = None\n self.__binary_compressed = False\n\n # Append to the receive buffer (of ThreadedSocket class)\n with self._ThreadedSocket__receive_lock:\n self._ThreadedSocket__receive_buffer.append([meta_data, binary_data])","def recv_frame(self):\r\n header_bytes = self._recv_strict(2)\r\n if not header_bytes:\r\n return None\r\n b1 = ord(header_bytes[0])\r\n fin = b1 >> 7 & 1\r\n rsv1 = b1 >> 6 & 1\r\n rsv2 = b1 >> 5 & 1\r\n rsv3 = b1 >> 4 & 1\r\n opcode = b1 & 0xf\r\n b2 = ord(header_bytes[1])\r\n mask = b2 >> 7 & 1\r\n length = b2 & 0x7f\r\n\r\n length_data = \"\"\r\n if length == 0x7e:\r\n length_data = self._recv_strict(2)\r\n length = struct.unpack(\"!H\", length_data)[0]\r\n elif length == 0x7f:\r\n length_data = self._recv_strict(8)\r\n length = struct.unpack(\"!Q\", length_data)[0]\r\n\r\n mask_key = \"\"\r\n if mask:\r\n mask_key = self._recv_strict(4)\r\n data = self._recv_strict(length)\r\n if traceEnabled:\r\n recieved = header_bytes + length_data + mask_key + data\r\n logger.debug(\"recv: \" + repr(recieved))\r\n\r\n if mask:\r\n data = ABNF.mask(mask_key, data)\r\n\r\n frame = ABNF(fin, rsv1, rsv2, rsv3, opcode, mask, data)\r\n return frame","def baseRecv(self, buflen):\n\n # Attempts to retrieve a message from the queue initilized in bind, returns None if there are no messages\n data = r.popMessage(); \n\n # Checks to see if a message was retrieved\n if data is None:\n return None; # Not certain if this is the correct return for this...\n else:\n dest_mac = data[0];\n source_mac = data[1];\n length = data[2];\n payload = data[3];\n mac_header = dest_mac+source_mac+length;\n\n ip_header = payload[:7];\n udp_header = payload[7:9];\n message = payload[9:];\n\n # If the message is not addressed to this computer's MAC, discard the message\n if dest_mac != self.my_mac: return None;\n\n if (buflen<len(message)): return None;\n else: return message, mac_header, ip_header, udp_header;","def from_ring_buffer(cls, buf):\n if len(buf) < cls.MESSAGE_LENGTH_SIZE:\n return None\n \n message_length_bytes = buf.peek(cls.MESSAGE_LENGTH_SIZE)\n message_length = int.from_bytes(message_length_bytes, byteorder='big')\n\n if message_length == 0:\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\n return cls(cls.Id.KEEP_ALIVE, 0)\n \n #print('message length {}'.format(message_length))\n if len(buf) < message_length + cls.MESSAGE_LENGTH_SIZE:\n # Incomplete header\n # Don't remove anything from the buffer, wait for next byte to get a full header\n #print('incomplete header: buffer needs {} bytes but only has {}'.format(message_length + 4,\n # len(buf)))\n return None\n\n\n # Have a full header (length + message id)\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\n message_id = cls.Id(buf.read(1)[0])\n\n payload_length = message_length - 1\n assert(len(buf) >= payload_length)\n\n payload = buf.read(payload_length)\n return cls(message_id, payload)","def true_recvfrom(conn, buff):\n received, address = conn.recvfrom(buff)\n data = key.decrypt(received)\n try:\n return data.decode(), address\n except UnicodeDecodeError: # pickle data\n return pickle.loads(data), address","def async_read(self):\n self.lock.acquire()\n\n # append data\n self.rx_buffer += self.interface.read()\n\n # ensure first byte start with 0xbc\n if len(self.rx_buffer) > 0:\n if self.rx_buffer[0] != 0xbc:\n try:\n pkt_start = self.rx_buffer.index(0xbc)\n self.rx_buffer = self.rx_buffer[pkt_start:]\n except ValueError:\n self.rx_buffer = bytes()\n\n # check if we got a valid packet\n if len(self.rx_buffer) >= 4:\n pkt_size = unpack('<H', self.rx_buffer[2:4])[0]\n # check if we got a complete packet\n if len(self.rx_buffer) >= (pkt_size + 5):\n # yep, parse this packet\n packet = Packet.fromBytes(self.rx_buffer[:pkt_size+5])\n self.rx_buffer = self.rx_buffer[pkt_size+5:]\n self.lock.release()\n return packet\n\n # otherwise, return None\n self.lock.release()\n return None","def recv(self) -> Tuple[int, bytes]:\n seq_idx: int = 0\n self.device.set_nonblocking(False)\n data_chunk: bytes = bytes(self.device.read(64 + 1))\n self.device.set_nonblocking(True)\n\n assert data_chunk[:2] == b\"\\x01\\x01\"\n assert data_chunk[2] == 5\n assert data_chunk[3:5] == seq_idx.to_bytes(2, byteorder=\"big\")\n\n data_len: int = int.from_bytes(data_chunk[5:7], byteorder=\"big\")\n data: bytes = data_chunk[7:]\n\n while len(data) < data_len:\n read_bytes = bytes(self.device.read(64 + 1, timeout_ms=1000))\n data += read_bytes[5:]\n\n sw: int = int.from_bytes(data[data_len - 2:data_len], byteorder=\"big\")\n rdata: bytes = data[:data_len - 2]\n\n LOG.debug(\"<= %s %s\", rdata.hex(), hex(sw)[2:])\n\n return sw, rdata","def unpack_from(self, struct):\n if len(self.view) < struct.size:\n raise UnderflowDecodeError()\n\n v = struct.unpack_from(self.view)\n self.num_bytes_consumed += struct.size\n self.view = self.view[struct.size:]\n return v","def parseBuffer(self):\n idx = self.buf.find(DELIMITER)\n while idx > -1:\n packet = self.buf[0:idx]\n if len(packet) > 4:\n if packet[0:3] == 'DATA':\n self.factory.setData(packet[4:idx])\n else:\n print \"%s is a malformed packet, header %s not recognized\" % (packet, packet[0:3])\n else:\n print \"%s attempting to send a packet of invalid length %s\" % (packet, len(packet))\n self.buf = self.buf[(idx + len(DELIMITER)):]\n idx = self.buf.find(DELIMITER)","def decode_network_packet(buf):\n off = 0\n blen = len(buf)\n\n while off < blen:\n ptype, plen = header.unpack_from(buf, off)\n\n if plen > blen - off:\n raise ValueError(\"Packet longer than amount of data in buffer\")\n\n if ptype not in _decoders:\n raise ValueError(\"Message type %i not recognized\" % ptype)\n\n yield ptype, _decoders[ptype](ptype, plen, buf[off:])\n off += plen","def packet_read(self):\n bytes_received = 0\n \n if self.sock == NC.INVALID_SOCKET:\n return NC.ERR_NO_CONN\n \n if self.in_packet.command == 0:\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\n if errnum == 0 and len(ba_data) == 1:\n bytes_received += 1\n byte = ba_data[0]\n self.in_packet.command = byte\n \n if self.as_broker:\n if self.bridge is None and self.state == NC.CS_NEW and (byte & 0xF0) != NC.CMD_CONNECT:\n print \"RETURN ERR_PROTOCOL\"\n return NC.ERR_PROTOCOL, bytes_received\n else:\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\n return NC.ERR_SUCCESS, bytes_received\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\n return NC.ERR_CONN_LOST, bytes_received\n else:\n evt = event.EventNeterr(errnum, errmsg)\n self.push_event(evt)\n return NC.ERR_UNKNOWN, bytes_received\n \n if not self.in_packet.have_remaining:\n loop_flag = True\n while loop_flag:\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\n \n if errnum == 0 and len(ba_data) == 1: \n byte = ba_data[0]\n bytes_received += 1\n self.in_packet.remaining_count += 1\n if self.in_packet.remaining_count > 4:\n return NC.ERR_PROTOCOL, bytes_received\n \n self.in_packet.remaining_length += (byte & 127) * self.in_packet.remaining_mult\n self.in_packet.remaining_mult *= 128\n else:\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\n return NC.ERR_SUCCESS, bytes_received\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\n return NC.ERR_CONN_LOST, bytes_received\n else:\n evt = event.EventNeterr(errnum, errmsg)\n self.push_event(evt)\n return NC.ERR_UNKNOWN, bytes_received\n \n if (byte & 128) == 0:\n loop_flag = False\n \n if self.in_packet.remaining_length > 0:\n self.in_packet.payload = bytearray(self.in_packet.remaining_length)\n if self.in_packet.payload is None:\n return NC.ERR_NO_MEM, bytes_received\n self.in_packet.to_process = self.in_packet.remaining_length\n \n self.in_packet.have_remaining = True\n \n if self.in_packet.to_process > 0:\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, self.in_packet.to_process)\n if errnum == 0 and len(ba_data) > 0:\n readlen = len(ba_data)\n bytes_received += readlen\n for idx in xrange(0, readlen):\n self.in_packet.payload[self.in_packet.pos] = ba_data[idx]\n self.in_packet.pos += 1\n self.in_packet.to_process -= 1\n else:\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\n return NC.ERR_SUCCESS, bytes_received\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\n return NC.ERR_CONN_LOST, bytes_received\n else:\n evt = event.EventNeterr(errnum, errmsg)\n self.push_event(evt)\n return NC.ERR_UNKNOWN, bytes_received\n\n #all data for this packet is read\n self.in_packet.pos = 0\n \n ret = self.packet_handle()\n \n self.in_packet.packet_cleanup()\n \n self.last_msg_in = time.time()\n \n return ret, bytes_received","def recv_data(self, maxbuffer=4096):\n try:\n buff = self.s.recv(maxbuffer)\n except OSError as e:\n print(e)\n return buff.decode()","def _receive_packet(self):\n report = self._serial_read(1)\n if len(report) != 1:\n self.log(\"ERROR: Didn't read back a report!\")\n report = -1\n else:\n report = report[0]\n retval = self._serial_read(1)\n if len(retval) != 1:\n self.log(\"ERROR: Didn't read back a return value!\")\n retval = -1\n else:\n retval = retval[0]\n\n return_payload_len = self._serial_read(1)\n if len(return_payload_len) != 1:\n self.log(\"ERROR: Didn't read back a return payload length!\")\n return_payload_len = 0\n else:\n return_payload_len = return_payload_len[0]\n\n if return_payload_len != 0:\n return_payload = self._serial_read(return_payload_len)\n else:\n return_payload = []\n checksum = self._serial_read(1)\n if len(checksum) != 1:\n self.log(\"ERROR: Didn't read back a checksum!\")\n checksum = -1\n else:\n checksum = checksum[0]\n\n data = self.MAGIC_HEADER + [report, retval, return_payload_len] + return_payload\n data.append(checksum)\n\n our_checksum = self.generate_checksum(data[:-1])\n if our_checksum != checksum:\n self.log(\"ERROR: Our checksum didn't calculate properly! \"\n \"(Calculated {}, expected {})\".format(our_checksum, checksum))\n return -1, checksum, []\n else:\n if self.verbose:\n self.log(\"Checksum match! ({} == {})\".format(our_checksum, checksum))\n\n return report, retval, return_payload","def length_wrapper(buf, pos):\n length, pos = varint.decode_varint(buf, pos)\n end = pos+length\n output = []\n while pos < end:\n value, pos = wrapped_decoder(buf, pos)\n output.append(value)\n if pos > end:\n raise DecoderException(\n (\"Error decoding packed field. Packed length larger than\"\n \" buffer: decoded = %d, left = %d\")\n % (length, len(buf) - pos))\n return output, pos","def receive(self) -> Packet:\n try:\n return packet_from_bytes(self._socket.recvfrom(MAX_PACKET_SIZE)[0])\n except socket.timeout:\n raise racetools.errors.Timeout('timeout reached waiting for UDP packet') from None","def unpack_real(self, data_type, length):\n\t\tif len(self.buff) < length:\n\t\t\traise IncompleteData()\n\t\to = struct.unpack_from('!'+data_type, self.buff)[0]\n\t\tself.buff = self.buff[length:]\n\t\treturn o","def unpack(self, pkt):\n if pkt[0]!='$' or pkt[-3]!='#':\n raise ValueError('bad packet')\n if (sum(ord(c) for c in pkt[1:-3]) % 256) != int(pkt[-2:],16):\n raise ValueError('bad checksum')\n pkt = pkt[1:-3]\n return pkt","def __recv_frame(self) -> Dict[str, Any]:\n # Grab a packet\n packets = self.sock.recvfrom(Sniffer.RECEIVE_SIZE)\n address = self.__process_address(packets[1])\n packet = packets[0]\n offset = 0\n\n # Make sure its a valid packet\n eth_header = self.__process_ethframe(packet[offset:(offset + Sniffer.ETH_HEADER_LENGTH)])\n offset = offset + eth_header['header_length']\n\n if eth_header['protocol'] != 8:\n # Not IP\n raise UnknownPacketException(\n 'Unknown frame {}'.format(eth_header['protocol'])\n )\n\n # Get the IP header\n ip_header = self.__process_ipframe(packet[offset:(offset + Sniffer.IP_HEADER_LENGTH)])\n offset = offset + ip_header['header_length']\n\n if ip_header['protocol'] != 6:\n # Not TCP\n raise UnknownPacketException(\n 'Unknown protocol {}'.format(ip_header['protocol']),\n )\n\n # Get TCP header\n tcp_header = self.__process_tcpframe(packet[offset:(offset + Sniffer.TCP_HEADER_LENGTH)])\n offset = offset + tcp_header['header_length']\n\n # Get payload length\n payload_length = ip_header['length'] - ip_header['header_length'] - tcp_header['header_length']\n\n # Get payload\n data = packet[offset:offset + payload_length]\n\n return {\n 'ip_header': ip_header,\n 'tcp_header': tcp_header,\n 'data': data,\n 'address': address,\n }","def _read(self):\n \n try:\n d = self._get_byte()\n ts = time.time()\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n ts = time.time()\n packet = [d]\n d = self._get_byte()\n if d == self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n ts = time.time()\n else:\n packet.append(d)\n while d != self.HDLC_FLAG_BYTE:\n d = self._get_byte()\n packet.append(d)\n if self._debug == True:\n print \"Serial:_read: unescaped\", packet\n packet = self._unescape(packet)\n \n crc = self._crc16(0, packet[1:-3])\n packet_crc = self._decode(packet[-3:-1])\n \n if crc != packet_crc:\n print \"Warning: wrong CRC! %x != %x %s\" % (crc, packet_crc, [\"%2x\" % i for i in packet])\n if self._debug:\n if self._ts == None:\n self._ts = ts\n else:\n print \"Serial:_read: %.4f (%.4f) Recv:\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\n self._ts = ts\n return RawPacket(ts, packet[1:-3], crc == packet_crc)\n except socket.timeout:\n return None","def parse_payload(self):\n while len(self.buffer) >= 10:\n \"\"\" check magic word \"\"\"\n if self.buffer[0:2] != self.mw:\n #LogDebug(\"drop all buffer due to incorrect magic word\")\n self.buffer = b\"\" # drop entire buffer\n\n \"\"\" extract the value from length field \"\"\"\n length = struct.unpack(\"I\", self.buffer[2:6])[0] + 1\n #print \"packet len\", length, \"buffer len\", len(self.buffer)\n if len(self.buffer) < length:\n #LogDebug(\"imcompleted packet will be processed later\")\n break\n\n \"\"\" verify the packet CRC \"\"\"\n calculated_crc = struct.pack(\"I\", binascii.crc32(self.buffer[:length-4]) & 0xFFFFFFFF)\n if calculated_crc != self.buffer[length-4:length]:\n pass\n else:\n payload = self.buffer[6:length-4]\n self.payloads.append(payload)\n self.buffer = self.buffer[length:]","def recvfrom(self, bufsize: int) -> Tuple:\n ...","def unpack(usb_packet):\n packet = StenoPacket(\n # Drop sync when unpacking.\n *StenoPacket._STRUCT.unpack(usb_packet[:StenoPacket.HEADER_SIZE])[1:]\n )\n if packet.data_length:\n packet.data, = unpack(\n '%ss' % packet.data_length,\n usb_packet[StenoPacket.HEADER_SIZE:StenoPacket.HEADER_SIZE +\n packet.data_length]\n )\n return packet","def _lowLevelRecv(self,buffer):\n import socket\n\n try: data = self.socket_reference.recv(buffer)\n except socket.error as error: raise CommClientException(str(error))\n\n return data","def get_packet(self):\n msg_type = ''\n msg = ''\n try:\n msg_type = self.sock.recv(4)\n data = self.sock.recv(4)\n msg_len = int(struct.unpack('!L', data)[0])\n\n while len(msg) != msg_len:\n data = self.sock.recv(min(2048, msg_len - len(msg)))\n if not len(data):\n break\n msg += data\n\n if len(msg) != msg_len:\n return [None, None]\n\n except KeyboardInterrupt:\n raise\n except:\n traceback.print_exc()\n\n return Packet(type=msg_type, payload=json.loads(msg), handler=self.handler, connection=self)","def parse_data(self,ring_buffer):\n #get one complete package\n\n if ring_buffer.buf_len() <= 0:\n return None\n\n\n #protocol_parse = protocol_handler.ProtocolHandler()\n package = None\n try:\n self._protocol_parse.del_wrong_header(ring_buffer)\n package = self._protocol_parse.get_one_complete_package(ring_buffer)\n ring_buffer.set_clear()\n except protocol_handler.ParseTimeout,e:\n #print 'parse timeout,current buffer:'\n #logger.debug(e.message)\n ring_buffer.set_time_out()\n if ring_buffer.over_max_time():\n self._protocol_parse.pop_header(ring_buffer)\n self._protocol_parse.del_wrong_header(ring_buffer)\n logger.error('ring buffer over max timeout time,del wrong header')\n return None\n except protocol_handler.ParseError,e:\n print 'parse error'\n self._protocol_parse.pop_header(ring_buffer)\n return None\n except Exception,e:\n return None\n\n\n if package == None:\n print 'package is None'\n return None\n\n parsed_data = self._protocol_parse.parse_data(package)\n\n if parsed_data == None:\n print 'parse package failed'\n return None\n\n return parsed_data","def unpack (self, buffer):\n\t\timport struct\n\t\tvalues = struct.unpack (self.struct, buffer)\n\t\tj = 0\n\t\tfor i in self.structref:\n\t\t\tself.value[i[self.NAME]] = values[j]\n\t\t\tj = j + 1","def receive_data(self):\n chunks = []\n bytes_recd = 0\n while bytes_recd < 8:\n #I'm reading my data in byte chunks\n try:\n chunk = self.sockfd.recv(min(8 - bytes_recd, 4))\n chunks.append(chunk)\n bytes_recd = bytes_recd + len(chunk)\n except:\n print(f'{self.ip} socket failed')\n break\n # if chunk == '':\n # raise RuntimeError(\"Socket connection broken\")\n\n stat_tuple = struct.unpack('L', chunks[0])\n data_tuple = struct.unpack('L', chunks[1])\n stat = stat_tuple[0]\n data = data_tuple[0]\n return stat, chunks[1]","def _receive(self, sock, count):\n\n buf = b''\n\n while len(buf) < count:\n chunk = sock.recv(count - len(buf))\n if not chunk:\n break\n buf += chunk\n\n return buf","def length_wrapper(buf, pos):\n length, pos = self.decode_varint(buf, pos)\n end = pos+length\n output = []\n while pos < end:\n value, pos = wrapped_decoder(buf, pos)\n output.append(value)\n if pos > end:\n raise decoder._DecodeError(\"Invalid Packed Field Length\")\n return output, pos","def recv(self, bufsize: int) -> bytes:\n ...","def decode(self,buf):\n eth = dpkt.ethernet.Ethernet(buf)\n pkt_len = len(buf)\n if(eth.type== dpkt.ethernet.ETH_TYPE_IP):\n ip = eth.data\n dst_ip = socket.inet_ntoa(ip.dst)\n src_ip = socket.inet_ntoa(ip.src)\n octet_list = string.split(dst_ip,'.')\n broadcast = False\n for o in octet_list:\n if (o == \"255\"):\n broadcast = True\n break\n if((octet_list[0] == \"224\") or (octet_list[0] == \"239\")):\n broadcast = True #Its multicast actually.\n if not broadcast:\n if(ip.p == dpkt.ip.IP_PROTO_TCP):\n pass\n elif(ip.p == dpkt.ip.IP_PROTO_UDP):\n udp =ip.data\n if((udp.dport == 53) or (udp.sport == 53)): # A request. \n if(udp.dport == 53): # A request. \n return self.dns_handler.handle_dns_request(ip.src,ip.dst,ip.p,udp.sport,udp.dport,udp.data)\n if(udp.sport == 53): # A DNS response\n self.dns_handler.handle_dns_response(ip.src,ip.dst,ip.p,udp.sport,udp.dport,udp.data)\n else:\n pass","def _decode(self):\n \n self.version = int(data_to_hex_str(self.packet[0])[2])\n self.header_len = int(data_to_hex_str(self.packet[0])[3]) * 4\n self.type_of_service = data_to_hex_str(self.packet[1:2])\n self.total_len = int(data_to_hex_str(self.packet[2:4]), 16)\n self.id = data_to_hex_str(self.packet[4:6])\n \n #parse the flags fields(reservedbit, don't fragment, more fragment)\n if ((ord(self.packet[6]) & (1 << 7)) != 0):\n self.flags_reservedbit = 1\n else:\n self.flags_reservedbit = 0\n #endof if\n \n if ((ord(self.packet[6]) & (1 << 6)) != 0):\n self.flags_dont_fragment = 1\n else:\n self.flags_dont_fragment = 0\n #endof if\n \n if ((ord(self.packet[6]) & (1 << 5)) != 0):\n self.flags_more_fragment = 1\n else:\n self.flags_more_fragment = 0\n #endof if\n \n #parse the offset field(in packet[6:7]): 00011111 & packet[6] (to filter flags) -->> get packet[6:7] in hex_str\n #tmp = str(31 & ord(self.packet[6]))\n self.fragment_offset = int(data_to_hex_str(self.packet[6:8]), 16)\n if (self.fragment_offset >= (1 << 13)):\n #take away the flags fields: 00011111 11111111 & self.fragment_offset\n self.fragment_offset = self.fragment_offset & ((1 << 13) - 1) \n \n self.TTL = ord(self.packet[8])\n self.protocol = IPPROTO[ord(self.packet[9])]\n self.header_checksum = data_to_hex_str(self.packet[10:12])\n \n self.src = str(ord(self.packet[12])) + '.' + str(ord(self.packet[13])) + '.' + \\\n str(ord(self.packet[14])) + '.' + str(ord(self.packet[15]))\n self.dst = str(ord(self.packet[16])) + '.' + str(ord(self.packet[17])) + '.' + \\\n str(ord(self.packet[18])) + '.' + str(ord(self.packet[19]))\n \n if (self.header_len > 20):\n self.opt_paddings = self.packet[20 : (self.header_len)]","def unpack_sequence_from(\n fn: UnpackFn[_T], buffer: bytes, offset: int = 0\n) -> tuple[Sequence[_T], int]:\n sequence = []\n length, length_size = _unpack_length_from(buffer, offset=offset)\n offset += length_size\n item_offset = 0\n while item_offset < length:\n item, item_size = fn(buffer, offset=offset + item_offset)\n item_offset += item_size\n sequence.append(item)\n return sequence, length_size + length","def _unpack_tuple(self, buff):\n cardinality = struct_L.unpack_from(buff)[0]\n _tuple = ['']*cardinality\n offset = 4 # The first 4 bytes in the response body is the <count> we have already read\n for i in xrange(cardinality):\n field_size, offset = self._unpack_int_base128(buff, offset)\n field_data = struct.unpack_from(\"<%ds\" % field_size, buff, offset)[0]\n _tuple[i] = field(field_data)\n offset += field_size\n\n return tuple(_tuple)","def recv(self, sock):\n\n #int length is at most 4 bytes long\n hdr_bytes = sock.recv(1)\n (msg_length, hdr_length) = _DecodeVarint32(hdr_bytes, 0)\n rsp_buffer = io.BytesIO()\n if hdr_length < 4:\n rsp_buffer.write(hdr_bytes[hdr_length:])\n\n # read the remaining message bytes\n # msg_length = msg_length - (4 - hdr_length)\n while msg_length > 0:\n rsp_bytes = sock.recv(min(8096, msg_length))\n rsp_buffer.write(rsp_bytes)\n msg_length = msg_length - len(rsp_bytes)\n return rsp_buffer.getvalue()","def recv(self):\n return from_bytes(self.sock.recv(512))","def unpack(self, fmt):\n try:\n data = self.get(struct.calcsize(fmt))\n return struct.unpack(fmt, data)\n except struct.error as e:\n raise BufferError(\n \"Error unpacking struct '%s' <%s>\" %\n (fmt, binascii.hexlify(data).decode())\n )","def unpack(self, request_raw):\n request = self.mh.unpack_request(request_raw)\n if not request: return request\n # If two messages were sent, cache the second\n if request[1]: self.pending_request = request[1]\n return request[0]","def read_fifo_parse(self, n_transfers=1, timeout=0, return_remaining = False):\n \n count=5*n_transfers\n remaining_words, buffer = self.read_fifo_raw(count, timeout)\n if self.debug: print('read_fifo_parse remaining_words', remaining_words)\n \n if len(buffer) == 0:\n return np.zeros((0,10),dtype=np.uint32)\n \n # reshape to N x 5 uint64 \n buf = buffer.reshape(-1, 5)\n \n # convert to a N x 10 uint32 array\n msU32 = buf>>32\n lsU32 = buf& 0xFFFFFFFF\n wide_buf = np.concatenate( [msU32, lsU32], axis=1)\n if self.debug: print(wide_buf.shape, wide_buf.dtype)\n\n ### Reorder columns \n data = np.zeros_like(wide_buf, dtype=np.uint32)\n \n header_order = wide_buf[0]>>28 # use the first transfer headers to define order\n if self.debug: print(header_order)\n \n for jj, header in enumerate(header_order):\n # grab the 28bit data from each buffer column\n # and place it in the correct column of data\n data[:, header] = wide_buf[:, jj] & 0x0FFFFFFF \n \n if return_remaining: \n return remaining_words, data \n else: \n return data","def read_and_unpack(self, fmt):\n try:\n return unpack(\n self.byte_order + fmt,\n self.read(calcsize(self.byte_order + fmt)))\n except Exception as e:\n if e.args[0].startswith('unpack requires a buffer of'):\n raise EOFError(e)\n else:\n raise","def unwrap(self, packet_raw):\n (self.ip_ihl_ver, self.ip_tos_ecn, self.ip_tot_len, self.ip_id, self.ip_flag_frag, \\\n self.ip_ttl, self.ip_proto) = unpack('!BBHHHBB', packet_raw[0:10])\n (self.ip_check) = unpack('H', packet_raw[10:12])\n (src_addr, dest_addr) = unpack('!4s4s', packet_raw[12:20])\n\n self.ip_ihl = self.ip_ihl_ver & 0x0f\n self.ip_ver = (self.ip_ihl_ver & 0xf0) >> 4\n self.ip_tos = (self.ip_tos_ecn & 0xfc) >> 2\n self.ip_ecn = self.ip_tos_ecn & 0x03\n self.ip_flag_df = (self.ip_flag_frag & 0x40) >> 14\n self.ip_flag_mf = (self.ip_flag_frag & 0x20) >> 13\n self.ip_frag_off = self.ip_flag_frag & 0x1f\n\n self.ip_saddr = socket.inet_ntoa(src_addr)\n self.ip_daddr = socket.inet_ntoa(dest_addr)\n self.data = packet_raw[self.ip_ihl*4:self.ip_tot_len]\n\n pesudo_ip_header = packet_raw[0:10] + pack('H', 0) + packet_raw[12:20]\n new_chksum = network_chksum(pesudo_ip_header)\n if self.ip_check != new_chksum:\n raise ValueError","def retrieveData():\n\n\t# My terribad first attempt at this based off of outflank example\n\t# I honestly have no idea what I was doing, but leaving it here just in case\n\t########\n\t# try:\n\t# \tdata = transSock.recv(4)\n\t# except:\n\t# \treturn(\"\")\n\t# if len(data) < 4:\n\t# \treturn()\n\t# slen = struct.unpack('<I', data)[0]\n\t# data = transSock.recv(slen)\n\t# while len(data) < slen:\n\t# \tdata = data + transSock.recv(slen - len(data))\n\t# return(data)\n\t########\n\n\t# Realizing that I have to unpack the buffer length first:\n\n\tframeSize = \"\"\n\twhile len(frameSize) != 4:\n\t\tframeSize = connSock.recv(4)\n\n\tdataSize = struct.unpack('<I', frameSize)[0]\n\tdata = connSock.recv(dataSize)\n\n\treturn data","async def _read_pdu(\n client: AIOHomeKitBleakClient,\n decryption_key: DecryptionKey | None,\n handle: BleakGATTCharacteristic,\n tid: int,\n) -> tuple[PDUStatus, bytes]:\n data = await client.read_gatt_char(handle)\n if decryption_key:\n try:\n data = decryption_key.decrypt(bytes(data))\n except DecryptionError:\n raise EncryptionError(\"Decryption failed\")\n\n debug = logger.isEnabledFor(logging.DEBUG)\n if debug:\n logger.debug(\"Read fragment: %s\", data)\n\n # Validate the PDU header\n status, expected_length, data = decode_pdu(tid, data)\n\n # If packet is too short then there may be 1 or more continuation\n # packets. Keep reading until we have enough data.\n #\n # Even if the status is failure, we must read the whole\n # data set or the encryption will be out of sync.\n #\n while len(data) < expected_length:\n next = await client.read_gatt_char(handle)\n if decryption_key:\n try:\n next = decryption_key.decrypt(bytes(next))\n except DecryptionError:\n raise EncryptionError(\"Decryption failed\")\n if debug:\n logger.debug(\"Read fragment: %s\", next)\n\n data += decode_pdu_continuation(tid, next)\n\n return status, data","def receive(self, sock):\n # TODO: This is just a dummy receive for now. Will need to implement a real one once\n # protocol is further developed.\n data = sock.recv(2048)\n return data","def recv(recv_buffer):\n\n header_len = struct.calcsize(CCPMessage.HEADER_FMT)\n\n msgs = []\n while True:\n if len(recv_buffer) < header_len:\n #print \"AAAAAAAAAAAAAA %s \" % str(len(recv_buffer))\n return (msgs, recv_buffer)\n\n header = recv_buffer[:header_len]\n\n (version, msg_type, data_len, conn_id) = struct.unpack(\n CCPMessage.HEADER_FMT, header)\n\n DEBUG and log_debug(\"msg %d: version: %r; msg_type: %r; data_len: %u; conn_id: %r\"\n % (len(msgs), version, msg_type, data_len, conn_id))\n\n\n #print(\"msg %d: version: %r; msg_type: %r; data_len: %u; conn_id: %r\"\n # % (len(msgs), version, msg_type, data_len, conn_id))\n\n if DEBUG:\n top1 = len(recv_buffer)\n top2 = len(recv_buffer)\n if top1 > 64:\n top1 = 64\n if top2 > 128:\n top2 = 128\n\n log_debug(\"first %d bytes of data: %s\" %\n (top1, binascii.b2a_hex(recv_buffer[0:top1])))\n if top2 > 64:\n log_debug(\"second %d bytes of data: %s\" %\n (top2 - top1,\n binascii.b2a_hex(recv_buffer[top1:top2])))\n\n # check to make sure that the data_len is sane. We defer the other\n # checks until we have the entire packet, but this needs to be done\n # first in order to prevent an adversary from gumming up the\n # connection by sending an impossibly long message.\n if data_len > CCPMessage.MAX_DATA_LEN:\n #print \"BBBBBBB bad data len\"\n err_str = 'bad data_len (%u), recv_buffer len: %d' % (data_len,\n len(recv_buffer))\n CCPMessage.LOGGER.warn(err_str)\n\n raise CCPMessageUnpackError(err_str)\n\n # if we haven't received an entire message yet, then return\n #\n if len(recv_buffer) < (header_len + data_len):\n #print \"CCCCCCCCCCCCCCCCCCCCCCCC len(recv_buffer) < %s \" % str(header_len + data_len)\n #print str(len(recv_buffer))\n return (msgs, recv_buffer)\n\n if data_len == 0:\n data = None\n else:\n data = recv_buffer[header_len:header_len + data_len]\n\n recv_buffer = recv_buffer[header_len + data_len:]\n\n # Now that we have the entire message, we can decide whether it's\n # valid.\n #\n if version != CCPMessage.PROTOCOL_VERSION:\n err_str = 'bad version (%u)' % (version,)\n CCPMessage.LOGGER.warn(err_str)\n raise CCPMessageUnpackError(err_str)\n\n if not msg_type in CCPMessage.msg_types:\n err_str = 'bad msg_type (%u)' % (msg_type,)\n CCPMessage.LOGGER.warn(err_str)\n raise CCPMessageUnpackError(err_str)\n\n # The message is complete and valid. Append it to the list of\n # messages we've received.\n #\n msgs.append(CCPMessage(msg_type, conn_id=conn_id, data=data))\n\n # CCPMessage.LOGGER.debug(\"received msg_type (%u)\" %\n # (msg_type,))","def recieve_data(self):\r\n try:\r\n while True:\r\n try:\r\n data, self.addr = self.sock.recvfrom(1024)\r\n return data\r\n except socket.timeout:\r\n print(\"There is no packet at all!\")\r\n break\r\n except Exception:\r\n print(\"Can't recieve a package\")","def recvData(self) -> bytes:\n \n packet = self.recvPacket()\n if(packet.seq == Rudp.ackPlusOne(self.ack)):\n self.ack = Rudp.ackPlusOne(self.ack)\n self.acknowledgePacket(packet)\n return packet.payload\n else:\n return None","def recv_bin_data(sock):\n mess = b''\n\n # Receive data until we have a full header\n mess_current_length = len(mess)\n while mess_current_length < LSPInfo.bin_header_size:\n mess += sock.recv(LSPInfo.bin_header_size) # Receive the header\n mess_current_length = len(mess) # Current length of the message\n\n # Check error code in header\n header = struct.unpack(LSPInfo.fmt_header, mess)\n error_code = header[-1]\n # If bad error code, close socket and return\n if error_code != 0:\n print('[LSP] Error code of %i. Communication terminated!' % i)\n sock.close()\n return\n\n # If error code is good, find size of message\n mess_len_total = header[-2]\n\n # Loop to receive bytes until we have the entire message\n while mess_current_length < mess_len_total:\n bytes_left = mess_len_total - mess_current_length # How many more bytes need to be received\n mess += sock.recv(bytes_left) # Try to receive those bytes\n mess_current_length = len(mess) # Current length of the message\n\n if mess_current_length > mess_len_total:\n print('Warning! More bytes received than expected') # Warning if we have too much data\n # If we have more data than a single message, extract the single scan and add rest of data to 'message'\n complete_scan = mess[:mess_len_total]\n # Otherwise the complete scan is just equal to the whole message\n else:\n complete_scan = mess\n\n unpacked_mess = LSPInfo.bin_unpacker.unpack(complete_scan) # Unpack message data\n\n return unpacked_mess","def recv(self):\r\n try:\r\n self.lock.acquire()\r\n length, = struct.unpack(self.HEADER_FORMAT, self.stream.read(self.HEADER_SIZE))\r\n return self.stream.read(length)\r\n finally:\r\n self.lock.release()","def recibir(self):\r\n lenbuf = self.__recvall(4)\r\n longitud, = struct.unpack('!I', lenbuf)\r\n return self.__recvall(longitud)","def _recvall(conn, n):\n data = b''\n while len(data) < n:\n packet = conn.recv(n - len(data))\n if not packet:\n return None\n data += packet\n return data","def unpack(self, data_type):\n\t\tif data_type in data_types:\n\t\t\tformat = data_types[data_type]\n\t\t\treturn self.unpack_real(format[0], format[1])\n\t\t\n\t\tif data_type == \"string8\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:length]\n\t\t\tself.buff = self.buff[length:]\n\t\t\treturn string\n\t\tif data_type == \"string16\":\n\t\t\tlength = self.unpack('short')\n\t\t\tif length < 0:\n\t\t\t\traise Exception(\"Negative length for string\")\n\t\t\tif len(self.buff) < 2*length:\n\t\t\t\traise IncompleteData()\n\t\t\tstring = self.buff[:2*length].decode('utf-16be')\n\t\t\tself.buff = self.buff[2*length:]\n\t\t\treturn string\n\t\tif data_type == \"slot\":\n\t\t\to = {}\n\t\t\to[\"id\"] = self.unpack('short')\n\t\t\tif o[\"id\"] > 0:\n\t\t\t\to[\"amount\"] = self.unpack('byte')\n\t\t\t\to[\"damage\"] = self.unpack('short')\n\t\t\tif o[\"id\"] in SLOT_EXTRA_DATA_IDS:\n\t\t\t\textra_len = self.unpack('short')\n\t\t\t\tif extra_len <= 0:\n\t\t\t\t\to[\"extra\"] = None\n\t\t\t\telse:\n\t\t\t\t\tif len(self.buff) < extra_len:\n\t\t\t\t\t\traise IncompleteData()\n\t\t\t\t\textra_buff = self.buff[:extra_len]\n\t\t\t\t\tself.buff = self.buff[extra_len:]\n\t\t\t\t\to[\"extra\"] = extra_buff\n\t\t\treturn o\n\t\tif data_type == \"metadata\":\n\t\t\t#[(17, 0), (0, 0), (16, -1)]\n\t\t\to = []\n\t\t\tmtype = self.unpack('byte')\n\t\t\twhile mtype != 127:\n\t\t\t\tmtype2 = mtype >> 5\n\t\t\t\tt = 0\n\t\t\t\tif mtype2 == 0: t = self.unpack('byte') \n\t\t\t\tif mtype2 == 1: t = self.unpack('short') \n\t\t\t\tif mtype2 == 2: t = self.unpack('int') \n\t\t\t\tif mtype2 == 3: t = self.unpack('float') \n\t\t\t\tif mtype2 == 4: t = self.unpack('string16')\n\t\t\t\tif mtype2 == 5:\n\t\t\t\t\tt = {}\n\t\t\t\t\tt[\"id\"] = self.unpack('short')\n\t\t\t\t\tt[\"count\"] = self.unpack('byte')\n\t\t\t\t\tt[\"damage\"] = self.unpack('short')\n\t\t\t\tif mtype2 == 6:\n\t\t\t\t\tt = []\n\t\t\t\t\tfor i in range(3):\n\t\t\t\t\t\ts = self.unpack('int')\n\t\t\t\t\t\tt.append(s)\n\t\t\t\tt = (mtype, t)\n\t\t\t\to.append(t)\n\t\t\t\tmtype = self.unpack('byte')\n\t\t\treturn o","def recv(self,bytes,blocking=False):\r\n # Check input sanity\r\n if bytes <= 0:\r\n raise ValueError, \"Must read a positive integer number of bytes!\"\r\n \r\n # Check if the socket is closed\r\n self._handleClosed_recv()\r\n \r\n # Block until there is data\r\n # This lock is released whenever new data arrives, or if there is data remaining to be read\r\n self.socketLocks[\"nodata\"].acquire()\r\n try:\r\n self.socketLocks[\"nodata\"].release()\r\n except:\r\n # Some weird timing issues can cause an exception, but it is harmless\r\n pass\r\n \r\n # Check if the socket is closed\r\n self._handleClosed_recv()\r\n \r\n # Get our own lock\r\n self.socketLocks[\"recv\"].acquire()\r\n \r\n # Read up to bytes\r\n data = self.buffer[:bytes] \r\n amountIn = len(data)\r\n \r\n # Remove what we read from the buffer\r\n self.buffer = self.buffer[bytes:] \r\n \r\n # Reduce amount of incoming data available\r\n self.bufferInfo[\"incoming\"] -= amountIn\r\n \r\n # Check if there is more incoming buffer available, if not, send a MULTIPLEXER_CONN_BUF_SIZE\r\n # This does not count against the outgoingAvailable quota\r\n if self.bufferInfo[\"incoming\"] <= 0:\r\n # Create MULTIPLEXER_CONN_BUF_SIZE frame\r\n buf_frame = MultiplexerFrame()\r\n buf_frame.initConnBufSizeFrame(self.id, self.mux.defaultBufSize)\r\n \r\n # Send it\r\n try:\r\n self.mux._sendFrame(buf_frame)\r\n except:\r\n # The multiplexer may be closed\r\n # Check if the socket is closed\r\n self._handleClosed()\r\n \r\n # Increase our incoming buffer\r\n self.bufferInfo[\"incoming\"] = self.mux.defaultBufSize\r\n \r\n # Set the no data lock if there is none\r\n if len(self.buffer) == 0:\r\n self.socketLocks[\"nodata\"].acquire()\r\n \r\n # Release the lock\r\n self.socketLocks[\"recv\"].release() \r\n \r\n # Are we supposed to block?\r\n if blocking and amountIn < bytes:\r\n # How much more do we need?\r\n more = bytes - amountIn\r\n \r\n # Try to recieve the extra, recursively call ourself\r\n moreData = self.recv(more, True)\r\n \r\n # Return the original data, plus the extra\r\n return (data + moreData)\r\n # Otherwise, just return what we have\r\n else:\r\n return data","def read(self, l):\n\t\twhile l > len(self.buf):\n\t\t\tself.buf += self.conn.recv(4096)\n\n\t\tobuf = self.buf\n\t\tself.buf = obuf[l:]\n\t\treturn obuf[:l]","def _pop_received_packet(self):\n fragments = self._receive_heap.pop_min_and_all_fragments()\n if fragments is None:\n self._attempt_disabling_looping_receive()\n else:\n last_seqnum = fragments[-1].sequence_number\n self._update_next_expected_seqnum(last_seqnum)\n self._update_next_delivered_seqnum(last_seqnum)\n payload = b''.join(f.payload for f in fragments)\n self.handler.receive_message(payload)\n\n if self._next_delivered_seqnum not in self._receive_heap:\n self._attempt_disabling_looping_receive()","def unpack(self, buf):\n super().unpack(buf) # unpacks _hdr\n\n if self.hdr_type != APv6Udp.HDR_TYPE:\n raise dpkt.UnpackError(\"Unpacking compressed UDP, but encountered wrong type value\")\n\n if self.hdr_co == 0:\n if len(self.data) < 2:\n raise dpkt.NeedData(\"for UDP checksum\")\n self.chksum = struct.unpack(\"!H\", self.data[0:2])[0]\n self.data = self.data[2:]\n\n p = self.hdr_ports\n if p == APv6Udp.HDR_PORTS_SRC_INLN_DST_INLN:\n if len(self.data) < 4:\n raise dpkt.NeedData(\"for UDP ports\")\n self.src_port = struct.unpack(\"!H\", self.data[0:2])[0]\n self.dst_port = struct.unpack(\"!H\", self.data[2:4])[0]\n self.data = self.data[4:]\n elif p == APv6Udp.HDR_PORTS_SRC_INLN_DST_F0XX:\n if len(self.data) < 3:\n raise dpkt.NeedData(\"for UDP ports\")\n self.src_port = struct.unpack(\"!H\", self.data[0:2])[0]\n self.dst_port = 0xf000 | self.data[2]\n self.data = self.data[3:]\n elif p == APv6Udp.HDR_PORTS_SRC_F0XX_DST_INLN:\n if len(self.data) < 3:\n raise dpkt.NeedData(\"for UDP ports\")\n self.src_port = 0xf000 | self.data[0]\n self.dst_port = struct.unpack(\"!H\", self.data[1:3])[0]\n self.data = self.data[3:]\n elif p == APv6Udp.HDR_PORTS_SRC_F0BX_DST_F0BX:\n if len(self.data) < 1:\n raise dpkt.NeedData(\"for UDP ports\")\n d = self.data[0]\n self.src_port = 0xf0b0 | ((d >> 4) & 0b1111)\n self.dst_port = 0xf0b0 | (d & 0b1111)\n self.data = self.data[1:]","def unpack_bytes(self, num_bytes):\n buf = self.view[0:num_bytes]\n\n self.num_bytes_consumed += num_bytes\n self.view = self.view[num_bytes:]\n\n return num_bytes, buf","def unpack_serializable_from(\n buffer: bytes, offset: int = 0\n) -> tuple[serializable_lib.Serializable, int]:\n module_name, module_name_size = unpack_str_from(buffer, offset=offset)\n offset += module_name_size\n class_name, class_name_size = unpack_str_from(buffer, offset=offset)\n offset += class_name_size\n serializable_length, serializable_length_size = _unpack_length_from(\n buffer, offset=offset\n )\n offset += serializable_length_size\n serializable_bytes, *_ = struct.unpack_from(\n f'!{serializable_length}s', buffer, offset=offset\n )\n module = importlib.import_module(module_name)\n cls = getattr(module, class_name)\n value = cls.from_bytes(serializable_bytes)\n return value, (\n module_name_size\n + class_name_size\n + serializable_length_size\n + serializable_length\n )","def recv(self, count: Optional[int] = None) -> bytes:\n\n if self.peek_buffer:\n data = self.peek_buffer[:count]\n self.peek_buffer = self.peek_buffer[count:]\n\n if len(data) >= count:\n return data\n else:\n data = b\"\"\n\n data += self.client.recv(count - len(data))\n\n return data","def parsePacket(self, packet):\n \n pcktParts = packet.split()\n \n # needs exactly 4 parts\n if len(pcktParts) != 4:\n raise PacketException(\"Packet malformed.\")\n \n direction = pcktParts[0]\n ip = pcktParts[1]\n port = pcktParts[2]\n flag = pcktParts[3]\n\n try:\n pckt = Packet(direction, ip, port, flag)\n except Exception as ex:\n eprint(\"Corrupt Packet:{0} Ignoring packet:\\n{1}\".format(ex, packet.__str__()))\n return None\n \n return pckt","def unpack(self, packedData):\n raise NotImplementedError, 'Method need to be overriden'","def get_data(self):\n\n data = self.socket.recv(BUFFER_SIZE)\n\n if not data:\n return None\n\n if len(data) == BUFFER_SIZE:\n while True:\n try:\n data += self.socket.recv(BUFFER_SIZE)\n except:\n break\n \n return data","def __recv(self):\n in_buffer = \"\"\n self.__ser.reset_input_buffer()\n while True:\n data_in = self.__ser.read(64)\n if not in_buffer and not data_in:\n time.sleep(0.1)\n continue\n if self.__debug:\n print \"<<< %s\" % binascii.hexlify(data_in)\n in_buffer += data_in\n if len(in_buffer) < 6:\n continue\n msg_id, param1, param2, dst, src = struct.unpack(\"<HBBBB\", in_buffer[0:6])\n msg_len = 6\n if dst | 0x80:\n # Packet is long format\n dst &= 0x7F\n msg_len += ((param2 << 8) | param1)\n # Check this message is from the controller and for us\n if dst != self.__src or src != self.__dst:\n in_buffer = \"\"\n continue\n if len(in_buffer) < msg_len:\n # Message is incomplete\n continue\n # Now look for messages we recognise\n if msg_id == self.MGMSG_MOT_GET_STATUSUPDATE:\n self.__decode_status(in_buffer[6:msg_len])\n in_buffer = in_buffer[msg_len:]\n continue\n elif msg_id == self.MGMSG_MOT_MOVE_COMPLETED:\n in_buffer = in_buffer[msg_len:]\n continue\n elif msg_id == self.MGMSG_MOT_MOVE_HOMED:\n in_buffer = in_buffer[msg_len:]\n continue\n # If we got here, the message was invalid\n # Clear the buffer to resynchronise\n in_buffer = \"\"\n continue","def __tcp_recv(self):\n total_data = []\n bs = 1024\n try:\n data = self.__sock.recv(bs)\n total_data.append(data)\n while True and data:\n if not re.search(\"L: (\\d+)\",data) and not data[-4:] == '\\r\\n\\r\\n':\n data = self.__sock.recv(bs)\n total_data.append(data)\n elif not re.search(\"L: (\\d+)\",data) and data[-4:] == '\\r\\n\\r\\n':\n return total_data\n else:\n break\n \n\n while re.search(\"L: (\\d+)\",data):\n n = len(data)\n L = int(re.findall(\"L: (\\d+)\",data)[-1])\n p = data.rfind('\\r\\n\\r\\n')\n abc = data\n data = ''\n\n p1 = data.rfind(str(L))\n if p < p1:\n log(\"rn before L\")\n left = L + n - (p1 + len(str(L))) + 4\n\n else:\n left = L - (n - p -4)\n if left == L:\n log(\"It happened!\")\n break\n\n #if more bytes then last L\n #come across another command: BN etc.\n #read until another L come\n if left < 0:\n log('abc')\n d = ''\n left = 0\n while True:\n d = self.__sock.recv(bs)\n data += d\n if re.search(\"L: (\\d+)\",d):\n break\n log(\"read left bytes\")\n log('data:'+data)\n total_data.append(data)\n\n #read left bytes in last L\n while left:\n data = self.__sock.recv(left)\n n = len(data)\n left = left - n\n\n if not data:\n break\n total_data.append(data)\n\n except socket.error,e:\n #self.__sock.close()\n raise PyFetionSocketError(e)\n\n return self.__split(''.join(total_data))\n\n #return ''.join(total_data)","def _recv(self):\n msg = b''\n try:\n count = 0\n while count < self.RECV_LIMIT:\n data = self.socket.recv(self.BUFFER_SIZE)\n \n if not data: break\n msg += data\n count+=1\n except: pass \n finally:\n return msg.decode(self.ENCODING)","def receive(self):\n raw_msglen = self.recvall(4)\n if not raw_msglen:\n return None\n msglen = stc.unpack('>I', raw_msglen)[0]\n # Read the message data\n return self.recvall(msglen)","def recv(self) -> Optional[bytes]:\n ready, _, _ = select.select([self.socket], [], [], 0)\n if len(ready) != 0:\n new_bytes = self.socket.recv(self.BUFFER_SIZE)\n self.__recv_buffer = self.__recv_buffer + new_bytes\n return self.__parse_one_message()","def grab_frame(self):\n with self._buflock:\n if self._buffer is None:\n return None\n buf = self._buffer.tostring()\n return buf","def RPC_decode(sock,blocking=False):\r\n # Get the dictionary length\r\n # Then, Get the dictionary\r\n if blocking:\r\n length = int(sock.recv(RPC_FIXED_SIZE,blocking=True))\r\n dict_str = sock.recv(length,blocking=True)\r\n else:\r\n length = int(sock.recv(RPC_FIXED_SIZE))\r\n dict_str = sock.recv(length)\r\n \r\n dict_obj = deserialize(dict_str) # Convert to object\r\n return dict_obj","def parse(self, data: bytes, parse_ts=True) -> tuple:\n sync_offset = data.find(b'\\x47')\n if sync_offset == -1: # No sync bit in packet\n return None, None, len(data)\n if sync_offset != 0: # Resync\n data = data[sync_offset:]\n for i in range(int(len(data) / self.__psize)):\n if sync_offset != 0:\n self.__resync = sync_offset\n sync_offset = 0\n else:\n self.__resync = 0\n packet = data[:self.__psize]\n data = data[self.__psize:]\n if len(packet) < self.__psize:\n yield None, None, len(packet)\n parsed = None\n if parse_ts:\n parsed = self.__parse(packet)\n yield packet, parsed, self.__resync","def read_pkt_line(self):\n if self._readahead is None:\n read = self.read\n else:\n read = self._readahead.read\n self._readahead = None\n\n try:\n sizestr = read(4)\n if not sizestr:\n raise HangupException()\n size = int(sizestr, 16)\n if size == 0:\n if self.report_activity:\n self.report_activity(4, \"read\")\n return None\n if self.report_activity:\n self.report_activity(size, \"read\")\n pkt_contents = read(size - 4)\n except socket.error as e:\n raise GitProtocolError(e)\n else:\n if len(pkt_contents) + 4 != size:\n raise GitProtocolError(\n \"Length of pkt read %04x does not match length prefix %04x\"\n % (len(pkt_contents) + 4, size)\n )\n return pkt_contents","def readpacket(self, n):\n try:\n msg = self.sock.recv(n)\n except BaseException:\n msg = ''\n return msg","def receive(self, packet):\n packet_key = (packet.src, packet.dest)\n # receiving wan\n if packet.dest in self.address_to_port:\n # The packet is destined to one of the clients connected to this middlebox;\n # send the packet there.\n\n if not packet.is_raw_data:\n block = self.hash_payloads[packet.payload]\n self.send_block(block, packet_key, packet.is_fin, False)\n else:\n self.add_packet_to_buffer(packet_key, packet)\n curr_block = self.buffers[packet_key]\n block_length = len(curr_block)\n left = 0\n right = 48 if block_length >= 48 else block_length\n while right <= block_length:\n block = curr_block[left:right]\n block_hash = utils.get_hash(block)\n is_delimiter = utils.get_last_n_bits(block_hash, 13) == self.GLOBAL_MATCH_BITSTRING\n if is_delimiter:\n send_block = curr_block[:right]\n curr_block = curr_block[right:]\n self.buffers[packet_key] = curr_block\n self.determine_if_hashed(send_block, packet_key, packet.is_fin, False)\n left = right\n if block_length - right >= 48:\n right = right + 48\n else:\n right = block_length\n if packet.is_fin:\n send_block = curr_block[left: block_length]\n self.determine_if_hashed(send_block, packet_key, True, False)\n self.buffers.pop(packet_key, None)\n break\n else:\n left = left + 1\n right = right + 1\n if packet_key in self.buffers:\n if packet.is_fin:\n send_block = self.buffers[packet_key]\n self.determine_if_hashed(send_block, packet_key, True, False)\n self.buffers.pop(packet_key, None)\n else:\n self.buffers.pop(packet_key, None)\n # sending wan\n else:\n # The packet must be destined to a host connected to the other middlebox\n # so send it across the WAN.\n\n self.add_packet_to_buffer(packet_key, packet)\n curr_block = self.buffers[packet_key]\n block_length = len(curr_block)\n left = 0\n right = 48 if block_length >= 48 else block_length\n while right <= block_length:\n block = curr_block[left:right]\n block_hash = utils.get_hash(block)\n is_delimiter = utils.get_last_n_bits(block_hash, 13) == self.GLOBAL_MATCH_BITSTRING\n if is_delimiter:\n send_block = curr_block[:right]\n curr_block = curr_block[right:]\n self.buffers[packet_key] = curr_block\n self.determine_if_hashed(send_block, packet_key, packet.is_fin, True)\n left = right\n if block_length - right >= 48:\n right = right + 48\n else:\n right = block_length\n if packet.is_fin:\n send_block = curr_block[left: block_length]\n self.determine_if_hashed(send_block, packet_key, True, True)\n self.buffers.pop(packet_key, None)\n break\n else:\n left = left + 1\n right = right + 1\n if packet_key in self.buffers:\n if packet.is_fin:\n send_block = self.buffers[packet_key]\n self.determine_if_hashed(send_block, packet_key, True, True)\n self.buffers.pop(packet_key, None)\n else:\n self.buffers.pop(packet_key, None)","def _extract_buffer(self, sample: Gst.Sample) -> typ.Optional[GstBuffer]:\n buffer = sample.get_buffer()\n caps = sample.get_caps()\n\n cnt = buffer.n_memory()\n if cnt <= 0:\n self.log.warning(\"%s No data in Gst.Buffer\", self)\n return None\n\n memory = buffer.get_memory(0)\n if not memory:\n self.log.warning(\"%s No Gst.Memory in Gst.Buffer\", self)\n return None\n\n array = gst_buffer_with_caps_to_ndarray(buffer, caps, do_copy=True)\n\n return GstBuffer(\n data=array,\n pts=buffer.pts,\n dts=buffer.dts,\n duration=buffer.duration,\n offset=buffer.offset,\n )","def peek_rear(self):\n if len(self) == 0:\n if self.none_for_empty:\n return None\n raise ValueError(\"Buffer is empty\")\n return self.buf[self.rear]","def _unpack_body(self, buff):\n\n # Unpack <return_code> and <count> (how many records affected or selected)\n self._return_code = struct_L.unpack_from(buff, offset=0)[0]\n\n # Separate return_code and completion_code\n self._completion_status = self._return_code & 0x00ff\n self._return_code >>= 8\n\n # In case of an error unpack the body as an error message\n if self._return_code != 0:\n self._return_message = unicode(buff[4:-1], self.charset, self.errors)\n if self._completion_status == 2:\n raise TarantoolError(self._return_code, self._return_message)\n\n # Unpack <count> (how many records affected or selected)\n self._rowcount = struct_L.unpack_from(buff, offset=4)[0]\n\n # If the response doesn't contain any tuple - there is nothing to unpack\n if self._body_length == 8:\n return\n\n # Parse response tuples (<fq_tuple>)\n if self._rowcount > 0:\n offset = 8 # The first 4 bytes in the response body is the <count> we have already read\n while offset < self._body_length:\n # In resonse tuples have the form <size><tuple> (<fq_tuple> ::= <size><tuple>).\n # Attribute <size> takes into account only size of tuple's <field> payload,\n # but does not include 4-byte of <cardinality> field.\n #Therefore the actual size of the <tuple> is greater to 4 bytes.\n tuple_size = struct.unpack_from(\"<L\", buff, offset)[0] + 4\n tuple_data = struct.unpack_from(\"<%ds\" % (tuple_size), buff, offset+4)[0]\n tuple_value = self._unpack_tuple(tuple_data)\n if self.field_types:\n self.append(self._cast_tuple(tuple_value))\n else:\n self.append(tuple_value)\n\n offset = offset + tuple_size + 4 # This '4' is a size of <size> attribute","def wait_packet(self, clazz):\n while True:\n pkt = PacketRegistry.decode(self.read())\n if isinstance(pkt, clazz):\n return pkt","def packet_from_bytes(data: bytes) -> Packet:\n packet = PacketBase.from_buffer_copy(data)\n struct = packet.struct_type()\n if len(data) != struct.SIZE:\n raise racetools.errors.PacketSizeMismatch(struct.SIZE, len(data))\n return struct.from_buffer_copy(data)","def _decode_message(self, label: str, buf, typedef=None, pos=0, end=None, group=False):\n print(str(pos) + \" decode_message \" + label)\n if end is None:\n end = len(buf)\n\n if typedef is None:\n typedef = {}\n else:\n # Don't want to accidentally modify the original\n typedef = copy.deepcopy(typedef)\n output = {}\n\n while pos < end:\n oldpos = pos\n tag, pos = decoder._DecodeVarint(buf, pos)\n try:\n field_number, wire_type = wire_format.UnpackTag(tag)\n except Exception as exc:\n raise (ValueError,\n 'Could not read valid tag at pos %d. Ensure it is a valid protobuf message: %s'\n % (pos-len(tag), exc), sys.exc_info()[2])\n # Convert to str\n field_number = str(field_number)\n orig_field_number = field_number\n \n field_typedef = None\n if field_number in typedef:\n field_typedef = typedef[field_number]\n else:\n field_typedef = {}\n field_typedef['type'] = self.wire_type_defaults[wire_type]\n field_type = field_typedef['type']\n if self.debug:\n ft = field_type\n if ft == None:\n ft = \"None\"\n print(\"@\" + str(oldpos) + \"-\" + str(pos-1) + \":\" + label + \" field_number \" +\n str(field_number) +\n \" wire_type \" + str(wire_type) +\n \" field_type \" + str(ft))\n # If field_type is None, its either an unsupported wire type, length delim or group\n # length delim we have to try and decode first\n field_out = None\n if field_type == 'LD':\n field_out, pos = self.decode_message_LD(label, buf, pos, field_typedef)\n elif field_type == 'endGroup':\n # TODO Should probably match the field_number to START_GROUP\n if not group:\n raise ValueError(\"Found END_GROUP before START_GROUP\")\n # exit out\n return output, typedef, pos\n elif field_type == 'message':\n field_out, pos = self.decode_message_message(\n label, buf, pos, field_typedef, field_number)\n elif field_type == 'group':\n group_typedef = None\n # Check for a anonymous type\n if 'group_typedef' in field_typedef:\n group_typedef = field_typedef['group_typedef']\n field_out, group_typedef, pos = self.decode_group(\n label, buf, group_typedef, pos)\n # Save type definition\n field_typedef['group_typedef'] = group_typedef\n else:\n # Verify wiretype matches\n if self.wiretypes[field_type] != wire_type:\n raise ValueError(\"Invalid wiretype for field number %s. %s is not wiretype %s\"\n % (field_number, field_type, wire_type))\n # Simple type, just look up the decoder\n field_out, pos = self.decoders[field_type](buf, pos)\n field_typedef['type'] = field_type\n if 'name' not in field_typedef:\n field_typedef['name'] = ''\n field_key = field_number\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\n field_key = field_typedef['name']\n # Deal with repeats\n if field_key in output:\n if isinstance(field_out, list):\n if isinstance(output[field_number], list):\n output[field_key] += field_out\n else:\n output[field_key] = field_out.append(output[field_key])\n else:\n if isinstance(output[field_number], list):\n output[field_key].append(field_out)\n else:\n output[field_key] = [output[field_key], field_out]\n else:\n output[field_key] = field_out\n typedef[orig_field_number] = field_typedef\n if self.debug:\n print(str(field_key) + \" field_out:\" + str(field_out))\n if pos > end:\n raise decoder._DecodeError(\"Invalid Message Length, pos=\" +\n str(pos) + \" end=\" + str(end))\n # Should never hit here as a group\n if group:\n raise ValueError(\"Got START_GROUP with no END_GROUP.\")\n print(\"decode_message finish \" + str(pos))\n return output, typedef, pos","def _get_discard_packet(self):\n return self.__discard_packet","def recvtil(self, delim):\n buf = b''\n # TODO maybe not make this O(n**2)...\n while not delim in buf:\n buf += self.recv(1)\n return buf","def ReceiveMessageFromPacketInfo(self) -> IPPacketInformation:","def _parse_packet(packet: StreamMessageResponse) -> Packet:\n if packet is None:\n raise TypeError(\"Packet cannot be None!\")\n\n packet = MessageToDict(packet)\n\n # Decoding Header\n ingress_port_base64 = packet['packet']['metadata'][0]['value'].encode()\n ingress_port = base64.decodebytes(ingress_port_base64) # retrieving ingress_port; not used, yet\n\n # Decoding Payload\n packet = _scapy_parse(packet)\n\n return packet","def _read_fixed(buf, length):\n result = buf.read(length)\n actual = len(result)\n if actual != length:\n raise EndOfMessage(False if actual == 0 else True)\n return result","def remove_buffered_packets(self):\n seq = self.next_seq\n while True:\n p = self.buffer.pop(seq, None)\n if p is None:\n break\n else:\n seq += len(p.data)\n yield p"],"string":"[\n \"def read_packet(self):\\n\\n\\t\\t#self.debug(\\\"READ BUFFER SIZE: %d\\\" % len(self.buff))\\n\\t\\tbackup = self.buff[:]\\n\\t\\tpacket = Packet()\\n\\t\\ttry:\\n\\t\\t\\tpacket.direction = self.node\\n\\t\\t\\tpacket.ident = self.unpack('ubyte')\\n\\t\\t\\t\\n\\t\\t\\t#Defined structs from huge dict\\n\\t\\t\\tfor datatype, name in self.get_struct(packet):\\n\\t\\t\\t\\t# this populates packet.data with {name: value}\\n\\t\\t\\t\\tpacket.data[name] = self.unpack(datatype)\\n\\n\\t\\t\\t# I believe the following are packet-type specific fixes for variable-length packets.\\n\\n\\t\\t\\t#0x17\\n\\t\\t\\tif packet.ident == 0x17:\\n\\t\\t\\t\\tif packet.data['unknown'] > 0:\\n\\t\\t\\t\\t\\tpacket.data['x2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['y2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['z2'] = self.unpack('short')\\n\\t\\t\\n\\t\\t\\t#0x33\\n\\t\\t\\tif packet.ident in (0x33, 0x34):\\n\\t\\t\\t\\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n#\\t\\t\\t#0x34\\n#\\t\\t\\tif packet.ident == 0x34:\\n#\\t\\t\\t\\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\\n#\\t\\t\\t\\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n#\\t\\t\\t\\tfor i in zip(coords, btype, metadata):\\n#\\t\\t\\t\\t\\tblock = {}\\n#\\t\\t\\t\\t\\tblock[\\\"x\\\"] =\\t\\ti[0] >> 12\\n#\\t\\t\\t\\t\\tblock[\\\"z\\\"] = 0x0F & i[0] >> 8\\n#\\t\\t\\t\\t\\tblock[\\\"y\\\"] = 0xFF & i[0]\\n#\\t\\t\\t\\t\\tblock[\\\"type\\\"] = i[1]\\n#\\t\\t\\t\\t\\tblock[\\\"metadata\\\"] = i[2]\\n#\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(block)\\n#\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x3C\\n\\t\\t\\tif packet.ident == 0x3C:\\n\\t\\t\\t\\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\\n\\t\\t\\t\\ti = 0\\n\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n\\t\\t\\t\\twhile i < packet.data['data_size']*3:\\n\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(dict(zip(('x','y','z'), records[i:i+3])))\\n\\t\\t\\t\\t\\ti+=3\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x68\\n\\t\\t\\tif packet.ident == 0x68:\\n\\t\\t\\t\\tpacket.data[\\\"slots_data\\\"] = self.unpack_array('slot', packet.data[\\\"data_size\\\"])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\t#0x82:\\n\\t\\t\\tif packet.ident == 0x82:\\n\\t\\t\\t\\tpacket.data[\\\"text\\\"] = []\\n\\t\\t\\t\\tfor i in range(4):\\n\\t\\t\\t\\t\\tpacket.data[\\\"text\\\"].append(packet.data[\\\"line_%s\\\" % (i+1)])\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t#0x83\\n\\t\\t\\tif packet.ident == 0x83:\\n\\t\\t\\t\\tpacket.data[\\\"data\\\"] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\n\\t\\t\\t# Sets packet.original to the byte string that the packet was decoded from.\\n\\t\\t\\tpacket.original = backup[:len(backup) - len(self.buff)]\\n\\n\\t\\t\\treturn packet\\n\\n\\t\\texcept IncompleteData:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\treturn None\\n\\t\\texcept Exception, ex:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\tex.args += (self.buff[20:],)\\n\\t\\t\\traise\",\n \"def recv_packet(self):\\r\\n self.recv_bytes()\\r\\n\\r\\n packet_length_index = 0\\r\\n \\r\\n amount_data = len(self.recvBuffer) # available amount of data to read\\r\\n \\r\\n if amount_data <= packet_length_index: # just 0's in the buffer\\r\\n return None\\r\\n\\r\\n if len(self.recvBuffer) <= packet_length_index + 2: # length not received\\r\\n return None\\r\\n \\r\\n packet_length = unpack(self.recvBuffer, packet_length_index, 'H')\\r\\n \\r\\n if packet_length > len(self.recvBuffer): # packet not fully received\\r\\n return None\\r\\n \\r\\n if packet_length == 0: # some wrong generated packet by server, inc position of reading packet length\\r\\n packet_length_index += 1\\r\\n return None\\r\\n\\r\\n\\t\\t# extract packet data\\r\\n packet = self.recvBuffer[packet_length_index:packet_length_index+packet_length]\\r\\n\\r\\n # remaining recv buffer\\r\\n self.recvBuffer = self.recvBuffer[packet_length_index + packet_length:]\\r\\n packet_length_index = 0 # next packet length should be at pos 0 again\\r\\n\\r\\n return packet\",\n \"def extract_packet(_buffer):\\n if len(_buffer)>=5:\\n mtype=_buffer[0]\\n msglen=struct.unpack('!L',_buffer[1:5])[0]\\n if len(_buffer)>=msglen+1:\\n return _buffer[5:msglen+1],mtype,_buffer[msglen+1:]\\n return None,None,_buffer\",\n \"def recv(self) -> tuple:\\n (data, c) = self.socket.recvfrom(Rudp.Packet.buffer())\\n # print(data)\\n (packet, validity) = Rudp.Packet.unpack(data)\\n if(validity):\\n print(\\\"Valid Packet Received From: \\\", c)\\n else:\\n raise Rudp.InvalidPacket(\\\"Invalid Packet Received\\\")\\n\\n return (packet, validity, c)\",\n \"def recv_raw(self) -> Dict[str, Any]:\\n while True:\\n try:\\n packet = self.__recv_frame()\\n except UnknownPacketException:\\n continue\\n\\n # Hack for sniffing on localhost\\n if packet['address']['interface'] == 'lo' and packet['address']['type'] != 4:\\n continue\\n\\n if self.address and self.port:\\n if (\\n packet['ip_header']['source_address'] == self.address and\\n packet['tcp_header']['source_port'] == self.port\\n ):\\n return packet\\n if (\\n packet['ip_header']['destination_address'] == self.address and\\n packet['tcp_header']['destination_port'] == self.port\\n ):\\n return packet\\n elif self.address:\\n if (\\n packet['ip_header']['source_address'] == self.address or\\n packet['ip_header']['destination_address'] == self.address\\n ):\\n return packet\\n elif self.port:\\n if (\\n packet['tcp_header']['source_port'] == self.port or\\n packet['tcp_header']['destination_port'] == self.port\\n ):\\n return packet\\n else:\\n return packet\",\n \"def recv_bundle(self):\\n hdr_raw = sock_recv_raw(self.sock, 6, self.timeout)\\n data_length, has_secondary = SPPPacketHeader.preparse_data_length(\\n hdr_raw\\n )\\n data_plus_secondary = sock_recv_raw(\\n self.sock,\\n data_length,\\n self.timeout,\\n )\\n packet, _ = SPPPacket.parse(\\n hdr_raw + data_plus_secondary,\\n timecode_used=True,\\n has_crc=self.use_crc,\\n )\\n if self.use_crc:\\n assert packet.crc_provided == packet.crc()\\n return packet.payload\",\n \"def from_network_layer(buffer):\\r\\n packet = buffer.get_packet()\\r\\n # print(f'buffer.message:{buffer.message}')\\r\\n # if packet == None:\\r\\n # print(f\\\"[from_network_layer] packet:NULL\\\")\\r\\n print(f\\\"[from_network_layer] packet:{packet}\\\")\\r\\n return packet\",\n \"def receive(self) -> [Packet, None]:\\n packet_size_data = self._stream.read(2)\\n if not packet_size_data:\\n return None\\n packet_size = int.from_bytes(packet_size_data, 'little')\\n packet_data = self._stream.read(packet_size)\\n return packet_from_bytes(packet_data)\",\n \"def decode(self, buf=None):\\n if buf is None:\\n buf = self.receive()\\n \\n return decode_network_packet(buf)\",\n \"def recv_data(self):\\n data = \\\"\\\"\\n size = 0\\n\\n try:\\n size = self.sockObj.recv(4) #Get metadata\\n except:\\n raise Exception(\\\"Error while receiving data. Probably broken pipe\\\")\\n\\n if len(size) == 0:\\n raise Exception(\\\"No data recivied. Probably broken pipe\\\")\\n\\n size = struct.unpack('>I',size)[0]\\n\\n data = self.sockObj.recv(size)\\n\\n if len(data) != size:\\n raise Exception(\\\"Partiala data recivied\\\")\\n\\n return self.decode(data)\",\n \"def recv(self):\\n self.buf = self.sock_in.recvfrom(65565)\\n p = Packet(data=self.buf)\\n return p\",\n \"def unpack(self, struct):\\n if len(self.view) < struct.size:\\n raise UnderflowDecodeError()\\n\\n v = struct.unpack(self.view[0:struct.size])\\n self.num_bytes_consumed += struct.size\\n self.view = self.view[struct.size:]\\n return v\",\n \"def read_raw_packet(self):\\n\\n size = 0\\n\\n # Read our two-byte header from the debugger...\\n while not size:\\n size = (self._get_next_byte() << 16) | self._get_next_byte()\\n\\n # ... and read our packet.\\n packet = bytearray([self._get_next_byte() for _ in range(size)])\\n\\n # Return our packet.\\n # TODO: extract and provide status flags\\n # TODO: generate a timestamp on-device\\n return packet, datetime.now(), None\",\n \"def decode(cls, buffer):\\n\\n if len(buffer) < struct.calcsize(b\\\"<i\\\"):\\n raise IncompleteMessageError\\n size = struct.unpack(b\\\"<i\\\", buffer[:4])[0]\\n if len(buffer) - struct.calcsize(b\\\"<i\\\") < size:\\n raise IncompleteMessageError\\n packet = buffer[:size + 4]\\n buffer = buffer[size + 4:]\\n id = struct.unpack(b\\\"<i\\\", packet[4:8])[0]\\n type = struct.unpack(b\\\"<i\\\", packet[8:12])[0]\\n body = packet[12:][:-2].decode(\\\"ascii\\\")\\n return cls(id, type, body), buffer\",\n \"def read(self):\\n packet = None\\n while packet is None:\\n packet = self.async_read()\\n return packet\",\n \"def handle_receive(self, data):\\n alldata = \\\"\\\"\\n for item in data:\\n alldata += item\\n\\n # Wrap data in a StringIO buffer\\n cur_buffer = stringio.StringIO(alldata)\\n\\n with self.__buffer_lock:\\n # While the buffer is not fully processed\\n while True:\\n # Read header, if no length for metadata and binary data is\\n # available\\n if self.__meta_length is None:\\n if self.read_part(cur_buffer, \\\"__header_buffer\\\", self.__header_length):\\n header = struct.unpack(\\\"!II?\\\", self.__header_buffer)\\n self.__meta_length, self.__binary_length, self.__binary_compressed = header\\n total = len(self.__header_buffer) + self.__meta_length + self.__binary_length\\n else:\\n break\\n\\n # Read metadata bytes when the metadata buffer does not have the\\n # correct length yet.\\n if len(self.__meta_buffer) < self.__meta_length:\\n if not self.read_part(cur_buffer, \\\"__meta_buffer\\\", self.__meta_length):\\n break\\n\\n # Read binary bytes when the binary buffer does not have the\\n # correct length yet.\\n if len(self.__binary_buffer) < self.__binary_length:\\n if not self.read_part(cur_buffer, \\\"__binary_buffer\\\", self.__binary_length):\\n break\\n\\n # Read a complete 'packet', unpack\\n if self.__binary_compressed:\\n self.__binary_buffer = zlib.decompress(self.__binary_buffer, 15, self.__binary_length * 2)\\n self.__meta_buffer = zlib.decompress(self.__meta_buffer, 15, self.__meta_length * 2)\\n\\n binary_data = self.__binary_buffer\\n meta_data = pickle.loads(self.__meta_buffer)\\n self.__binary_buffer = \\\"\\\"\\n self.__meta_buffer = \\\"\\\"\\n self.__header_buffer = \\\"\\\"\\n self.__meta_length = None\\n self.__binary_length = None\\n self.__binary_compressed = False\\n\\n # Append to the receive buffer (of ThreadedSocket class)\\n with self._ThreadedSocket__receive_lock:\\n self._ThreadedSocket__receive_buffer.append([meta_data, binary_data])\",\n \"def recv_frame(self):\\r\\n header_bytes = self._recv_strict(2)\\r\\n if not header_bytes:\\r\\n return None\\r\\n b1 = ord(header_bytes[0])\\r\\n fin = b1 >> 7 & 1\\r\\n rsv1 = b1 >> 6 & 1\\r\\n rsv2 = b1 >> 5 & 1\\r\\n rsv3 = b1 >> 4 & 1\\r\\n opcode = b1 & 0xf\\r\\n b2 = ord(header_bytes[1])\\r\\n mask = b2 >> 7 & 1\\r\\n length = b2 & 0x7f\\r\\n\\r\\n length_data = \\\"\\\"\\r\\n if length == 0x7e:\\r\\n length_data = self._recv_strict(2)\\r\\n length = struct.unpack(\\\"!H\\\", length_data)[0]\\r\\n elif length == 0x7f:\\r\\n length_data = self._recv_strict(8)\\r\\n length = struct.unpack(\\\"!Q\\\", length_data)[0]\\r\\n\\r\\n mask_key = \\\"\\\"\\r\\n if mask:\\r\\n mask_key = self._recv_strict(4)\\r\\n data = self._recv_strict(length)\\r\\n if traceEnabled:\\r\\n recieved = header_bytes + length_data + mask_key + data\\r\\n logger.debug(\\\"recv: \\\" + repr(recieved))\\r\\n\\r\\n if mask:\\r\\n data = ABNF.mask(mask_key, data)\\r\\n\\r\\n frame = ABNF(fin, rsv1, rsv2, rsv3, opcode, mask, data)\\r\\n return frame\",\n \"def baseRecv(self, buflen):\\n\\n # Attempts to retrieve a message from the queue initilized in bind, returns None if there are no messages\\n data = r.popMessage(); \\n\\n # Checks to see if a message was retrieved\\n if data is None:\\n return None; # Not certain if this is the correct return for this...\\n else:\\n dest_mac = data[0];\\n source_mac = data[1];\\n length = data[2];\\n payload = data[3];\\n mac_header = dest_mac+source_mac+length;\\n\\n ip_header = payload[:7];\\n udp_header = payload[7:9];\\n message = payload[9:];\\n\\n # If the message is not addressed to this computer's MAC, discard the message\\n if dest_mac != self.my_mac: return None;\\n\\n if (buflen<len(message)): return None;\\n else: return message, mac_header, ip_header, udp_header;\",\n \"def from_ring_buffer(cls, buf):\\n if len(buf) < cls.MESSAGE_LENGTH_SIZE:\\n return None\\n \\n message_length_bytes = buf.peek(cls.MESSAGE_LENGTH_SIZE)\\n message_length = int.from_bytes(message_length_bytes, byteorder='big')\\n\\n if message_length == 0:\\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\\n return cls(cls.Id.KEEP_ALIVE, 0)\\n \\n #print('message length {}'.format(message_length))\\n if len(buf) < message_length + cls.MESSAGE_LENGTH_SIZE:\\n # Incomplete header\\n # Don't remove anything from the buffer, wait for next byte to get a full header\\n #print('incomplete header: buffer needs {} bytes but only has {}'.format(message_length + 4,\\n # len(buf)))\\n return None\\n\\n\\n # Have a full header (length + message id)\\n buf.remove(cls.MESSAGE_LENGTH_SIZE)\\n message_id = cls.Id(buf.read(1)[0])\\n\\n payload_length = message_length - 1\\n assert(len(buf) >= payload_length)\\n\\n payload = buf.read(payload_length)\\n return cls(message_id, payload)\",\n \"def true_recvfrom(conn, buff):\\n received, address = conn.recvfrom(buff)\\n data = key.decrypt(received)\\n try:\\n return data.decode(), address\\n except UnicodeDecodeError: # pickle data\\n return pickle.loads(data), address\",\n \"def async_read(self):\\n self.lock.acquire()\\n\\n # append data\\n self.rx_buffer += self.interface.read()\\n\\n # ensure first byte start with 0xbc\\n if len(self.rx_buffer) > 0:\\n if self.rx_buffer[0] != 0xbc:\\n try:\\n pkt_start = self.rx_buffer.index(0xbc)\\n self.rx_buffer = self.rx_buffer[pkt_start:]\\n except ValueError:\\n self.rx_buffer = bytes()\\n\\n # check if we got a valid packet\\n if len(self.rx_buffer) >= 4:\\n pkt_size = unpack('<H', self.rx_buffer[2:4])[0]\\n # check if we got a complete packet\\n if len(self.rx_buffer) >= (pkt_size + 5):\\n # yep, parse this packet\\n packet = Packet.fromBytes(self.rx_buffer[:pkt_size+5])\\n self.rx_buffer = self.rx_buffer[pkt_size+5:]\\n self.lock.release()\\n return packet\\n\\n # otherwise, return None\\n self.lock.release()\\n return None\",\n \"def recv(self) -> Tuple[int, bytes]:\\n seq_idx: int = 0\\n self.device.set_nonblocking(False)\\n data_chunk: bytes = bytes(self.device.read(64 + 1))\\n self.device.set_nonblocking(True)\\n\\n assert data_chunk[:2] == b\\\"\\\\x01\\\\x01\\\"\\n assert data_chunk[2] == 5\\n assert data_chunk[3:5] == seq_idx.to_bytes(2, byteorder=\\\"big\\\")\\n\\n data_len: int = int.from_bytes(data_chunk[5:7], byteorder=\\\"big\\\")\\n data: bytes = data_chunk[7:]\\n\\n while len(data) < data_len:\\n read_bytes = bytes(self.device.read(64 + 1, timeout_ms=1000))\\n data += read_bytes[5:]\\n\\n sw: int = int.from_bytes(data[data_len - 2:data_len], byteorder=\\\"big\\\")\\n rdata: bytes = data[:data_len - 2]\\n\\n LOG.debug(\\\"<= %s %s\\\", rdata.hex(), hex(sw)[2:])\\n\\n return sw, rdata\",\n \"def unpack_from(self, struct):\\n if len(self.view) < struct.size:\\n raise UnderflowDecodeError()\\n\\n v = struct.unpack_from(self.view)\\n self.num_bytes_consumed += struct.size\\n self.view = self.view[struct.size:]\\n return v\",\n \"def parseBuffer(self):\\n idx = self.buf.find(DELIMITER)\\n while idx > -1:\\n packet = self.buf[0:idx]\\n if len(packet) > 4:\\n if packet[0:3] == 'DATA':\\n self.factory.setData(packet[4:idx])\\n else:\\n print \\\"%s is a malformed packet, header %s not recognized\\\" % (packet, packet[0:3])\\n else:\\n print \\\"%s attempting to send a packet of invalid length %s\\\" % (packet, len(packet))\\n self.buf = self.buf[(idx + len(DELIMITER)):]\\n idx = self.buf.find(DELIMITER)\",\n \"def decode_network_packet(buf):\\n off = 0\\n blen = len(buf)\\n\\n while off < blen:\\n ptype, plen = header.unpack_from(buf, off)\\n\\n if plen > blen - off:\\n raise ValueError(\\\"Packet longer than amount of data in buffer\\\")\\n\\n if ptype not in _decoders:\\n raise ValueError(\\\"Message type %i not recognized\\\" % ptype)\\n\\n yield ptype, _decoders[ptype](ptype, plen, buf[off:])\\n off += plen\",\n \"def packet_read(self):\\n bytes_received = 0\\n \\n if self.sock == NC.INVALID_SOCKET:\\n return NC.ERR_NO_CONN\\n \\n if self.in_packet.command == 0:\\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\\n if errnum == 0 and len(ba_data) == 1:\\n bytes_received += 1\\n byte = ba_data[0]\\n self.in_packet.command = byte\\n \\n if self.as_broker:\\n if self.bridge is None and self.state == NC.CS_NEW and (byte & 0xF0) != NC.CMD_CONNECT:\\n print \\\"RETURN ERR_PROTOCOL\\\"\\n return NC.ERR_PROTOCOL, bytes_received\\n else:\\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\\n return NC.ERR_SUCCESS, bytes_received\\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\\n return NC.ERR_CONN_LOST, bytes_received\\n else:\\n evt = event.EventNeterr(errnum, errmsg)\\n self.push_event(evt)\\n return NC.ERR_UNKNOWN, bytes_received\\n \\n if not self.in_packet.have_remaining:\\n loop_flag = True\\n while loop_flag:\\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, 1)\\n \\n if errnum == 0 and len(ba_data) == 1: \\n byte = ba_data[0]\\n bytes_received += 1\\n self.in_packet.remaining_count += 1\\n if self.in_packet.remaining_count > 4:\\n return NC.ERR_PROTOCOL, bytes_received\\n \\n self.in_packet.remaining_length += (byte & 127) * self.in_packet.remaining_mult\\n self.in_packet.remaining_mult *= 128\\n else:\\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\\n return NC.ERR_SUCCESS, bytes_received\\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\\n return NC.ERR_CONN_LOST, bytes_received\\n else:\\n evt = event.EventNeterr(errnum, errmsg)\\n self.push_event(evt)\\n return NC.ERR_UNKNOWN, bytes_received\\n \\n if (byte & 128) == 0:\\n loop_flag = False\\n \\n if self.in_packet.remaining_length > 0:\\n self.in_packet.payload = bytearray(self.in_packet.remaining_length)\\n if self.in_packet.payload is None:\\n return NC.ERR_NO_MEM, bytes_received\\n self.in_packet.to_process = self.in_packet.remaining_length\\n \\n self.in_packet.have_remaining = True\\n \\n if self.in_packet.to_process > 0:\\n ba_data, errnum, errmsg = nyamuk_net.read(self.sock, self.in_packet.to_process)\\n if errnum == 0 and len(ba_data) > 0:\\n readlen = len(ba_data)\\n bytes_received += readlen\\n for idx in xrange(0, readlen):\\n self.in_packet.payload[self.in_packet.pos] = ba_data[idx]\\n self.in_packet.pos += 1\\n self.in_packet.to_process -= 1\\n else:\\n if errnum == errno.EAGAIN or errnum == errno.EWOULDBLOCK:\\n return NC.ERR_SUCCESS, bytes_received\\n elif errnum == 0 and len(ba_data) == 0 or errnum == errno.ECONNRESET:\\n return NC.ERR_CONN_LOST, bytes_received\\n else:\\n evt = event.EventNeterr(errnum, errmsg)\\n self.push_event(evt)\\n return NC.ERR_UNKNOWN, bytes_received\\n\\n #all data for this packet is read\\n self.in_packet.pos = 0\\n \\n ret = self.packet_handle()\\n \\n self.in_packet.packet_cleanup()\\n \\n self.last_msg_in = time.time()\\n \\n return ret, bytes_received\",\n \"def recv_data(self, maxbuffer=4096):\\n try:\\n buff = self.s.recv(maxbuffer)\\n except OSError as e:\\n print(e)\\n return buff.decode()\",\n \"def _receive_packet(self):\\n report = self._serial_read(1)\\n if len(report) != 1:\\n self.log(\\\"ERROR: Didn't read back a report!\\\")\\n report = -1\\n else:\\n report = report[0]\\n retval = self._serial_read(1)\\n if len(retval) != 1:\\n self.log(\\\"ERROR: Didn't read back a return value!\\\")\\n retval = -1\\n else:\\n retval = retval[0]\\n\\n return_payload_len = self._serial_read(1)\\n if len(return_payload_len) != 1:\\n self.log(\\\"ERROR: Didn't read back a return payload length!\\\")\\n return_payload_len = 0\\n else:\\n return_payload_len = return_payload_len[0]\\n\\n if return_payload_len != 0:\\n return_payload = self._serial_read(return_payload_len)\\n else:\\n return_payload = []\\n checksum = self._serial_read(1)\\n if len(checksum) != 1:\\n self.log(\\\"ERROR: Didn't read back a checksum!\\\")\\n checksum = -1\\n else:\\n checksum = checksum[0]\\n\\n data = self.MAGIC_HEADER + [report, retval, return_payload_len] + return_payload\\n data.append(checksum)\\n\\n our_checksum = self.generate_checksum(data[:-1])\\n if our_checksum != checksum:\\n self.log(\\\"ERROR: Our checksum didn't calculate properly! \\\"\\n \\\"(Calculated {}, expected {})\\\".format(our_checksum, checksum))\\n return -1, checksum, []\\n else:\\n if self.verbose:\\n self.log(\\\"Checksum match! ({} == {})\\\".format(our_checksum, checksum))\\n\\n return report, retval, return_payload\",\n \"def length_wrapper(buf, pos):\\n length, pos = varint.decode_varint(buf, pos)\\n end = pos+length\\n output = []\\n while pos < end:\\n value, pos = wrapped_decoder(buf, pos)\\n output.append(value)\\n if pos > end:\\n raise DecoderException(\\n (\\\"Error decoding packed field. Packed length larger than\\\"\\n \\\" buffer: decoded = %d, left = %d\\\")\\n % (length, len(buf) - pos))\\n return output, pos\",\n \"def receive(self) -> Packet:\\n try:\\n return packet_from_bytes(self._socket.recvfrom(MAX_PACKET_SIZE)[0])\\n except socket.timeout:\\n raise racetools.errors.Timeout('timeout reached waiting for UDP packet') from None\",\n \"def unpack_real(self, data_type, length):\\n\\t\\tif len(self.buff) < length:\\n\\t\\t\\traise IncompleteData()\\n\\t\\to = struct.unpack_from('!'+data_type, self.buff)[0]\\n\\t\\tself.buff = self.buff[length:]\\n\\t\\treturn o\",\n \"def unpack(self, pkt):\\n if pkt[0]!='$' or pkt[-3]!='#':\\n raise ValueError('bad packet')\\n if (sum(ord(c) for c in pkt[1:-3]) % 256) != int(pkt[-2:],16):\\n raise ValueError('bad checksum')\\n pkt = pkt[1:-3]\\n return pkt\",\n \"def __recv_frame(self) -> Dict[str, Any]:\\n # Grab a packet\\n packets = self.sock.recvfrom(Sniffer.RECEIVE_SIZE)\\n address = self.__process_address(packets[1])\\n packet = packets[0]\\n offset = 0\\n\\n # Make sure its a valid packet\\n eth_header = self.__process_ethframe(packet[offset:(offset + Sniffer.ETH_HEADER_LENGTH)])\\n offset = offset + eth_header['header_length']\\n\\n if eth_header['protocol'] != 8:\\n # Not IP\\n raise UnknownPacketException(\\n 'Unknown frame {}'.format(eth_header['protocol'])\\n )\\n\\n # Get the IP header\\n ip_header = self.__process_ipframe(packet[offset:(offset + Sniffer.IP_HEADER_LENGTH)])\\n offset = offset + ip_header['header_length']\\n\\n if ip_header['protocol'] != 6:\\n # Not TCP\\n raise UnknownPacketException(\\n 'Unknown protocol {}'.format(ip_header['protocol']),\\n )\\n\\n # Get TCP header\\n tcp_header = self.__process_tcpframe(packet[offset:(offset + Sniffer.TCP_HEADER_LENGTH)])\\n offset = offset + tcp_header['header_length']\\n\\n # Get payload length\\n payload_length = ip_header['length'] - ip_header['header_length'] - tcp_header['header_length']\\n\\n # Get payload\\n data = packet[offset:offset + payload_length]\\n\\n return {\\n 'ip_header': ip_header,\\n 'tcp_header': tcp_header,\\n 'data': data,\\n 'address': address,\\n }\",\n \"def _read(self):\\n \\n try:\\n d = self._get_byte()\\n ts = time.time()\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n ts = time.time()\\n packet = [d]\\n d = self._get_byte()\\n if d == self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n ts = time.time()\\n else:\\n packet.append(d)\\n while d != self.HDLC_FLAG_BYTE:\\n d = self._get_byte()\\n packet.append(d)\\n if self._debug == True:\\n print \\\"Serial:_read: unescaped\\\", packet\\n packet = self._unescape(packet)\\n \\n crc = self._crc16(0, packet[1:-3])\\n packet_crc = self._decode(packet[-3:-1])\\n \\n if crc != packet_crc:\\n print \\\"Warning: wrong CRC! %x != %x %s\\\" % (crc, packet_crc, [\\\"%2x\\\" % i for i in packet])\\n if self._debug:\\n if self._ts == None:\\n self._ts = ts\\n else:\\n print \\\"Serial:_read: %.4f (%.4f) Recv:\\\" % (ts, ts - self._ts), self._format_packet(packet[1:-3])\\n self._ts = ts\\n return RawPacket(ts, packet[1:-3], crc == packet_crc)\\n except socket.timeout:\\n return None\",\n \"def parse_payload(self):\\n while len(self.buffer) >= 10:\\n \\\"\\\"\\\" check magic word \\\"\\\"\\\"\\n if self.buffer[0:2] != self.mw:\\n #LogDebug(\\\"drop all buffer due to incorrect magic word\\\")\\n self.buffer = b\\\"\\\" # drop entire buffer\\n\\n \\\"\\\"\\\" extract the value from length field \\\"\\\"\\\"\\n length = struct.unpack(\\\"I\\\", self.buffer[2:6])[0] + 1\\n #print \\\"packet len\\\", length, \\\"buffer len\\\", len(self.buffer)\\n if len(self.buffer) < length:\\n #LogDebug(\\\"imcompleted packet will be processed later\\\")\\n break\\n\\n \\\"\\\"\\\" verify the packet CRC \\\"\\\"\\\"\\n calculated_crc = struct.pack(\\\"I\\\", binascii.crc32(self.buffer[:length-4]) & 0xFFFFFFFF)\\n if calculated_crc != self.buffer[length-4:length]:\\n pass\\n else:\\n payload = self.buffer[6:length-4]\\n self.payloads.append(payload)\\n self.buffer = self.buffer[length:]\",\n \"def recvfrom(self, bufsize: int) -> Tuple:\\n ...\",\n \"def unpack(usb_packet):\\n packet = StenoPacket(\\n # Drop sync when unpacking.\\n *StenoPacket._STRUCT.unpack(usb_packet[:StenoPacket.HEADER_SIZE])[1:]\\n )\\n if packet.data_length:\\n packet.data, = unpack(\\n '%ss' % packet.data_length,\\n usb_packet[StenoPacket.HEADER_SIZE:StenoPacket.HEADER_SIZE +\\n packet.data_length]\\n )\\n return packet\",\n \"def _lowLevelRecv(self,buffer):\\n import socket\\n\\n try: data = self.socket_reference.recv(buffer)\\n except socket.error as error: raise CommClientException(str(error))\\n\\n return data\",\n \"def get_packet(self):\\n msg_type = ''\\n msg = ''\\n try:\\n msg_type = self.sock.recv(4)\\n data = self.sock.recv(4)\\n msg_len = int(struct.unpack('!L', data)[0])\\n\\n while len(msg) != msg_len:\\n data = self.sock.recv(min(2048, msg_len - len(msg)))\\n if not len(data):\\n break\\n msg += data\\n\\n if len(msg) != msg_len:\\n return [None, None]\\n\\n except KeyboardInterrupt:\\n raise\\n except:\\n traceback.print_exc()\\n\\n return Packet(type=msg_type, payload=json.loads(msg), handler=self.handler, connection=self)\",\n \"def parse_data(self,ring_buffer):\\n #get one complete package\\n\\n if ring_buffer.buf_len() <= 0:\\n return None\\n\\n\\n #protocol_parse = protocol_handler.ProtocolHandler()\\n package = None\\n try:\\n self._protocol_parse.del_wrong_header(ring_buffer)\\n package = self._protocol_parse.get_one_complete_package(ring_buffer)\\n ring_buffer.set_clear()\\n except protocol_handler.ParseTimeout,e:\\n #print 'parse timeout,current buffer:'\\n #logger.debug(e.message)\\n ring_buffer.set_time_out()\\n if ring_buffer.over_max_time():\\n self._protocol_parse.pop_header(ring_buffer)\\n self._protocol_parse.del_wrong_header(ring_buffer)\\n logger.error('ring buffer over max timeout time,del wrong header')\\n return None\\n except protocol_handler.ParseError,e:\\n print 'parse error'\\n self._protocol_parse.pop_header(ring_buffer)\\n return None\\n except Exception,e:\\n return None\\n\\n\\n if package == None:\\n print 'package is None'\\n return None\\n\\n parsed_data = self._protocol_parse.parse_data(package)\\n\\n if parsed_data == None:\\n print 'parse package failed'\\n return None\\n\\n return parsed_data\",\n \"def unpack (self, buffer):\\n\\t\\timport struct\\n\\t\\tvalues = struct.unpack (self.struct, buffer)\\n\\t\\tj = 0\\n\\t\\tfor i in self.structref:\\n\\t\\t\\tself.value[i[self.NAME]] = values[j]\\n\\t\\t\\tj = j + 1\",\n \"def receive_data(self):\\n chunks = []\\n bytes_recd = 0\\n while bytes_recd < 8:\\n #I'm reading my data in byte chunks\\n try:\\n chunk = self.sockfd.recv(min(8 - bytes_recd, 4))\\n chunks.append(chunk)\\n bytes_recd = bytes_recd + len(chunk)\\n except:\\n print(f'{self.ip} socket failed')\\n break\\n # if chunk == '':\\n # raise RuntimeError(\\\"Socket connection broken\\\")\\n\\n stat_tuple = struct.unpack('L', chunks[0])\\n data_tuple = struct.unpack('L', chunks[1])\\n stat = stat_tuple[0]\\n data = data_tuple[0]\\n return stat, chunks[1]\",\n \"def _receive(self, sock, count):\\n\\n buf = b''\\n\\n while len(buf) < count:\\n chunk = sock.recv(count - len(buf))\\n if not chunk:\\n break\\n buf += chunk\\n\\n return buf\",\n \"def length_wrapper(buf, pos):\\n length, pos = self.decode_varint(buf, pos)\\n end = pos+length\\n output = []\\n while pos < end:\\n value, pos = wrapped_decoder(buf, pos)\\n output.append(value)\\n if pos > end:\\n raise decoder._DecodeError(\\\"Invalid Packed Field Length\\\")\\n return output, pos\",\n \"def recv(self, bufsize: int) -> bytes:\\n ...\",\n \"def decode(self,buf):\\n eth = dpkt.ethernet.Ethernet(buf)\\n pkt_len = len(buf)\\n if(eth.type== dpkt.ethernet.ETH_TYPE_IP):\\n ip = eth.data\\n dst_ip = socket.inet_ntoa(ip.dst)\\n src_ip = socket.inet_ntoa(ip.src)\\n octet_list = string.split(dst_ip,'.')\\n broadcast = False\\n for o in octet_list:\\n if (o == \\\"255\\\"):\\n broadcast = True\\n break\\n if((octet_list[0] == \\\"224\\\") or (octet_list[0] == \\\"239\\\")):\\n broadcast = True #Its multicast actually.\\n if not broadcast:\\n if(ip.p == dpkt.ip.IP_PROTO_TCP):\\n pass\\n elif(ip.p == dpkt.ip.IP_PROTO_UDP):\\n udp =ip.data\\n if((udp.dport == 53) or (udp.sport == 53)): # A request. \\n if(udp.dport == 53): # A request. \\n return self.dns_handler.handle_dns_request(ip.src,ip.dst,ip.p,udp.sport,udp.dport,udp.data)\\n if(udp.sport == 53): # A DNS response\\n self.dns_handler.handle_dns_response(ip.src,ip.dst,ip.p,udp.sport,udp.dport,udp.data)\\n else:\\n pass\",\n \"def _decode(self):\\n \\n self.version = int(data_to_hex_str(self.packet[0])[2])\\n self.header_len = int(data_to_hex_str(self.packet[0])[3]) * 4\\n self.type_of_service = data_to_hex_str(self.packet[1:2])\\n self.total_len = int(data_to_hex_str(self.packet[2:4]), 16)\\n self.id = data_to_hex_str(self.packet[4:6])\\n \\n #parse the flags fields(reservedbit, don't fragment, more fragment)\\n if ((ord(self.packet[6]) & (1 << 7)) != 0):\\n self.flags_reservedbit = 1\\n else:\\n self.flags_reservedbit = 0\\n #endof if\\n \\n if ((ord(self.packet[6]) & (1 << 6)) != 0):\\n self.flags_dont_fragment = 1\\n else:\\n self.flags_dont_fragment = 0\\n #endof if\\n \\n if ((ord(self.packet[6]) & (1 << 5)) != 0):\\n self.flags_more_fragment = 1\\n else:\\n self.flags_more_fragment = 0\\n #endof if\\n \\n #parse the offset field(in packet[6:7]): 00011111 & packet[6] (to filter flags) -->> get packet[6:7] in hex_str\\n #tmp = str(31 & ord(self.packet[6]))\\n self.fragment_offset = int(data_to_hex_str(self.packet[6:8]), 16)\\n if (self.fragment_offset >= (1 << 13)):\\n #take away the flags fields: 00011111 11111111 & self.fragment_offset\\n self.fragment_offset = self.fragment_offset & ((1 << 13) - 1) \\n \\n self.TTL = ord(self.packet[8])\\n self.protocol = IPPROTO[ord(self.packet[9])]\\n self.header_checksum = data_to_hex_str(self.packet[10:12])\\n \\n self.src = str(ord(self.packet[12])) + '.' + str(ord(self.packet[13])) + '.' + \\\\\\n str(ord(self.packet[14])) + '.' + str(ord(self.packet[15]))\\n self.dst = str(ord(self.packet[16])) + '.' + str(ord(self.packet[17])) + '.' + \\\\\\n str(ord(self.packet[18])) + '.' + str(ord(self.packet[19]))\\n \\n if (self.header_len > 20):\\n self.opt_paddings = self.packet[20 : (self.header_len)]\",\n \"def unpack_sequence_from(\\n fn: UnpackFn[_T], buffer: bytes, offset: int = 0\\n) -> tuple[Sequence[_T], int]:\\n sequence = []\\n length, length_size = _unpack_length_from(buffer, offset=offset)\\n offset += length_size\\n item_offset = 0\\n while item_offset < length:\\n item, item_size = fn(buffer, offset=offset + item_offset)\\n item_offset += item_size\\n sequence.append(item)\\n return sequence, length_size + length\",\n \"def _unpack_tuple(self, buff):\\n cardinality = struct_L.unpack_from(buff)[0]\\n _tuple = ['']*cardinality\\n offset = 4 # The first 4 bytes in the response body is the <count> we have already read\\n for i in xrange(cardinality):\\n field_size, offset = self._unpack_int_base128(buff, offset)\\n field_data = struct.unpack_from(\\\"<%ds\\\" % field_size, buff, offset)[0]\\n _tuple[i] = field(field_data)\\n offset += field_size\\n\\n return tuple(_tuple)\",\n \"def recv(self, sock):\\n\\n #int length is at most 4 bytes long\\n hdr_bytes = sock.recv(1)\\n (msg_length, hdr_length) = _DecodeVarint32(hdr_bytes, 0)\\n rsp_buffer = io.BytesIO()\\n if hdr_length < 4:\\n rsp_buffer.write(hdr_bytes[hdr_length:])\\n\\n # read the remaining message bytes\\n # msg_length = msg_length - (4 - hdr_length)\\n while msg_length > 0:\\n rsp_bytes = sock.recv(min(8096, msg_length))\\n rsp_buffer.write(rsp_bytes)\\n msg_length = msg_length - len(rsp_bytes)\\n return rsp_buffer.getvalue()\",\n \"def recv(self):\\n return from_bytes(self.sock.recv(512))\",\n \"def unpack(self, fmt):\\n try:\\n data = self.get(struct.calcsize(fmt))\\n return struct.unpack(fmt, data)\\n except struct.error as e:\\n raise BufferError(\\n \\\"Error unpacking struct '%s' <%s>\\\" %\\n (fmt, binascii.hexlify(data).decode())\\n )\",\n \"def unpack(self, request_raw):\\n request = self.mh.unpack_request(request_raw)\\n if not request: return request\\n # If two messages were sent, cache the second\\n if request[1]: self.pending_request = request[1]\\n return request[0]\",\n \"def read_fifo_parse(self, n_transfers=1, timeout=0, return_remaining = False):\\n \\n count=5*n_transfers\\n remaining_words, buffer = self.read_fifo_raw(count, timeout)\\n if self.debug: print('read_fifo_parse remaining_words', remaining_words)\\n \\n if len(buffer) == 0:\\n return np.zeros((0,10),dtype=np.uint32)\\n \\n # reshape to N x 5 uint64 \\n buf = buffer.reshape(-1, 5)\\n \\n # convert to a N x 10 uint32 array\\n msU32 = buf>>32\\n lsU32 = buf& 0xFFFFFFFF\\n wide_buf = np.concatenate( [msU32, lsU32], axis=1)\\n if self.debug: print(wide_buf.shape, wide_buf.dtype)\\n\\n ### Reorder columns \\n data = np.zeros_like(wide_buf, dtype=np.uint32)\\n \\n header_order = wide_buf[0]>>28 # use the first transfer headers to define order\\n if self.debug: print(header_order)\\n \\n for jj, header in enumerate(header_order):\\n # grab the 28bit data from each buffer column\\n # and place it in the correct column of data\\n data[:, header] = wide_buf[:, jj] & 0x0FFFFFFF \\n \\n if return_remaining: \\n return remaining_words, data \\n else: \\n return data\",\n \"def read_and_unpack(self, fmt):\\n try:\\n return unpack(\\n self.byte_order + fmt,\\n self.read(calcsize(self.byte_order + fmt)))\\n except Exception as e:\\n if e.args[0].startswith('unpack requires a buffer of'):\\n raise EOFError(e)\\n else:\\n raise\",\n \"def unwrap(self, packet_raw):\\n (self.ip_ihl_ver, self.ip_tos_ecn, self.ip_tot_len, self.ip_id, self.ip_flag_frag, \\\\\\n self.ip_ttl, self.ip_proto) = unpack('!BBHHHBB', packet_raw[0:10])\\n (self.ip_check) = unpack('H', packet_raw[10:12])\\n (src_addr, dest_addr) = unpack('!4s4s', packet_raw[12:20])\\n\\n self.ip_ihl = self.ip_ihl_ver & 0x0f\\n self.ip_ver = (self.ip_ihl_ver & 0xf0) >> 4\\n self.ip_tos = (self.ip_tos_ecn & 0xfc) >> 2\\n self.ip_ecn = self.ip_tos_ecn & 0x03\\n self.ip_flag_df = (self.ip_flag_frag & 0x40) >> 14\\n self.ip_flag_mf = (self.ip_flag_frag & 0x20) >> 13\\n self.ip_frag_off = self.ip_flag_frag & 0x1f\\n\\n self.ip_saddr = socket.inet_ntoa(src_addr)\\n self.ip_daddr = socket.inet_ntoa(dest_addr)\\n self.data = packet_raw[self.ip_ihl*4:self.ip_tot_len]\\n\\n pesudo_ip_header = packet_raw[0:10] + pack('H', 0) + packet_raw[12:20]\\n new_chksum = network_chksum(pesudo_ip_header)\\n if self.ip_check != new_chksum:\\n raise ValueError\",\n \"def retrieveData():\\n\\n\\t# My terribad first attempt at this based off of outflank example\\n\\t# I honestly have no idea what I was doing, but leaving it here just in case\\n\\t########\\n\\t# try:\\n\\t# \\tdata = transSock.recv(4)\\n\\t# except:\\n\\t# \\treturn(\\\"\\\")\\n\\t# if len(data) < 4:\\n\\t# \\treturn()\\n\\t# slen = struct.unpack('<I', data)[0]\\n\\t# data = transSock.recv(slen)\\n\\t# while len(data) < slen:\\n\\t# \\tdata = data + transSock.recv(slen - len(data))\\n\\t# return(data)\\n\\t########\\n\\n\\t# Realizing that I have to unpack the buffer length first:\\n\\n\\tframeSize = \\\"\\\"\\n\\twhile len(frameSize) != 4:\\n\\t\\tframeSize = connSock.recv(4)\\n\\n\\tdataSize = struct.unpack('<I', frameSize)[0]\\n\\tdata = connSock.recv(dataSize)\\n\\n\\treturn data\",\n \"async def _read_pdu(\\n client: AIOHomeKitBleakClient,\\n decryption_key: DecryptionKey | None,\\n handle: BleakGATTCharacteristic,\\n tid: int,\\n) -> tuple[PDUStatus, bytes]:\\n data = await client.read_gatt_char(handle)\\n if decryption_key:\\n try:\\n data = decryption_key.decrypt(bytes(data))\\n except DecryptionError:\\n raise EncryptionError(\\\"Decryption failed\\\")\\n\\n debug = logger.isEnabledFor(logging.DEBUG)\\n if debug:\\n logger.debug(\\\"Read fragment: %s\\\", data)\\n\\n # Validate the PDU header\\n status, expected_length, data = decode_pdu(tid, data)\\n\\n # If packet is too short then there may be 1 or more continuation\\n # packets. Keep reading until we have enough data.\\n #\\n # Even if the status is failure, we must read the whole\\n # data set or the encryption will be out of sync.\\n #\\n while len(data) < expected_length:\\n next = await client.read_gatt_char(handle)\\n if decryption_key:\\n try:\\n next = decryption_key.decrypt(bytes(next))\\n except DecryptionError:\\n raise EncryptionError(\\\"Decryption failed\\\")\\n if debug:\\n logger.debug(\\\"Read fragment: %s\\\", next)\\n\\n data += decode_pdu_continuation(tid, next)\\n\\n return status, data\",\n \"def receive(self, sock):\\n # TODO: This is just a dummy receive for now. Will need to implement a real one once\\n # protocol is further developed.\\n data = sock.recv(2048)\\n return data\",\n \"def recv(recv_buffer):\\n\\n header_len = struct.calcsize(CCPMessage.HEADER_FMT)\\n\\n msgs = []\\n while True:\\n if len(recv_buffer) < header_len:\\n #print \\\"AAAAAAAAAAAAAA %s \\\" % str(len(recv_buffer))\\n return (msgs, recv_buffer)\\n\\n header = recv_buffer[:header_len]\\n\\n (version, msg_type, data_len, conn_id) = struct.unpack(\\n CCPMessage.HEADER_FMT, header)\\n\\n DEBUG and log_debug(\\\"msg %d: version: %r; msg_type: %r; data_len: %u; conn_id: %r\\\"\\n % (len(msgs), version, msg_type, data_len, conn_id))\\n\\n\\n #print(\\\"msg %d: version: %r; msg_type: %r; data_len: %u; conn_id: %r\\\"\\n # % (len(msgs), version, msg_type, data_len, conn_id))\\n\\n if DEBUG:\\n top1 = len(recv_buffer)\\n top2 = len(recv_buffer)\\n if top1 > 64:\\n top1 = 64\\n if top2 > 128:\\n top2 = 128\\n\\n log_debug(\\\"first %d bytes of data: %s\\\" %\\n (top1, binascii.b2a_hex(recv_buffer[0:top1])))\\n if top2 > 64:\\n log_debug(\\\"second %d bytes of data: %s\\\" %\\n (top2 - top1,\\n binascii.b2a_hex(recv_buffer[top1:top2])))\\n\\n # check to make sure that the data_len is sane. We defer the other\\n # checks until we have the entire packet, but this needs to be done\\n # first in order to prevent an adversary from gumming up the\\n # connection by sending an impossibly long message.\\n if data_len > CCPMessage.MAX_DATA_LEN:\\n #print \\\"BBBBBBB bad data len\\\"\\n err_str = 'bad data_len (%u), recv_buffer len: %d' % (data_len,\\n len(recv_buffer))\\n CCPMessage.LOGGER.warn(err_str)\\n\\n raise CCPMessageUnpackError(err_str)\\n\\n # if we haven't received an entire message yet, then return\\n #\\n if len(recv_buffer) < (header_len + data_len):\\n #print \\\"CCCCCCCCCCCCCCCCCCCCCCCC len(recv_buffer) < %s \\\" % str(header_len + data_len)\\n #print str(len(recv_buffer))\\n return (msgs, recv_buffer)\\n\\n if data_len == 0:\\n data = None\\n else:\\n data = recv_buffer[header_len:header_len + data_len]\\n\\n recv_buffer = recv_buffer[header_len + data_len:]\\n\\n # Now that we have the entire message, we can decide whether it's\\n # valid.\\n #\\n if version != CCPMessage.PROTOCOL_VERSION:\\n err_str = 'bad version (%u)' % (version,)\\n CCPMessage.LOGGER.warn(err_str)\\n raise CCPMessageUnpackError(err_str)\\n\\n if not msg_type in CCPMessage.msg_types:\\n err_str = 'bad msg_type (%u)' % (msg_type,)\\n CCPMessage.LOGGER.warn(err_str)\\n raise CCPMessageUnpackError(err_str)\\n\\n # The message is complete and valid. Append it to the list of\\n # messages we've received.\\n #\\n msgs.append(CCPMessage(msg_type, conn_id=conn_id, data=data))\\n\\n # CCPMessage.LOGGER.debug(\\\"received msg_type (%u)\\\" %\\n # (msg_type,))\",\n \"def recieve_data(self):\\r\\n try:\\r\\n while True:\\r\\n try:\\r\\n data, self.addr = self.sock.recvfrom(1024)\\r\\n return data\\r\\n except socket.timeout:\\r\\n print(\\\"There is no packet at all!\\\")\\r\\n break\\r\\n except Exception:\\r\\n print(\\\"Can't recieve a package\\\")\",\n \"def recvData(self) -> bytes:\\n \\n packet = self.recvPacket()\\n if(packet.seq == Rudp.ackPlusOne(self.ack)):\\n self.ack = Rudp.ackPlusOne(self.ack)\\n self.acknowledgePacket(packet)\\n return packet.payload\\n else:\\n return None\",\n \"def recv_bin_data(sock):\\n mess = b''\\n\\n # Receive data until we have a full header\\n mess_current_length = len(mess)\\n while mess_current_length < LSPInfo.bin_header_size:\\n mess += sock.recv(LSPInfo.bin_header_size) # Receive the header\\n mess_current_length = len(mess) # Current length of the message\\n\\n # Check error code in header\\n header = struct.unpack(LSPInfo.fmt_header, mess)\\n error_code = header[-1]\\n # If bad error code, close socket and return\\n if error_code != 0:\\n print('[LSP] Error code of %i. Communication terminated!' % i)\\n sock.close()\\n return\\n\\n # If error code is good, find size of message\\n mess_len_total = header[-2]\\n\\n # Loop to receive bytes until we have the entire message\\n while mess_current_length < mess_len_total:\\n bytes_left = mess_len_total - mess_current_length # How many more bytes need to be received\\n mess += sock.recv(bytes_left) # Try to receive those bytes\\n mess_current_length = len(mess) # Current length of the message\\n\\n if mess_current_length > mess_len_total:\\n print('Warning! More bytes received than expected') # Warning if we have too much data\\n # If we have more data than a single message, extract the single scan and add rest of data to 'message'\\n complete_scan = mess[:mess_len_total]\\n # Otherwise the complete scan is just equal to the whole message\\n else:\\n complete_scan = mess\\n\\n unpacked_mess = LSPInfo.bin_unpacker.unpack(complete_scan) # Unpack message data\\n\\n return unpacked_mess\",\n \"def recv(self):\\r\\n try:\\r\\n self.lock.acquire()\\r\\n length, = struct.unpack(self.HEADER_FORMAT, self.stream.read(self.HEADER_SIZE))\\r\\n return self.stream.read(length)\\r\\n finally:\\r\\n self.lock.release()\",\n \"def recibir(self):\\r\\n lenbuf = self.__recvall(4)\\r\\n longitud, = struct.unpack('!I', lenbuf)\\r\\n return self.__recvall(longitud)\",\n \"def _recvall(conn, n):\\n data = b''\\n while len(data) < n:\\n packet = conn.recv(n - len(data))\\n if not packet:\\n return None\\n data += packet\\n return data\",\n \"def unpack(self, data_type):\\n\\t\\tif data_type in data_types:\\n\\t\\t\\tformat = data_types[data_type]\\n\\t\\t\\treturn self.unpack_real(format[0], format[1])\\n\\t\\t\\n\\t\\tif data_type == \\\"string8\\\":\\n\\t\\t\\tlength = self.unpack('short')\\n\\t\\t\\tif length < 0:\\n\\t\\t\\t\\traise Exception(\\\"Negative length for string\\\")\\n\\t\\t\\tif len(self.buff) < length:\\n\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\tstring = self.buff[:length]\\n\\t\\t\\tself.buff = self.buff[length:]\\n\\t\\t\\treturn string\\n\\t\\tif data_type == \\\"string16\\\":\\n\\t\\t\\tlength = self.unpack('short')\\n\\t\\t\\tif length < 0:\\n\\t\\t\\t\\traise Exception(\\\"Negative length for string\\\")\\n\\t\\t\\tif len(self.buff) < 2*length:\\n\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\tstring = self.buff[:2*length].decode('utf-16be')\\n\\t\\t\\tself.buff = self.buff[2*length:]\\n\\t\\t\\treturn string\\n\\t\\tif data_type == \\\"slot\\\":\\n\\t\\t\\to = {}\\n\\t\\t\\to[\\\"id\\\"] = self.unpack('short')\\n\\t\\t\\tif o[\\\"id\\\"] > 0:\\n\\t\\t\\t\\to[\\\"amount\\\"] = self.unpack('byte')\\n\\t\\t\\t\\to[\\\"damage\\\"] = self.unpack('short')\\n\\t\\t\\tif o[\\\"id\\\"] in SLOT_EXTRA_DATA_IDS:\\n\\t\\t\\t\\textra_len = self.unpack('short')\\n\\t\\t\\t\\tif extra_len <= 0:\\n\\t\\t\\t\\t\\to[\\\"extra\\\"] = None\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif len(self.buff) < extra_len:\\n\\t\\t\\t\\t\\t\\traise IncompleteData()\\n\\t\\t\\t\\t\\textra_buff = self.buff[:extra_len]\\n\\t\\t\\t\\t\\tself.buff = self.buff[extra_len:]\\n\\t\\t\\t\\t\\to[\\\"extra\\\"] = extra_buff\\n\\t\\t\\treturn o\\n\\t\\tif data_type == \\\"metadata\\\":\\n\\t\\t\\t#[(17, 0), (0, 0), (16, -1)]\\n\\t\\t\\to = []\\n\\t\\t\\tmtype = self.unpack('byte')\\n\\t\\t\\twhile mtype != 127:\\n\\t\\t\\t\\tmtype2 = mtype >> 5\\n\\t\\t\\t\\tt = 0\\n\\t\\t\\t\\tif mtype2 == 0: t = self.unpack('byte') \\n\\t\\t\\t\\tif mtype2 == 1: t = self.unpack('short') \\n\\t\\t\\t\\tif mtype2 == 2: t = self.unpack('int') \\n\\t\\t\\t\\tif mtype2 == 3: t = self.unpack('float') \\n\\t\\t\\t\\tif mtype2 == 4: t = self.unpack('string16')\\n\\t\\t\\t\\tif mtype2 == 5:\\n\\t\\t\\t\\t\\tt = {}\\n\\t\\t\\t\\t\\tt[\\\"id\\\"] = self.unpack('short')\\n\\t\\t\\t\\t\\tt[\\\"count\\\"] = self.unpack('byte')\\n\\t\\t\\t\\t\\tt[\\\"damage\\\"] = self.unpack('short')\\n\\t\\t\\t\\tif mtype2 == 6:\\n\\t\\t\\t\\t\\tt = []\\n\\t\\t\\t\\t\\tfor i in range(3):\\n\\t\\t\\t\\t\\t\\ts = self.unpack('int')\\n\\t\\t\\t\\t\\t\\tt.append(s)\\n\\t\\t\\t\\tt = (mtype, t)\\n\\t\\t\\t\\to.append(t)\\n\\t\\t\\t\\tmtype = self.unpack('byte')\\n\\t\\t\\treturn o\",\n \"def recv(self,bytes,blocking=False):\\r\\n # Check input sanity\\r\\n if bytes <= 0:\\r\\n raise ValueError, \\\"Must read a positive integer number of bytes!\\\"\\r\\n \\r\\n # Check if the socket is closed\\r\\n self._handleClosed_recv()\\r\\n \\r\\n # Block until there is data\\r\\n # This lock is released whenever new data arrives, or if there is data remaining to be read\\r\\n self.socketLocks[\\\"nodata\\\"].acquire()\\r\\n try:\\r\\n self.socketLocks[\\\"nodata\\\"].release()\\r\\n except:\\r\\n # Some weird timing issues can cause an exception, but it is harmless\\r\\n pass\\r\\n \\r\\n # Check if the socket is closed\\r\\n self._handleClosed_recv()\\r\\n \\r\\n # Get our own lock\\r\\n self.socketLocks[\\\"recv\\\"].acquire()\\r\\n \\r\\n # Read up to bytes\\r\\n data = self.buffer[:bytes] \\r\\n amountIn = len(data)\\r\\n \\r\\n # Remove what we read from the buffer\\r\\n self.buffer = self.buffer[bytes:] \\r\\n \\r\\n # Reduce amount of incoming data available\\r\\n self.bufferInfo[\\\"incoming\\\"] -= amountIn\\r\\n \\r\\n # Check if there is more incoming buffer available, if not, send a MULTIPLEXER_CONN_BUF_SIZE\\r\\n # This does not count against the outgoingAvailable quota\\r\\n if self.bufferInfo[\\\"incoming\\\"] <= 0:\\r\\n # Create MULTIPLEXER_CONN_BUF_SIZE frame\\r\\n buf_frame = MultiplexerFrame()\\r\\n buf_frame.initConnBufSizeFrame(self.id, self.mux.defaultBufSize)\\r\\n \\r\\n # Send it\\r\\n try:\\r\\n self.mux._sendFrame(buf_frame)\\r\\n except:\\r\\n # The multiplexer may be closed\\r\\n # Check if the socket is closed\\r\\n self._handleClosed()\\r\\n \\r\\n # Increase our incoming buffer\\r\\n self.bufferInfo[\\\"incoming\\\"] = self.mux.defaultBufSize\\r\\n \\r\\n # Set the no data lock if there is none\\r\\n if len(self.buffer) == 0:\\r\\n self.socketLocks[\\\"nodata\\\"].acquire()\\r\\n \\r\\n # Release the lock\\r\\n self.socketLocks[\\\"recv\\\"].release() \\r\\n \\r\\n # Are we supposed to block?\\r\\n if blocking and amountIn < bytes:\\r\\n # How much more do we need?\\r\\n more = bytes - amountIn\\r\\n \\r\\n # Try to recieve the extra, recursively call ourself\\r\\n moreData = self.recv(more, True)\\r\\n \\r\\n # Return the original data, plus the extra\\r\\n return (data + moreData)\\r\\n # Otherwise, just return what we have\\r\\n else:\\r\\n return data\",\n \"def read(self, l):\\n\\t\\twhile l > len(self.buf):\\n\\t\\t\\tself.buf += self.conn.recv(4096)\\n\\n\\t\\tobuf = self.buf\\n\\t\\tself.buf = obuf[l:]\\n\\t\\treturn obuf[:l]\",\n \"def _pop_received_packet(self):\\n fragments = self._receive_heap.pop_min_and_all_fragments()\\n if fragments is None:\\n self._attempt_disabling_looping_receive()\\n else:\\n last_seqnum = fragments[-1].sequence_number\\n self._update_next_expected_seqnum(last_seqnum)\\n self._update_next_delivered_seqnum(last_seqnum)\\n payload = b''.join(f.payload for f in fragments)\\n self.handler.receive_message(payload)\\n\\n if self._next_delivered_seqnum not in self._receive_heap:\\n self._attempt_disabling_looping_receive()\",\n \"def unpack(self, buf):\\n super().unpack(buf) # unpacks _hdr\\n\\n if self.hdr_type != APv6Udp.HDR_TYPE:\\n raise dpkt.UnpackError(\\\"Unpacking compressed UDP, but encountered wrong type value\\\")\\n\\n if self.hdr_co == 0:\\n if len(self.data) < 2:\\n raise dpkt.NeedData(\\\"for UDP checksum\\\")\\n self.chksum = struct.unpack(\\\"!H\\\", self.data[0:2])[0]\\n self.data = self.data[2:]\\n\\n p = self.hdr_ports\\n if p == APv6Udp.HDR_PORTS_SRC_INLN_DST_INLN:\\n if len(self.data) < 4:\\n raise dpkt.NeedData(\\\"for UDP ports\\\")\\n self.src_port = struct.unpack(\\\"!H\\\", self.data[0:2])[0]\\n self.dst_port = struct.unpack(\\\"!H\\\", self.data[2:4])[0]\\n self.data = self.data[4:]\\n elif p == APv6Udp.HDR_PORTS_SRC_INLN_DST_F0XX:\\n if len(self.data) < 3:\\n raise dpkt.NeedData(\\\"for UDP ports\\\")\\n self.src_port = struct.unpack(\\\"!H\\\", self.data[0:2])[0]\\n self.dst_port = 0xf000 | self.data[2]\\n self.data = self.data[3:]\\n elif p == APv6Udp.HDR_PORTS_SRC_F0XX_DST_INLN:\\n if len(self.data) < 3:\\n raise dpkt.NeedData(\\\"for UDP ports\\\")\\n self.src_port = 0xf000 | self.data[0]\\n self.dst_port = struct.unpack(\\\"!H\\\", self.data[1:3])[0]\\n self.data = self.data[3:]\\n elif p == APv6Udp.HDR_PORTS_SRC_F0BX_DST_F0BX:\\n if len(self.data) < 1:\\n raise dpkt.NeedData(\\\"for UDP ports\\\")\\n d = self.data[0]\\n self.src_port = 0xf0b0 | ((d >> 4) & 0b1111)\\n self.dst_port = 0xf0b0 | (d & 0b1111)\\n self.data = self.data[1:]\",\n \"def unpack_bytes(self, num_bytes):\\n buf = self.view[0:num_bytes]\\n\\n self.num_bytes_consumed += num_bytes\\n self.view = self.view[num_bytes:]\\n\\n return num_bytes, buf\",\n \"def unpack_serializable_from(\\n buffer: bytes, offset: int = 0\\n) -> tuple[serializable_lib.Serializable, int]:\\n module_name, module_name_size = unpack_str_from(buffer, offset=offset)\\n offset += module_name_size\\n class_name, class_name_size = unpack_str_from(buffer, offset=offset)\\n offset += class_name_size\\n serializable_length, serializable_length_size = _unpack_length_from(\\n buffer, offset=offset\\n )\\n offset += serializable_length_size\\n serializable_bytes, *_ = struct.unpack_from(\\n f'!{serializable_length}s', buffer, offset=offset\\n )\\n module = importlib.import_module(module_name)\\n cls = getattr(module, class_name)\\n value = cls.from_bytes(serializable_bytes)\\n return value, (\\n module_name_size\\n + class_name_size\\n + serializable_length_size\\n + serializable_length\\n )\",\n \"def recv(self, count: Optional[int] = None) -> bytes:\\n\\n if self.peek_buffer:\\n data = self.peek_buffer[:count]\\n self.peek_buffer = self.peek_buffer[count:]\\n\\n if len(data) >= count:\\n return data\\n else:\\n data = b\\\"\\\"\\n\\n data += self.client.recv(count - len(data))\\n\\n return data\",\n \"def parsePacket(self, packet):\\n \\n pcktParts = packet.split()\\n \\n # needs exactly 4 parts\\n if len(pcktParts) != 4:\\n raise PacketException(\\\"Packet malformed.\\\")\\n \\n direction = pcktParts[0]\\n ip = pcktParts[1]\\n port = pcktParts[2]\\n flag = pcktParts[3]\\n\\n try:\\n pckt = Packet(direction, ip, port, flag)\\n except Exception as ex:\\n eprint(\\\"Corrupt Packet:{0} Ignoring packet:\\\\n{1}\\\".format(ex, packet.__str__()))\\n return None\\n \\n return pckt\",\n \"def unpack(self, packedData):\\n raise NotImplementedError, 'Method need to be overriden'\",\n \"def get_data(self):\\n\\n data = self.socket.recv(BUFFER_SIZE)\\n\\n if not data:\\n return None\\n\\n if len(data) == BUFFER_SIZE:\\n while True:\\n try:\\n data += self.socket.recv(BUFFER_SIZE)\\n except:\\n break\\n \\n return data\",\n \"def __recv(self):\\n in_buffer = \\\"\\\"\\n self.__ser.reset_input_buffer()\\n while True:\\n data_in = self.__ser.read(64)\\n if not in_buffer and not data_in:\\n time.sleep(0.1)\\n continue\\n if self.__debug:\\n print \\\"<<< %s\\\" % binascii.hexlify(data_in)\\n in_buffer += data_in\\n if len(in_buffer) < 6:\\n continue\\n msg_id, param1, param2, dst, src = struct.unpack(\\\"<HBBBB\\\", in_buffer[0:6])\\n msg_len = 6\\n if dst | 0x80:\\n # Packet is long format\\n dst &= 0x7F\\n msg_len += ((param2 << 8) | param1)\\n # Check this message is from the controller and for us\\n if dst != self.__src or src != self.__dst:\\n in_buffer = \\\"\\\"\\n continue\\n if len(in_buffer) < msg_len:\\n # Message is incomplete\\n continue\\n # Now look for messages we recognise\\n if msg_id == self.MGMSG_MOT_GET_STATUSUPDATE:\\n self.__decode_status(in_buffer[6:msg_len])\\n in_buffer = in_buffer[msg_len:]\\n continue\\n elif msg_id == self.MGMSG_MOT_MOVE_COMPLETED:\\n in_buffer = in_buffer[msg_len:]\\n continue\\n elif msg_id == self.MGMSG_MOT_MOVE_HOMED:\\n in_buffer = in_buffer[msg_len:]\\n continue\\n # If we got here, the message was invalid\\n # Clear the buffer to resynchronise\\n in_buffer = \\\"\\\"\\n continue\",\n \"def __tcp_recv(self):\\n total_data = []\\n bs = 1024\\n try:\\n data = self.__sock.recv(bs)\\n total_data.append(data)\\n while True and data:\\n if not re.search(\\\"L: (\\\\d+)\\\",data) and not data[-4:] == '\\\\r\\\\n\\\\r\\\\n':\\n data = self.__sock.recv(bs)\\n total_data.append(data)\\n elif not re.search(\\\"L: (\\\\d+)\\\",data) and data[-4:] == '\\\\r\\\\n\\\\r\\\\n':\\n return total_data\\n else:\\n break\\n \\n\\n while re.search(\\\"L: (\\\\d+)\\\",data):\\n n = len(data)\\n L = int(re.findall(\\\"L: (\\\\d+)\\\",data)[-1])\\n p = data.rfind('\\\\r\\\\n\\\\r\\\\n')\\n abc = data\\n data = ''\\n\\n p1 = data.rfind(str(L))\\n if p < p1:\\n log(\\\"rn before L\\\")\\n left = L + n - (p1 + len(str(L))) + 4\\n\\n else:\\n left = L - (n - p -4)\\n if left == L:\\n log(\\\"It happened!\\\")\\n break\\n\\n #if more bytes then last L\\n #come across another command: BN etc.\\n #read until another L come\\n if left < 0:\\n log('abc')\\n d = ''\\n left = 0\\n while True:\\n d = self.__sock.recv(bs)\\n data += d\\n if re.search(\\\"L: (\\\\d+)\\\",d):\\n break\\n log(\\\"read left bytes\\\")\\n log('data:'+data)\\n total_data.append(data)\\n\\n #read left bytes in last L\\n while left:\\n data = self.__sock.recv(left)\\n n = len(data)\\n left = left - n\\n\\n if not data:\\n break\\n total_data.append(data)\\n\\n except socket.error,e:\\n #self.__sock.close()\\n raise PyFetionSocketError(e)\\n\\n return self.__split(''.join(total_data))\\n\\n #return ''.join(total_data)\",\n \"def _recv(self):\\n msg = b''\\n try:\\n count = 0\\n while count < self.RECV_LIMIT:\\n data = self.socket.recv(self.BUFFER_SIZE)\\n \\n if not data: break\\n msg += data\\n count+=1\\n except: pass \\n finally:\\n return msg.decode(self.ENCODING)\",\n \"def receive(self):\\n raw_msglen = self.recvall(4)\\n if not raw_msglen:\\n return None\\n msglen = stc.unpack('>I', raw_msglen)[0]\\n # Read the message data\\n return self.recvall(msglen)\",\n \"def recv(self) -> Optional[bytes]:\\n ready, _, _ = select.select([self.socket], [], [], 0)\\n if len(ready) != 0:\\n new_bytes = self.socket.recv(self.BUFFER_SIZE)\\n self.__recv_buffer = self.__recv_buffer + new_bytes\\n return self.__parse_one_message()\",\n \"def grab_frame(self):\\n with self._buflock:\\n if self._buffer is None:\\n return None\\n buf = self._buffer.tostring()\\n return buf\",\n \"def RPC_decode(sock,blocking=False):\\r\\n # Get the dictionary length\\r\\n # Then, Get the dictionary\\r\\n if blocking:\\r\\n length = int(sock.recv(RPC_FIXED_SIZE,blocking=True))\\r\\n dict_str = sock.recv(length,blocking=True)\\r\\n else:\\r\\n length = int(sock.recv(RPC_FIXED_SIZE))\\r\\n dict_str = sock.recv(length)\\r\\n \\r\\n dict_obj = deserialize(dict_str) # Convert to object\\r\\n return dict_obj\",\n \"def parse(self, data: bytes, parse_ts=True) -> tuple:\\n sync_offset = data.find(b'\\\\x47')\\n if sync_offset == -1: # No sync bit in packet\\n return None, None, len(data)\\n if sync_offset != 0: # Resync\\n data = data[sync_offset:]\\n for i in range(int(len(data) / self.__psize)):\\n if sync_offset != 0:\\n self.__resync = sync_offset\\n sync_offset = 0\\n else:\\n self.__resync = 0\\n packet = data[:self.__psize]\\n data = data[self.__psize:]\\n if len(packet) < self.__psize:\\n yield None, None, len(packet)\\n parsed = None\\n if parse_ts:\\n parsed = self.__parse(packet)\\n yield packet, parsed, self.__resync\",\n \"def read_pkt_line(self):\\n if self._readahead is None:\\n read = self.read\\n else:\\n read = self._readahead.read\\n self._readahead = None\\n\\n try:\\n sizestr = read(4)\\n if not sizestr:\\n raise HangupException()\\n size = int(sizestr, 16)\\n if size == 0:\\n if self.report_activity:\\n self.report_activity(4, \\\"read\\\")\\n return None\\n if self.report_activity:\\n self.report_activity(size, \\\"read\\\")\\n pkt_contents = read(size - 4)\\n except socket.error as e:\\n raise GitProtocolError(e)\\n else:\\n if len(pkt_contents) + 4 != size:\\n raise GitProtocolError(\\n \\\"Length of pkt read %04x does not match length prefix %04x\\\"\\n % (len(pkt_contents) + 4, size)\\n )\\n return pkt_contents\",\n \"def readpacket(self, n):\\n try:\\n msg = self.sock.recv(n)\\n except BaseException:\\n msg = ''\\n return msg\",\n \"def receive(self, packet):\\n packet_key = (packet.src, packet.dest)\\n # receiving wan\\n if packet.dest in self.address_to_port:\\n # The packet is destined to one of the clients connected to this middlebox;\\n # send the packet there.\\n\\n if not packet.is_raw_data:\\n block = self.hash_payloads[packet.payload]\\n self.send_block(block, packet_key, packet.is_fin, False)\\n else:\\n self.add_packet_to_buffer(packet_key, packet)\\n curr_block = self.buffers[packet_key]\\n block_length = len(curr_block)\\n left = 0\\n right = 48 if block_length >= 48 else block_length\\n while right <= block_length:\\n block = curr_block[left:right]\\n block_hash = utils.get_hash(block)\\n is_delimiter = utils.get_last_n_bits(block_hash, 13) == self.GLOBAL_MATCH_BITSTRING\\n if is_delimiter:\\n send_block = curr_block[:right]\\n curr_block = curr_block[right:]\\n self.buffers[packet_key] = curr_block\\n self.determine_if_hashed(send_block, packet_key, packet.is_fin, False)\\n left = right\\n if block_length - right >= 48:\\n right = right + 48\\n else:\\n right = block_length\\n if packet.is_fin:\\n send_block = curr_block[left: block_length]\\n self.determine_if_hashed(send_block, packet_key, True, False)\\n self.buffers.pop(packet_key, None)\\n break\\n else:\\n left = left + 1\\n right = right + 1\\n if packet_key in self.buffers:\\n if packet.is_fin:\\n send_block = self.buffers[packet_key]\\n self.determine_if_hashed(send_block, packet_key, True, False)\\n self.buffers.pop(packet_key, None)\\n else:\\n self.buffers.pop(packet_key, None)\\n # sending wan\\n else:\\n # The packet must be destined to a host connected to the other middlebox\\n # so send it across the WAN.\\n\\n self.add_packet_to_buffer(packet_key, packet)\\n curr_block = self.buffers[packet_key]\\n block_length = len(curr_block)\\n left = 0\\n right = 48 if block_length >= 48 else block_length\\n while right <= block_length:\\n block = curr_block[left:right]\\n block_hash = utils.get_hash(block)\\n is_delimiter = utils.get_last_n_bits(block_hash, 13) == self.GLOBAL_MATCH_BITSTRING\\n if is_delimiter:\\n send_block = curr_block[:right]\\n curr_block = curr_block[right:]\\n self.buffers[packet_key] = curr_block\\n self.determine_if_hashed(send_block, packet_key, packet.is_fin, True)\\n left = right\\n if block_length - right >= 48:\\n right = right + 48\\n else:\\n right = block_length\\n if packet.is_fin:\\n send_block = curr_block[left: block_length]\\n self.determine_if_hashed(send_block, packet_key, True, True)\\n self.buffers.pop(packet_key, None)\\n break\\n else:\\n left = left + 1\\n right = right + 1\\n if packet_key in self.buffers:\\n if packet.is_fin:\\n send_block = self.buffers[packet_key]\\n self.determine_if_hashed(send_block, packet_key, True, True)\\n self.buffers.pop(packet_key, None)\\n else:\\n self.buffers.pop(packet_key, None)\",\n \"def _extract_buffer(self, sample: Gst.Sample) -> typ.Optional[GstBuffer]:\\n buffer = sample.get_buffer()\\n caps = sample.get_caps()\\n\\n cnt = buffer.n_memory()\\n if cnt <= 0:\\n self.log.warning(\\\"%s No data in Gst.Buffer\\\", self)\\n return None\\n\\n memory = buffer.get_memory(0)\\n if not memory:\\n self.log.warning(\\\"%s No Gst.Memory in Gst.Buffer\\\", self)\\n return None\\n\\n array = gst_buffer_with_caps_to_ndarray(buffer, caps, do_copy=True)\\n\\n return GstBuffer(\\n data=array,\\n pts=buffer.pts,\\n dts=buffer.dts,\\n duration=buffer.duration,\\n offset=buffer.offset,\\n )\",\n \"def peek_rear(self):\\n if len(self) == 0:\\n if self.none_for_empty:\\n return None\\n raise ValueError(\\\"Buffer is empty\\\")\\n return self.buf[self.rear]\",\n \"def _unpack_body(self, buff):\\n\\n # Unpack <return_code> and <count> (how many records affected or selected)\\n self._return_code = struct_L.unpack_from(buff, offset=0)[0]\\n\\n # Separate return_code and completion_code\\n self._completion_status = self._return_code & 0x00ff\\n self._return_code >>= 8\\n\\n # In case of an error unpack the body as an error message\\n if self._return_code != 0:\\n self._return_message = unicode(buff[4:-1], self.charset, self.errors)\\n if self._completion_status == 2:\\n raise TarantoolError(self._return_code, self._return_message)\\n\\n # Unpack <count> (how many records affected or selected)\\n self._rowcount = struct_L.unpack_from(buff, offset=4)[0]\\n\\n # If the response doesn't contain any tuple - there is nothing to unpack\\n if self._body_length == 8:\\n return\\n\\n # Parse response tuples (<fq_tuple>)\\n if self._rowcount > 0:\\n offset = 8 # The first 4 bytes in the response body is the <count> we have already read\\n while offset < self._body_length:\\n # In resonse tuples have the form <size><tuple> (<fq_tuple> ::= <size><tuple>).\\n # Attribute <size> takes into account only size of tuple's <field> payload,\\n # but does not include 4-byte of <cardinality> field.\\n #Therefore the actual size of the <tuple> is greater to 4 bytes.\\n tuple_size = struct.unpack_from(\\\"<L\\\", buff, offset)[0] + 4\\n tuple_data = struct.unpack_from(\\\"<%ds\\\" % (tuple_size), buff, offset+4)[0]\\n tuple_value = self._unpack_tuple(tuple_data)\\n if self.field_types:\\n self.append(self._cast_tuple(tuple_value))\\n else:\\n self.append(tuple_value)\\n\\n offset = offset + tuple_size + 4 # This '4' is a size of <size> attribute\",\n \"def wait_packet(self, clazz):\\n while True:\\n pkt = PacketRegistry.decode(self.read())\\n if isinstance(pkt, clazz):\\n return pkt\",\n \"def packet_from_bytes(data: bytes) -> Packet:\\n packet = PacketBase.from_buffer_copy(data)\\n struct = packet.struct_type()\\n if len(data) != struct.SIZE:\\n raise racetools.errors.PacketSizeMismatch(struct.SIZE, len(data))\\n return struct.from_buffer_copy(data)\",\n \"def _decode_message(self, label: str, buf, typedef=None, pos=0, end=None, group=False):\\n print(str(pos) + \\\" decode_message \\\" + label)\\n if end is None:\\n end = len(buf)\\n\\n if typedef is None:\\n typedef = {}\\n else:\\n # Don't want to accidentally modify the original\\n typedef = copy.deepcopy(typedef)\\n output = {}\\n\\n while pos < end:\\n oldpos = pos\\n tag, pos = decoder._DecodeVarint(buf, pos)\\n try:\\n field_number, wire_type = wire_format.UnpackTag(tag)\\n except Exception as exc:\\n raise (ValueError,\\n 'Could not read valid tag at pos %d. Ensure it is a valid protobuf message: %s'\\n % (pos-len(tag), exc), sys.exc_info()[2])\\n # Convert to str\\n field_number = str(field_number)\\n orig_field_number = field_number\\n \\n field_typedef = None\\n if field_number in typedef:\\n field_typedef = typedef[field_number]\\n else:\\n field_typedef = {}\\n field_typedef['type'] = self.wire_type_defaults[wire_type]\\n field_type = field_typedef['type']\\n if self.debug:\\n ft = field_type\\n if ft == None:\\n ft = \\\"None\\\"\\n print(\\\"@\\\" + str(oldpos) + \\\"-\\\" + str(pos-1) + \\\":\\\" + label + \\\" field_number \\\" +\\n str(field_number) +\\n \\\" wire_type \\\" + str(wire_type) +\\n \\\" field_type \\\" + str(ft))\\n # If field_type is None, its either an unsupported wire type, length delim or group\\n # length delim we have to try and decode first\\n field_out = None\\n if field_type == 'LD':\\n field_out, pos = self.decode_message_LD(label, buf, pos, field_typedef)\\n elif field_type == 'endGroup':\\n # TODO Should probably match the field_number to START_GROUP\\n if not group:\\n raise ValueError(\\\"Found END_GROUP before START_GROUP\\\")\\n # exit out\\n return output, typedef, pos\\n elif field_type == 'message':\\n field_out, pos = self.decode_message_message(\\n label, buf, pos, field_typedef, field_number)\\n elif field_type == 'group':\\n group_typedef = None\\n # Check for a anonymous type\\n if 'group_typedef' in field_typedef:\\n group_typedef = field_typedef['group_typedef']\\n field_out, group_typedef, pos = self.decode_group(\\n label, buf, group_typedef, pos)\\n # Save type definition\\n field_typedef['group_typedef'] = group_typedef\\n else:\\n # Verify wiretype matches\\n if self.wiretypes[field_type] != wire_type:\\n raise ValueError(\\\"Invalid wiretype for field number %s. %s is not wiretype %s\\\"\\n % (field_number, field_type, wire_type))\\n # Simple type, just look up the decoder\\n field_out, pos = self.decoders[field_type](buf, pos)\\n field_typedef['type'] = field_type\\n if 'name' not in field_typedef:\\n field_typedef['name'] = ''\\n field_key = field_number\\n if '-' not in field_number and 'name' in field_typedef and field_typedef['name'] != '':\\n field_key = field_typedef['name']\\n # Deal with repeats\\n if field_key in output:\\n if isinstance(field_out, list):\\n if isinstance(output[field_number], list):\\n output[field_key] += field_out\\n else:\\n output[field_key] = field_out.append(output[field_key])\\n else:\\n if isinstance(output[field_number], list):\\n output[field_key].append(field_out)\\n else:\\n output[field_key] = [output[field_key], field_out]\\n else:\\n output[field_key] = field_out\\n typedef[orig_field_number] = field_typedef\\n if self.debug:\\n print(str(field_key) + \\\" field_out:\\\" + str(field_out))\\n if pos > end:\\n raise decoder._DecodeError(\\\"Invalid Message Length, pos=\\\" +\\n str(pos) + \\\" end=\\\" + str(end))\\n # Should never hit here as a group\\n if group:\\n raise ValueError(\\\"Got START_GROUP with no END_GROUP.\\\")\\n print(\\\"decode_message finish \\\" + str(pos))\\n return output, typedef, pos\",\n \"def _get_discard_packet(self):\\n return self.__discard_packet\",\n \"def recvtil(self, delim):\\n buf = b''\\n # TODO maybe not make this O(n**2)...\\n while not delim in buf:\\n buf += self.recv(1)\\n return buf\",\n \"def ReceiveMessageFromPacketInfo(self) -> IPPacketInformation:\",\n \"def _parse_packet(packet: StreamMessageResponse) -> Packet:\\n if packet is None:\\n raise TypeError(\\\"Packet cannot be None!\\\")\\n\\n packet = MessageToDict(packet)\\n\\n # Decoding Header\\n ingress_port_base64 = packet['packet']['metadata'][0]['value'].encode()\\n ingress_port = base64.decodebytes(ingress_port_base64) # retrieving ingress_port; not used, yet\\n\\n # Decoding Payload\\n packet = _scapy_parse(packet)\\n\\n return packet\",\n \"def _read_fixed(buf, length):\\n result = buf.read(length)\\n actual = len(result)\\n if actual != length:\\n raise EndOfMessage(False if actual == 0 else True)\\n return result\",\n \"def remove_buffered_packets(self):\\n seq = self.next_seq\\n while True:\\n p = self.buffer.pop(seq, None)\\n if p is None:\\n break\\n else:\\n seq += len(p.data)\\n yield p\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6680396","0.6446139","0.635691","0.61377084","0.60597813","0.59214246","0.59068066","0.5846877","0.5788773","0.57825875","0.5771481","0.5694871","0.5669175","0.5655013","0.5589426","0.55781716","0.5572244","0.5557182","0.55246246","0.55121374","0.55106103","0.5510396","0.5495902","0.5495885","0.5474145","0.5462859","0.5459933","0.54557073","0.5448626","0.541125","0.54097605","0.53848326","0.5370771","0.5360658","0.53470093","0.5333108","0.53322953","0.5329665","0.5319238","0.531918","0.53190994","0.52803236","0.52479845","0.5238739","0.5234217","0.5229773","0.5223661","0.522224","0.5221993","0.5221581","0.52189606","0.5208241","0.52061296","0.52060795","0.51996213","0.5180704","0.5179554","0.5156061","0.515509","0.51498145","0.5145884","0.5133943","0.51261115","0.511588","0.5092551","0.5088675","0.5079029","0.5064432","0.50627756","0.5057213","0.50562686","0.5046669","0.50410163","0.50408167","0.50358313","0.5034883","0.50312036","0.5024619","0.50227934","0.5020828","0.5019218","0.5017509","0.5016165","0.5004912","0.4994954","0.4994861","0.49912283","0.4974616","0.49709696","0.49708393","0.49694297","0.4967234","0.49659142","0.49606076","0.49527395","0.49520382","0.49500307","0.49403417","0.4939636","0.49277234"],"string":"[\n \"0.6680396\",\n \"0.6446139\",\n \"0.635691\",\n \"0.61377084\",\n \"0.60597813\",\n \"0.59214246\",\n \"0.59068066\",\n \"0.5846877\",\n \"0.5788773\",\n \"0.57825875\",\n \"0.5771481\",\n \"0.5694871\",\n \"0.5669175\",\n \"0.5655013\",\n \"0.5589426\",\n \"0.55781716\",\n \"0.5572244\",\n \"0.5557182\",\n \"0.55246246\",\n \"0.55121374\",\n \"0.55106103\",\n \"0.5510396\",\n \"0.5495902\",\n \"0.5495885\",\n \"0.5474145\",\n \"0.5462859\",\n \"0.5459933\",\n \"0.54557073\",\n \"0.5448626\",\n \"0.541125\",\n \"0.54097605\",\n \"0.53848326\",\n \"0.5370771\",\n \"0.5360658\",\n \"0.53470093\",\n \"0.5333108\",\n \"0.53322953\",\n \"0.5329665\",\n \"0.5319238\",\n \"0.531918\",\n \"0.53190994\",\n \"0.52803236\",\n \"0.52479845\",\n \"0.5238739\",\n \"0.5234217\",\n \"0.5229773\",\n \"0.5223661\",\n \"0.522224\",\n \"0.5221993\",\n \"0.5221581\",\n \"0.52189606\",\n \"0.5208241\",\n \"0.52061296\",\n \"0.52060795\",\n \"0.51996213\",\n \"0.5180704\",\n \"0.5179554\",\n \"0.5156061\",\n \"0.515509\",\n \"0.51498145\",\n \"0.5145884\",\n \"0.5133943\",\n \"0.51261115\",\n \"0.511588\",\n \"0.5092551\",\n \"0.5088675\",\n \"0.5079029\",\n \"0.5064432\",\n \"0.50627756\",\n \"0.5057213\",\n \"0.50562686\",\n \"0.5046669\",\n \"0.50410163\",\n \"0.50408167\",\n \"0.50358313\",\n \"0.5034883\",\n \"0.50312036\",\n \"0.5024619\",\n \"0.50227934\",\n \"0.5020828\",\n \"0.5019218\",\n \"0.5017509\",\n \"0.5016165\",\n \"0.5004912\",\n \"0.4994954\",\n \"0.4994861\",\n \"0.49912283\",\n \"0.4974616\",\n \"0.49709696\",\n \"0.49708393\",\n \"0.49694297\",\n \"0.4967234\",\n \"0.49659142\",\n \"0.49606076\",\n \"0.49527395\",\n \"0.49520382\",\n \"0.49500307\",\n \"0.49403417\",\n \"0.4939636\",\n \"0.49277234\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72920316"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90590,"cells":{"query":{"kind":"string","value":"A wrapper about the normal objects, that lets you pack decoded packets easily. Returns the bytestring that represents the packet."},"document":{"kind":"string","value":"def stateless_pack(packet, to_server):\n\tdecoder = PacketDecoder(to_server)\n\treturn decoder.encode_packet(packet)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def packetize(self):\n byte_str = b''\n\n # Bit string to accumulate bit values until we are ready to convert it into bytes\n bit_str = \"\"\n\n for field in self.fields:\n #if the current field is a special type, the bit_str value to the byte string and clear the accumulated bit_str.\n if not isinstance(field.size, int) and len(bit_str) != 0:\n byte_str += self.encode_bit_str(bit_str)\n bit_str = \"\"\n if field.size == NULL_TERMINATE:\n byte_str += self.encode_null_term(field.value)\n elif field.size == PREFIX_LENGTH:\n byte_str += self.encode_prefix_length(field.value)\n elif field.size == PREFIX_LEN_NULL_TERM:\n byte_str += self.encode_prefix_length_null_term(field.value)\n elif field.size == IPv4:\n byte_str += self.encode_ipv4(field.value)\n elif field.size == 1: # One bit, just add it to our bit string.\n bit_str += \"0\" if field.value == 0 else \"1\"\n else:\n if isinstance(field.value, int):\n bit_str += \"0\" * (field.size - len(bin(field.value)[2:])) + bin(field.value)[2:]\n elif isinstance(field.value, bytes):\n bit_str += field.value.decode('latin-1')\n #clear the bit string one last time\n if len(bit_str) != 0:\n byte_str += self.encode_bit_str(bit_str)\n bit_str = \"\"\n\n return byte_str","def encode_packet(self, packet):\n\n\t\ttry:\n\t\t\toutput = self.pack('ubyte', packet.ident)\n\t\t\tappend = ''\n\t\t\t#0x17\n\t\t\tif packet.ident == 0x17:\n\t\t\t\tif packet.data['unknown'] > 0:\n\t\t\t\t\tfor i in ('x2','y2','z2'):\n\t\t\t\t\t\tappend += self.pack('short', packet.data[i])\n\t\t\t#0x33\n\t\t\tif packet.ident in (0x33, 0x34):\n\t\t\t\tpacket.data['data_size'] = len(packet.data['data'])\n\t\t\t\tappend += self.pack_array_fast('byte', packet.data['data'])\n\t\t\t\n#\t\t\t#0x34\n#\t\t\tif packet.ident == 0x34:\n#\t\t\t\tcoords = []\n#\t\t\t\tbtypes = []\n#\t\t\t\tmetadata = []\n#\t\t\t\tfor i in packet.data['blocks']:\n#\t\t\t\t\tcoords.append(i['x'] << 12 | i['z'] << 8 | i['y'])\n#\t\t\t\t\tbtypes.append(i['type'])\n#\t\t\t\t\tmetadata.append(i['metadata'])\n#\t\t\t\t\n#\t\t\t\tpacket.data['data_size'] = len(coords)\n#\t\t\t\tappend += self.pack_array_fast('short', coords)\n#\t\t\t\tappend += self.pack_array_fast('byte', btypes)\n#\t\t\t\tappend += self.pack_array_fast('byte', metadata)\n\t\t\t\n\t\t\t#0x3C\n\t\t\tif packet.ident == 0x3C:\n\t\t\t\tarray = []\n\t\t\t\tfor i in packet.data['blocks']:\n\t\t\t\t\tarray += [i['x'], i['y'], i['z']]\n\t\t\t\tpacket.data['data_size'] = len(packet.data['blocks'])\n\t\t\t\tappend += self.pack_array_fast('byte', array)\n\t\t\t\n\t\t\t#0x68\n\t\t\tif packet.ident == 0x68:\n\t\t\t\tpacket.data['data_size'] = len(packet.data['slots_data'])\n\t\t\t\tappend += self.pack_array('slot', packet.data['slots_data'])\n\t\t\t#0x82: Sign\n\t\t\tif packet.ident == 0x82:\n\t\t\t\tfor i in range(4):\n\t\t\t\t\tpacket.data[\"line_%s\" % (i+1)] = packet.data[\"text\"][i]\n\t\t\t#0x83\n\t\t\tif packet.ident == 0x83:\n\t\t\t\tpacket.data['data_size'] = len(packet.data['data'])\n\t\t\t\tappend += self.pack_array_fast('byte', packet.data['data'])\n\t\t\n\t\t\tfor i in self.get_struct(packet):\n\t\t\t\toutput += self.pack(i[0], packet.data[i[1]])\n\t\t\t\n\t\t\toutput += append\n\t\t\treturn output\n\t\texcept Exception:\n\t\t\traise","def _pack(self) -> bytes:\n return struct.pack(self.PACKAGING_FORMAT, self.type, self.length)","def obj2bytes(obj: StunPacket) -> bytes:\n\n message = bytes()\n for [attribute_type, attribute_val] in obj.message.items():\n message += pack(\n '{}{}s'.format(ATTRIBUTE_HEADER_FORMAT, len(attribute_val)),\n attribute_type,\n len(attribute_val),\n attribute_val,\n )\n\n type_bits = (\n '00'\n + obj.type_method[0:5]\n + obj.type_class[0]\n + obj.type_method[5:8]\n + obj.type_class[1]\n + obj.type_method[8:]\n )\n return pack(\n '{}{}s'.format(HEADER_FORMAT, len(message)),\n int(type_bits, 2),\n len(message),\n obj.magic_cookie,\n obj.transaction_id,\n message,\n )","def bytes(self):\n return bytes(self._packet)","def pack(self):\n \n data = \"\".join(map(lambda arg: arg.pack(), self))\n data = struct.pack(\">2H\", self.type, len(data)) + data\n \n return data","def make_packet(self, type, data): \n return (\"{}\\x00{}\\x00{}\".format(type, data, self.ID)).encode()","def _marshal(self, pieces):\n payload = b''.join(pieces)\n return struct.pack('>BHI', self.frame_type, self.channel_number,\n len(payload)) + payload + bytes((spec.FRAME_END,))","def encode_packet(self, packet, b64=False):\n if packet.binary and not b64:\n bytes = six.int2byte(packet.type)\n else:\n bytes = six.binary_type(packet.type)\n if packet.binary and b64:\n bytes = 'b' + bytes\n\n if packet.binary and b64:\n bytes += base64.b64encode(packet.data).decode('utf-8')\n else:\n bytes += six.binary_type(packet.data)\n\n return bytes","def encode(self):\n return (struct.pack(b\"<iii\", self.size, self.id, self.type) +\n self.body.encode(\"ascii\") + b\"\\x00\\x00\")","def __bytes__(self):\n # Mac address case\n if self.subtype == 3:\n return bytes([self.type * 2, 1 + 6, self.subtype]) + self.value\n # ip address case\n elif self.subtype == 4:\n if self.value.version == 4:\n # ipv4 case\n return bytes([self.type * 2, 1 + 5, self.subtype ,1]) + self.value.packed\n else:\n # ipv6 case\n return bytes([self.type * 2, 1 + 17, self.subtype, 2]) + self.value.packed\n\n #all other cases:\n else:\n if len(self.value) > 255:\n return bytes([(self.type * 2) + 1, len(self.value) - 256, self.subtype]) + bytes(self.value, 'utf-8')\n else:\n return bytes([self.type * 2, len(self.value) + 1, self.subtype]) + bytes(self.value,'utf-8')","def to_buffer(self) -> bytearray:\n packet = bytearray()\n packet.extend(\n struct.pack(\n \"!ccccHH\",\n \"D\".encode(\"ascii\"),\n \"L\".encode(\"ascii\"),\n \"E\".encode(\"ascii\"),\n \"P\".encode(\"ascii\"),\n int(self.type),\n self.len,\n )\n )\n return packet","def packet(self):\n return self.server.packet(context=self.ctx)","def _finalize_packet(self, rudp_packet):\n return rudp_packet.to_bytes()","def getBinary(self):\n address = OSCArgument(self.address)[1]\n typetags = OSCArgument(self.typetags)[1]\n return address + typetags + self.message","def pack(self):\n return self._STRUCT.pack(\n self._SYNC, self.sequence_number, self.packet_id, self.data_length,\n self.p1, self.p2, self.p3, self.p4, self.p5\n ) + (\n pack('%ss' % len(self.data), self.data)\n )","def _pack(self) -> bytes:\n\n return struct.pack(\n self.PACKAGING_FORMAT, \n self.first_operand, \n self.operator, \n self.type_of_second_operand, \n self.second_operand, \n self.length\n )","def encode(self):\r\n data = ''\r\n if self.id == PUSH_ACK:\r\n data = pack('<BHB', self.version, self.token, self.id)\r\n elif self.id == PULL_ACK:\r\n data = pack('<BHB', self.version, self.token, self.id)\r\n elif self.id == PULL_RESP:\r\n if self.version == 1:\r\n self.token = 0\r\n self.payload = self.txpk.encode()\r\n print(str(self.payload))\r\n data = pack('<BHB', self.version, self.token, self.id) + \\\r\n bytearray(self.payload,'utf-8')\r\n return data","def _pack(self) -> bytes:\n\n return struct.pack(self.PACKAGING_FORMAT, self.ref_id)","def __bytes__(self):\n return (\n bytes(self.block_header) +\n pack_compact_int(len(self.txns)) +\n b''.join([bytes(t) for t in self.txns])\n )","def _to_bytes(self, item):\n data = bytes(type(item).write_to_string(item)) if isinstance(item, Struct) else \\\n bytes(item.pack()) if isinstance(item, Buffer) else \\\n '' if item is None else bytes(item)\n return data","def __str__(self):\n return '\\n%(source)s > %(type)s (0x%(type_d).2x)\\n%(data)s' % \\\n {'type': DGTL.pkt_type_str[self.type], 'type_d': self.type,\n 'data': str(self.decoded) if self.decoded else 'Unknown raw data.',\n 'source': self.source}","def build_packets(self):\n from scapy.all import IP, TCP\n return IP()/TCP()","def encode(self) -> bytes:\n\n # unsigned char dmac[6];\n # unsigned char smac[6];\n # uint16_t ethertype;\n # unsigned char payload[];\n\n t = struct.pack(\"H\", socket.htons(self.typ))\n return self.dmac + self.smac + t + self.payload","def read_packet(self):\n\n\t\t#self.debug(\"READ BUFFER SIZE: %d\" % len(self.buff))\n\t\tbackup = self.buff[:]\n\t\tpacket = Packet()\n\t\ttry:\n\t\t\tpacket.direction = self.node\n\t\t\tpacket.ident = self.unpack('ubyte')\n\t\t\t\n\t\t\t#Defined structs from huge dict\n\t\t\tfor datatype, name in self.get_struct(packet):\n\t\t\t\t# this populates packet.data with {name: value}\n\t\t\t\tpacket.data[name] = self.unpack(datatype)\n\n\t\t\t# I believe the following are packet-type specific fixes for variable-length packets.\n\n\t\t\t#0x17\n\t\t\tif packet.ident == 0x17:\n\t\t\t\tif packet.data['unknown'] > 0:\n\t\t\t\t\tpacket.data['x2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['y2'] = self.unpack('short')\n\t\t\t\t\tpacket.data['z2'] = self.unpack('short')\n\t\t\n\t\t\t#0x33\n\t\t\tif packet.ident in (0x33, 0x34):\n\t\t\t\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n#\t\t\t#0x34\n#\t\t\tif packet.ident == 0x34:\n#\t\t\t\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\n#\t\t\t\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\n#\t\t\t\tpacket.data[\"blocks\"] = []\n#\t\t\t\tfor i in zip(coords, btype, metadata):\n#\t\t\t\t\tblock = {}\n#\t\t\t\t\tblock[\"x\"] =\t\ti[0] >> 12\n#\t\t\t\t\tblock[\"z\"] = 0x0F & i[0] >> 8\n#\t\t\t\t\tblock[\"y\"] = 0xFF & i[0]\n#\t\t\t\t\tblock[\"type\"] = i[1]\n#\t\t\t\t\tblock[\"metadata\"] = i[2]\n#\t\t\t\t\tpacket.data[\"blocks\"].append(block)\n#\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x3C\n\t\t\tif packet.ident == 0x3C:\n\t\t\t\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\n\t\t\t\ti = 0\n\t\t\t\tpacket.data[\"blocks\"] = []\n\t\t\t\twhile i < packet.data['data_size']*3:\n\t\t\t\t\tpacket.data[\"blocks\"].append(dict(zip(('x','y','z'), records[i:i+3])))\n\t\t\t\t\ti+=3\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\n\t\t\t#0x68\n\t\t\tif packet.ident == 0x68:\n\t\t\t\tpacket.data[\"slots_data\"] = self.unpack_array('slot', packet.data[\"data_size\"])\n\t\t\t\tdel packet.data[\"data_size\"]\n\t\t\t#0x82:\n\t\t\tif packet.ident == 0x82:\n\t\t\t\tpacket.data[\"text\"] = []\n\t\t\t\tfor i in range(4):\n\t\t\t\t\tpacket.data[\"text\"].append(packet.data[\"line_%s\" % (i+1)])\n\t\t\t\t\t\n\t\t\t#0x83\n\t\t\tif packet.ident == 0x83:\n\t\t\t\tpacket.data[\"data\"] = self.unpack_array_fast('byte', packet.data['data_size'])\n\t\t\t\tdel packet.data[\"data_size\"]\n\n\t\t\t# Sets packet.original to the byte string that the packet was decoded from.\n\t\t\tpacket.original = backup[:len(backup) - len(self.buff)]\n\n\t\t\treturn packet\n\n\t\texcept IncompleteData:\n\t\t\tself.buff = backup\n\t\t\treturn None\n\t\texcept Exception, ex:\n\t\t\tself.buff = backup\n\t\t\tex.args += (self.buff[20:],)\n\t\t\traise","def encode(self) -> bytes:\n return pack('<B' + self.fmt, *([self.type] + self.__args))","def encode(self):\n packed = struct.pack(\"<2Bl\",\n self.device_number,\n self.command_number,\n self.data)\n if self.message_id is not None:\n packed = packed[:5] + struct.pack(\"B\", self.message_id)\n return packed","def encode_payload(self, packets, b64=False):\n bytes = b''\n for packet in packets:\n packet_bytes = self.encode_packet(packet, b64)\n packet_len = len(packet_bytes)\n if b64:\n bytes += str(packet_len) + b':' + packet_bytes\n else:\n binary_len = b''\n while packet_len != 0:\n binary_len = six.int2byte(packet_len % 10) + binary_len\n packet_len = int(packet_len / 10)\n bytes += b'\\x01' if packet.binary else b'\\x00'\n bytes += binary_len + b'\\xff' + packet_bytes\n\n return bytes","def _pack(self):\n pass","def __bytes__(self):\n return pack(\"<HH\", self._packet_len, self._control_ctr)","def dump(self) : \n mybuffer = []\n if None not in (self.version, self.operation_id) :\n mybuffer.append(chr(self.version[0]) + chr(self.version[1]))\n mybuffer.append(pack(\">H\", self.operation_id))\n mybuffer.append(pack(\">I\", self.request_id or 1))\n for attrtype in self.attributes_types :\n for attribute in getattr(self, \"_%s_attributes\" % attrtype) :\n if attribute :\n mybuffer.append(chr(self.tagvalues[\"%s-attributes-tag\" % attrtype]))\n for (attrname, value) in attribute :\n nameprinted = 0\n for (vtype, val) in value :\n mybuffer.append(chr(self.tagvalues[vtype]))\n if not nameprinted :\n mybuffer.append(pack(\">H\", len(attrname)))\n mybuffer.append(attrname)\n nameprinted = 1\n else :\n mybuffer.append(pack(\">H\", 0))\n if vtype in (\"integer\", \"enum\") :\n mybuffer.append(pack(\">H\", 4))\n mybuffer.append(pack(\">I\", val))\n elif vtype == \"boolean\" :\n mybuffer.append(pack(\">H\", 1))\n mybuffer.append(chr(val))\n else :\n mybuffer.append(pack(\">H\", len(val)))\n mybuffer.append(val)\n mybuffer.append(chr(self.tagvalues[\"end-of-attributes-tag\"]))\n mybuffer.append(self.data)\n return \"\".join(mybuffer)","def _create_packet(self, request):\n\n data_len = struct.pack('<Q', len(request))\n packet = b'ZBXD\\x01' + data_len + request\n\n def ord23(x):\n if not isinstance(x, int):\n return ord(x)\n else:\n return x\n\n logger.debug('Packet [str]: %s', packet)\n logger.debug('Packet [hex]: %s', ':'.join(hex(ord23(x))[2:] for x in packet))\n return packet","def serialize_str(self, obj):\n if len(obj) < 0x100:\n return 'U' + struct.pack('<B', len(obj)) + obj\n return 'T' + struct.pack('<I', len(obj)) + obj","def _pack(self):\n to_pack = {\n \"remote_ip\": self.remote_ip,\n \"remote_port\": self.remote_port,\n \"min_fidelity\": self.min_fidelity,\n \"max_time\": self.max_time,\n \"num_pairs\": self.num_pairs,\n \"priority\": self.priority,\n \"store\": self.store,\n \"atomic\": self.atomic,\n \"measure_directly\": self.measure_directly,\n }\n request_Bitstring = bitstring.pack(self.PACKAGING_FORMAT, **to_pack)\n requestH = request_Bitstring.tobytes()\n\n return requestH","def __bytes__(self):\n return self.header_bytes() + self.payload","def serialize(self, buff):\n try:\n _x = self.name\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.compatibility\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.display_name\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.description\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.namespace\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.icon.resource_name\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.icon.format\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.icon.data\n length = len(_x)\n # - if encoded as a list instead, serialize as bytes instead of string\n if type(_x) in [list, tuple]:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n length = len(self.remappings)\n buff.write(_struct_I.pack(length))\n for val1 in self.remappings:\n _x = val1.remap_from\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = val1.remap_to\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self.parameters\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n buff.write(_struct_i.pack(self.max))\n _x = self.pairing.rapp\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n length = len(self.pairing.remappings)\n buff.write(_struct_I.pack(length))\n for val1 in self.pairing.remappings:\n _x = val1.remap_from\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = val1.remap_to\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n length = len(self.pairing.parameters)\n buff.write(_struct_I.pack(length))\n for val1 in self.pairing.parameters:\n _x = val1.key\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = val1.value\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n buff.write(_struct_i.pack(self.hash))\n _x = self.role\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n except struct.error as se: self._check_types(struct.error(\"%s: '%s' when writing '%s'\" % (type(se), str(se), str(locals().get('_x', self)))))\n except TypeError as te: self._check_types(ValueError(\"%s: '%s' when writing '%s'\" % (type(te), str(te), str(locals().get('_x', self)))))","def __bytes__(self):\n prm = self.package(self.p, LEN_PRIME)\n gen = self.package(self.g, LEN_GEN)\n pbk = self.package(self.pk, LEN_PK)\n return prm + gen + pbk","def encode(self) -> bytes:\n version_ihl = self._version << 4 | self._ihl\n flags_fragoffset = self._flags << 13 | self._frag_offset\n\n raw = struct.pack(\n IPHeader.fmt,\n version_ihl,\n self._tos,\n self.len,\n self.id,\n flags_fragoffset,\n self._ttl,\n self.proto,\n self._csum,\n self.saddr,\n self.daddr,\n )\n return raw + self.payload","def _pack_data( self, data ) : \r\n \r\n # hints = self._translation_table.get( type(data), None )\r\n hints = self._get_hints( data ) \r\n \r\n if hints is None : \r\n \r\n ## #debug: \r\n ## print \"_pack_data(): no hints for data type %s (data repr: %s)\" % (type(data), repr(data))\r\n \r\n # \"one-level recursion\" : \r\n # return self._pack_data( repr(data) )\r\n return self._pack_data( str(data) )\r\n \r\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \r\n ## if data is None: data = 0\r\n \r\n # else ... \r\n \r\n # 'DescType' + 'length' + 'data'\r\n desctype = hints[0]\r\n if desctype == 'TEXT' : \r\n length = len(data)\r\n data_str = data \r\n else :\r\n length = struct.calcsize( hints[1] )\r\n data_str = struct.pack( hints[1], data )\r\n \r\n length_str = struct.pack('=H', length)\r\n \r\n \r\n return _cat(desctype, length_str, data_str)","def serialize(self, buff):\n try:\n _x = self\n buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))\n _x = self.header.frame_id\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self\n buff.write(_struct_3I.pack(_x.pan.header.seq, _x.pan.header.stamp.secs, _x.pan.header.stamp.nsecs))\n _x = self.pan.header.frame_id\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self\n buff.write(_struct_6f3df3I.pack(_x.pan.current, _x.pan.pos_rad, _x.pan.vel_rps, _x.pan.torque_nm, _x.pan.pwm, _x.pan.encoder_rad, _x.pan.accel.x, _x.pan.accel.y, _x.pan.accel.z, _x.pan.temperature_degC, _x.tilt.header.seq, _x.tilt.header.stamp.secs, _x.tilt.header.stamp.nsecs))\n _x = self.tilt.header.frame_id\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n _x = self\n buff.write(_struct_6f3df.pack(_x.tilt.current, _x.tilt.pos_rad, _x.tilt.vel_rps, _x.tilt.torque_nm, _x.tilt.pwm, _x.tilt.encoder_rad, _x.tilt.accel.x, _x.tilt.accel.y, _x.tilt.accel.z, _x.tilt.temperature_degC))\n except struct.error as se: self._check_types(struct.error(\"%s: '%s' when writing '%s'\" % (type(se), str(se), str(locals().get('_x', self)))))\n except TypeError as te: self._check_types(ValueError(\"%s: '%s' when writing '%s'\" % (type(te), str(te), str(locals().get('_x', self)))))","def create_message(self, packet):\n self._header.packet_len = len(bytes(packet))\n \n frame_bytes = super(EthernetTransport, self).create_message(packet) \n \n # Update control counter for next frame\n self._header.update_control()\n \n return bytes(frame_bytes)","def bytes2obj(buf: bytes) -> StunPacket:\n\n type_raw, length, magic_cookie, transaction_id = unpack_from(\n HEADER_FORMAT, buf, 0)\n\n # Convert message type into bits, to parse it as a class and method.\n type_bits: str = bin(type_raw)[2:].zfill(16)\n if type_bits[:2] != \"00\":\n raise Exception(\n \"STUN packet invalid - most signifigant 2 bits must be zeroes.\")\n type_class = type_bits[7] + type_bits[11]\n type_method = type_bits[2:7] + type_bits[8:11] + type_bits[12:]\n\n message_bytes = unpack_from('!{}s'.format(\n length), buf, calcsize(HEADER_FORMAT))[0]\n # if magic_cookie != bytes.fromhex(\"2112A442\"):\n # print(\"Warning: Request not RFC 8489 compilant.\")\n\n message_read = 0\n message: Dict[bytes, bytes] = {}\n while message_read < length:\n attribute_type, attribute_length = unpack_from(\n ATTRIBUTE_HEADER_FORMAT, message_bytes, message_read\n )\n attribute_val = unpack_from(\n \"!{}s\".format(attribute_length), message_bytes, message_read +\n calcsize(ATTRIBUTE_HEADER_FORMAT)\n )[0]\n message[attribute_type] = attribute_val\n\n message_read += calcsize(ATTRIBUTE_HEADER_FORMAT)\n message_read += attribute_length\n\n return StunPacket(type_class, type_method, magic_cookie, transaction_id, message)","def __str__(self):\n return bytes_to_string(self._bytes)","def __bytes__(self) -> bytes:\n from hathor.merged_mining.bitcoin import encode_bytearray, encode_list\n struct_bytes = self.header_head\n struct_bytes += encode_bytearray(self.coinbase_head)\n struct_bytes += encode_bytearray(self.coinbase_tail)\n struct_bytes += encode_list(self.merkle_path)\n struct_bytes += self.header_tail\n return struct_bytes","def to_bytes(self, **kwargs: Any) -> bytes:\n serial = OrderedDict(\n (\n (\"spaczz_overwrite\", self.overwrite),\n (\"spaczz_ent_id_sep\", self.ent_id_sep),\n (\"spaczz_patterns\", self.patterns),\n (\"spaczz_defaults\", self.defaults),\n )\n )\n return srsly.msgpack_dumps(serial)","def read_raw_packet(self):\n\n size = 0\n\n # Read our two-byte header from the debugger...\n while not size:\n size = (self._get_next_byte() << 16) | self._get_next_byte()\n\n # ... and read our packet.\n packet = bytearray([self._get_next_byte() for _ in range(size)])\n\n # Return our packet.\n # TODO: extract and provide status flags\n # TODO: generate a timestamp on-device\n return packet, datetime.now(), None","def pack(self):\n\n msg = struct.pack(SentmanRequest.FORMAT,\n self.version, self.op_type, self.msg_len)\n return msg","def str(self):\n return struct.pack(\n '!IIIIIIIIIII',\n self.magic,\n self.totalsize,\n self.off_dt_struct,\n self.off_dt_strings,\n self.off_mem_rsvmap,\n self.version,\n self.last_comp_version,\n self.size_dt_strings,\n self.size_dt_struct\n )","def serialize(self):\n\n # The len must be multiple of 4 bits to convert unambiguously\n\n id_len = self.id.bit_length()\n while (id_len % 4)!= 0:\n id_len += 1\n if self.payload:\n pay_len = self.payload.bit_length()\n while (pay_len % 4)!= 0:\n pay_len += 1\n else: pay_len = 0\n if self.command:\n com_len = self.command.bit_length()\n while (com_len % 4)!= 0:\n com_len += 1\n else: com_len = 0\n\n values = {\n \"id\": self.id,\n \"id_len\": id_len,\n \"payload\": self.payload,\n \"payload_len\": pay_len,\n \"command\": self.command,\n \"command_len\": com_len\n }\n\n\n if self.id == Message.MEASURE or self.id == Message.SINGLE_MEASURE:\n serial_format = (\n \"uint:id_len=id, bits:payload_len=payload, bits:command_len = command, 0x0D0A\"\n )\n else:\n serial_format = (\n \"0x23, uint:id_len=id, bits:payload_len=payload, bits:command_len = command, 0x0D0A\"\n )\n\n message = bitstring.pack(serial_format, **values)\n\n rospy.logdebug(\"Sent command '0x%s'\", message.hex)\n\n return message.tobytes()","def string_raw(self):\n return \"x%x\" % self.encoded","def marshal(self):\n return b'AMQP' + struct.pack('BBBB', 0, self.major, self.minor,\n self.revision)","def __bytes__(self):\n if self._header.value_type in b'ZH':\n value = self._buffer[:-1] # Omit the trailing Null\n elif self._header.value_type in b'AB':\n value = self._buffer\n else:\n value = str(self._buffer.value).encode('ASCII')\n return self._header.tag + b':' + (self._header.value_type if self._header.value_type in b'AifZHB' else b'i') + b':' + value","def tobytes(self):\n\n self.meta.msg_id = self.body.__msg_id__\n self.meta.msg_class = self.body.__msg_class__\n offset = HEADER_STRUCT_SIZE\n if (\n isinstance(self.body, Modern)\n and not self.body.binary is None\n and self.meta.msg_class in (MSG_CLASS_MODERN_BINARY, MSG_CLASS_MODERN_OTHER)\n ):\n offset += 4\n buffer = bytearray()\n (body_len, bin_offset) = self.body.__pack_into__(self.meta, buffer, offset)\n self.meta.__pack_into__(buffer, body_len, bin_offset)\n return bytes(buffer)","def to_bytes(self, ???):","def _pack(self):\n header = struct.pack(self.PACKAGING_FORMAT, self.cmd_length)\n return header","def from_network_layer(buffer):\r\n packet = buffer.get_packet()\r\n # print(f'buffer.message:{buffer.message}')\r\n # if packet == None:\r\n # print(f\"[from_network_layer] packet:NULL\")\r\n print(f\"[from_network_layer] packet:{packet}\")\r\n return packet","def encode(self):\n b = 0 | self.mtype << 5 | self.major\n data = struct.pack('B', b)\n return data","def to_bytes(self) -> bytes:","def dump_payload(self, obj):\n return want_bytes(self.serializer.dumps(obj, **self.serializer_kwargs))","def as_packet(self, ptype):\n return ctypes.cast(self.ptr, ctypes.POINTER(ptype))[0]","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def to_bytes(self, *args, **kwargs): # real signature unknown\n pass","def dump(self):\n avps = self.get_all_avps_contents()\n auth = self.compute_authenticator(avps)\n header = struct.pack(RadiusMessage.RADIUS_HDR_TMPL, self.code,\n self.pid, len(self), auth)\n return b\"\".join([header, avps])","def __init__(self, bytes = None):\n version = pcs.Field(\"version\", 4, default = 4)\n hlen = pcs.Field(\"hlen\", 4)\n tos = pcs.Field(\"tos\", 8)\n length = pcs.Field(\"length\", 16)\n id = pcs.Field(\"id\", 16)\n flags = pcs.Field(\"flags\", 3)\n offset = pcs.Field(\"offset\", 13)\n ttl = pcs.Field(\"ttl\", 8, default = 64)\n protocol = pcs.Field(\"protocol\", 8)\n checksum = pcs.Field(\"checksum\", 16)\n src = pcs.Field(\"src\", 32)\n dst = pcs.Field(\"dst\", 32)\n pcs.Packet.__init__(self,\n [version, hlen, tos, length, id, flags, offset,\n ttl, protocol, checksum, src, dst],\n bytes = bytes)\n # Description MUST be set after the PCS layer init\n self.description = \"IPv4\"\n\n\n if (bytes != None):\n offset = self.hlen << 2\n self.data = self.next(bytes[offset:len(bytes)])\n else:\n self.data = None","def make_binary_protocol(*, \n encode_function: Callable, \n decode_function: Callable, \n byteEncodingString: str, # struct pattern for the header\n infoBytes: int # amount of bytes to read off (must match the struct pattern)\n ) -> _SocketProtocol:\n\n def send_message(sock: socket, packet: StrictPacket):\n serialised = encode_function(packet)\n bytes_ = struct.pack(byteEncodingString, len(serialised)) + serialised\n sock.send(bytes_)\n\n def recv_message(sock: socket) -> Packet:\n lengthRaw = sock.recv(infoBytes)\n try:\n length = struct.unpack(byteEncodingString, lengthRaw)[0]\n except struct.error:\n return None\n raw = sock.recv(length)\n try:\n return decode_function(raw)\n except PacketMalformedError:\n return None\n\n return _SocketProtocol(send_message, recv_message)","def __bytes__(self):\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')","def __bytes__(self):\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')","def __bytes__(self):\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')","def object_to_bytes(obj):\n if isinstance(obj, str):\n return bytearray(obj, \"UTF-8\")\n elif isinstance(obj, bool):\n return bytearray()\n elif isinstance(obj, int):\n return pack(\"<L\", obj)\n elif obj == None:\n return bytearray()\n elif isinstance(obj, bytearray):\n return obj\n else:\n #print type(obj), obj\n return obj.get_raw()","def pack(self):\n if self.originalOriginate is None:\n os, on = divmod(self.originateNanos,1000000000)\n else:\n os, on = self.originalOriginate\n rs, rn = divmod(self.receiveNanos, 1000000000)\n ts, tn = divmod(self.transmitNanos, 1000000000)\n msg = struct.pack(WCMessage.STRUCT_FMT, 0, self.msgtype, self.precision, 0, self.maxFreqError, os, on, rs, rn, ts, tn) \n return msg","def serialize(self, buff):\n try:\n _x = self\n buff.write(_struct_2d2q14dq.pack(_x.tcp, _x.ori, _x.zone, _x.vacuum, _x.workx, _x.worky, _x.workz, _x.workq0, _x.workqx, _x.workqy, _x.workqz, _x.toolx, _x.tooly, _x.toolz, _x.toolq0, _x.toolqx, _x.toolqy, _x.toolqz, _x.ret))\n _x = self.msg\n length = len(_x)\n if python3 or type(_x) == unicode:\n _x = _x.encode('utf-8')\n length = len(_x)\n if python3:\n buff.write(struct.pack('<I%sB'%length, length, *_x))\n else:\n buff.write(struct.pack('<I%ss'%length, length, _x))\n except struct.error as se: self._check_types(struct.error(\"%s: '%s' when writing '%s'\" % (type(se), str(se), str(locals().get('_x', self)))))\n except TypeError as te: self._check_types(ValueError(\"%s: '%s' when writing '%s'\" % (type(te), str(te), str(locals().get('_x', self)))))","def to_bytes(self) -> bytes:\n return pack('4B', self.tag, self.flags, self.reserved, self.params_count)","def package(payload):\n return salt.utils.msgpack.dumps(payload)","def payload_from_raw(raw, linktype=1):\n ip = iplayer_from_raw(raw, linktype)\n try: return ip.data.data\n except:\n return \"\"","def packetize(cls, source, raw_data):\n pkt = cls(source, raw_data)\n\n if pkt.type not in DGTL.descriptors.keys():\n raise Warning('Unsupported packet type! (%s)' % pkt.type)\n\n pkt.set_decoder(DGTL.descriptors[pkt.type][2])\n\n return pkt","def _packet_string(self):\n return 'Packet (Length: %s)%s' % (self.length, os.linesep)","def get_binary(self):\n data = bytes()\n\n for tag in self._tags:\n value = 0\n if tag in self.fields.keys():\n value = self.fields[tag]\n try:\n data += struct.pack(\"<I\", value)\n except struct.error as e:\n raise TypeError(f\"expected integer value for {tag} but got {type(value)}: {value}\")\n\n return data","def __str__(self):\n return bytes_to_str(bytes(self))","def encode(self):\n data = struct.pack('BBB', self.cid, self.margin, self.gwcnt)\n return data","def __init__(self, bytes = None, timestamp = None):\n from socket import IPPROTO_TCP\n src = pcs.Field(\"src\", 32)\n dst = pcs.Field(\"dst\", 32)\n reserved = pcs.Field(\"reserved\", 8, default = 0)\n protocol = pcs.Field(\"protocol\", 8, default = IPPROTO_TCP)\n length = pcs.Field(\"length\", 16)\n pcs.Packet.__init__(self, [src, dst, reserved, protocol, length],\n bytes = bytes)\n # Description MUST be set after the PCS layer init\n self.description = inspect.getdoc(self)\n if timestamp == None:\n self.timestamp = time.time()\n else:\n self.timestamp = timestamp\n\n self.data = None","def pack(self, *args):\n return self._msg_struct.pack(self.message_id, *args)","def pack(self):\r\n return pack('!BBHHBBBHBBHBBB',\r\n 17, # size\r\n 0xe0, # pdu type: CR\r\n self.dst_ref,\r\n self.src_ref,\r\n 0, # flag\r\n 0xc1, 2, self.src_tsap,\r\n 0xc2, 2, self.dst_tsap,\r\n 0xc0, 1, self.tpdu_size)","def _pack(self):\n header = struct.pack(self.PACKAGING_FORMAT, self.outcome)\n return header","def decode_packet(self, bytes):\n b64 = False\n if not isinstance(bytes, six.binary_type):\n bytes = bytes.encode('utf-8')\n\n packet_type = six.byte2int(bytes[0:1])\n if packet_type == ord('b'):\n binary = True\n bytes = bytes[1:]\n packet_type = int(chr(six.byte2int(bytes[0:1])))\n b64 = True\n elif packet_type >= ord('0'):\n packet_type = int(chr(packet_type))\n binary = False\n else:\n binary = True\n\n packet_data = None\n if len(bytes) > 1:\n if binary:\n if b64:\n packet_data = base64.b64decode(bytes[1:])\n else:\n packet_data = bytes[1:]\n else:\n packet_data = bytes[1:].decode('utf-8')\n\n return Packet(packet_type, packet_data, binary)","def serialize(self):\n messageLen = len(self._messageBuf) + 1 # 1 byte for the message type\n header = pack(self.headerFormat, messageLen)\n msgType = pack(self.messageTypeFormat, self.messageType)\n payload = bytes(self._messageBuf)\n return header + msgType + payload","def spoof_packet(packet):"],"string":"[\n \"def packetize(self):\\n byte_str = b''\\n\\n # Bit string to accumulate bit values until we are ready to convert it into bytes\\n bit_str = \\\"\\\"\\n\\n for field in self.fields:\\n #if the current field is a special type, the bit_str value to the byte string and clear the accumulated bit_str.\\n if not isinstance(field.size, int) and len(bit_str) != 0:\\n byte_str += self.encode_bit_str(bit_str)\\n bit_str = \\\"\\\"\\n if field.size == NULL_TERMINATE:\\n byte_str += self.encode_null_term(field.value)\\n elif field.size == PREFIX_LENGTH:\\n byte_str += self.encode_prefix_length(field.value)\\n elif field.size == PREFIX_LEN_NULL_TERM:\\n byte_str += self.encode_prefix_length_null_term(field.value)\\n elif field.size == IPv4:\\n byte_str += self.encode_ipv4(field.value)\\n elif field.size == 1: # One bit, just add it to our bit string.\\n bit_str += \\\"0\\\" if field.value == 0 else \\\"1\\\"\\n else:\\n if isinstance(field.value, int):\\n bit_str += \\\"0\\\" * (field.size - len(bin(field.value)[2:])) + bin(field.value)[2:]\\n elif isinstance(field.value, bytes):\\n bit_str += field.value.decode('latin-1')\\n #clear the bit string one last time\\n if len(bit_str) != 0:\\n byte_str += self.encode_bit_str(bit_str)\\n bit_str = \\\"\\\"\\n\\n return byte_str\",\n \"def encode_packet(self, packet):\\n\\n\\t\\ttry:\\n\\t\\t\\toutput = self.pack('ubyte', packet.ident)\\n\\t\\t\\tappend = ''\\n\\t\\t\\t#0x17\\n\\t\\t\\tif packet.ident == 0x17:\\n\\t\\t\\t\\tif packet.data['unknown'] > 0:\\n\\t\\t\\t\\t\\tfor i in ('x2','y2','z2'):\\n\\t\\t\\t\\t\\t\\tappend += self.pack('short', packet.data[i])\\n\\t\\t\\t#0x33\\n\\t\\t\\tif packet.ident in (0x33, 0x34):\\n\\t\\t\\t\\tpacket.data['data_size'] = len(packet.data['data'])\\n\\t\\t\\t\\tappend += self.pack_array_fast('byte', packet.data['data'])\\n\\t\\t\\t\\n#\\t\\t\\t#0x34\\n#\\t\\t\\tif packet.ident == 0x34:\\n#\\t\\t\\t\\tcoords = []\\n#\\t\\t\\t\\tbtypes = []\\n#\\t\\t\\t\\tmetadata = []\\n#\\t\\t\\t\\tfor i in packet.data['blocks']:\\n#\\t\\t\\t\\t\\tcoords.append(i['x'] << 12 | i['z'] << 8 | i['y'])\\n#\\t\\t\\t\\t\\tbtypes.append(i['type'])\\n#\\t\\t\\t\\t\\tmetadata.append(i['metadata'])\\n#\\t\\t\\t\\t\\n#\\t\\t\\t\\tpacket.data['data_size'] = len(coords)\\n#\\t\\t\\t\\tappend += self.pack_array_fast('short', coords)\\n#\\t\\t\\t\\tappend += self.pack_array_fast('byte', btypes)\\n#\\t\\t\\t\\tappend += self.pack_array_fast('byte', metadata)\\n\\t\\t\\t\\n\\t\\t\\t#0x3C\\n\\t\\t\\tif packet.ident == 0x3C:\\n\\t\\t\\t\\tarray = []\\n\\t\\t\\t\\tfor i in packet.data['blocks']:\\n\\t\\t\\t\\t\\tarray += [i['x'], i['y'], i['z']]\\n\\t\\t\\t\\tpacket.data['data_size'] = len(packet.data['blocks'])\\n\\t\\t\\t\\tappend += self.pack_array_fast('byte', array)\\n\\t\\t\\t\\n\\t\\t\\t#0x68\\n\\t\\t\\tif packet.ident == 0x68:\\n\\t\\t\\t\\tpacket.data['data_size'] = len(packet.data['slots_data'])\\n\\t\\t\\t\\tappend += self.pack_array('slot', packet.data['slots_data'])\\n\\t\\t\\t#0x82: Sign\\n\\t\\t\\tif packet.ident == 0x82:\\n\\t\\t\\t\\tfor i in range(4):\\n\\t\\t\\t\\t\\tpacket.data[\\\"line_%s\\\" % (i+1)] = packet.data[\\\"text\\\"][i]\\n\\t\\t\\t#0x83\\n\\t\\t\\tif packet.ident == 0x83:\\n\\t\\t\\t\\tpacket.data['data_size'] = len(packet.data['data'])\\n\\t\\t\\t\\tappend += self.pack_array_fast('byte', packet.data['data'])\\n\\t\\t\\n\\t\\t\\tfor i in self.get_struct(packet):\\n\\t\\t\\t\\toutput += self.pack(i[0], packet.data[i[1]])\\n\\t\\t\\t\\n\\t\\t\\toutput += append\\n\\t\\t\\treturn output\\n\\t\\texcept Exception:\\n\\t\\t\\traise\",\n \"def _pack(self) -> bytes:\\n return struct.pack(self.PACKAGING_FORMAT, self.type, self.length)\",\n \"def obj2bytes(obj: StunPacket) -> bytes:\\n\\n message = bytes()\\n for [attribute_type, attribute_val] in obj.message.items():\\n message += pack(\\n '{}{}s'.format(ATTRIBUTE_HEADER_FORMAT, len(attribute_val)),\\n attribute_type,\\n len(attribute_val),\\n attribute_val,\\n )\\n\\n type_bits = (\\n '00'\\n + obj.type_method[0:5]\\n + obj.type_class[0]\\n + obj.type_method[5:8]\\n + obj.type_class[1]\\n + obj.type_method[8:]\\n )\\n return pack(\\n '{}{}s'.format(HEADER_FORMAT, len(message)),\\n int(type_bits, 2),\\n len(message),\\n obj.magic_cookie,\\n obj.transaction_id,\\n message,\\n )\",\n \"def bytes(self):\\n return bytes(self._packet)\",\n \"def pack(self):\\n \\n data = \\\"\\\".join(map(lambda arg: arg.pack(), self))\\n data = struct.pack(\\\">2H\\\", self.type, len(data)) + data\\n \\n return data\",\n \"def make_packet(self, type, data): \\n return (\\\"{}\\\\x00{}\\\\x00{}\\\".format(type, data, self.ID)).encode()\",\n \"def _marshal(self, pieces):\\n payload = b''.join(pieces)\\n return struct.pack('>BHI', self.frame_type, self.channel_number,\\n len(payload)) + payload + bytes((spec.FRAME_END,))\",\n \"def encode_packet(self, packet, b64=False):\\n if packet.binary and not b64:\\n bytes = six.int2byte(packet.type)\\n else:\\n bytes = six.binary_type(packet.type)\\n if packet.binary and b64:\\n bytes = 'b' + bytes\\n\\n if packet.binary and b64:\\n bytes += base64.b64encode(packet.data).decode('utf-8')\\n else:\\n bytes += six.binary_type(packet.data)\\n\\n return bytes\",\n \"def encode(self):\\n return (struct.pack(b\\\"<iii\\\", self.size, self.id, self.type) +\\n self.body.encode(\\\"ascii\\\") + b\\\"\\\\x00\\\\x00\\\")\",\n \"def __bytes__(self):\\n # Mac address case\\n if self.subtype == 3:\\n return bytes([self.type * 2, 1 + 6, self.subtype]) + self.value\\n # ip address case\\n elif self.subtype == 4:\\n if self.value.version == 4:\\n # ipv4 case\\n return bytes([self.type * 2, 1 + 5, self.subtype ,1]) + self.value.packed\\n else:\\n # ipv6 case\\n return bytes([self.type * 2, 1 + 17, self.subtype, 2]) + self.value.packed\\n\\n #all other cases:\\n else:\\n if len(self.value) > 255:\\n return bytes([(self.type * 2) + 1, len(self.value) - 256, self.subtype]) + bytes(self.value, 'utf-8')\\n else:\\n return bytes([self.type * 2, len(self.value) + 1, self.subtype]) + bytes(self.value,'utf-8')\",\n \"def to_buffer(self) -> bytearray:\\n packet = bytearray()\\n packet.extend(\\n struct.pack(\\n \\\"!ccccHH\\\",\\n \\\"D\\\".encode(\\\"ascii\\\"),\\n \\\"L\\\".encode(\\\"ascii\\\"),\\n \\\"E\\\".encode(\\\"ascii\\\"),\\n \\\"P\\\".encode(\\\"ascii\\\"),\\n int(self.type),\\n self.len,\\n )\\n )\\n return packet\",\n \"def packet(self):\\n return self.server.packet(context=self.ctx)\",\n \"def _finalize_packet(self, rudp_packet):\\n return rudp_packet.to_bytes()\",\n \"def getBinary(self):\\n address = OSCArgument(self.address)[1]\\n typetags = OSCArgument(self.typetags)[1]\\n return address + typetags + self.message\",\n \"def pack(self):\\n return self._STRUCT.pack(\\n self._SYNC, self.sequence_number, self.packet_id, self.data_length,\\n self.p1, self.p2, self.p3, self.p4, self.p5\\n ) + (\\n pack('%ss' % len(self.data), self.data)\\n )\",\n \"def _pack(self) -> bytes:\\n\\n return struct.pack(\\n self.PACKAGING_FORMAT, \\n self.first_operand, \\n self.operator, \\n self.type_of_second_operand, \\n self.second_operand, \\n self.length\\n )\",\n \"def encode(self):\\r\\n data = ''\\r\\n if self.id == PUSH_ACK:\\r\\n data = pack('<BHB', self.version, self.token, self.id)\\r\\n elif self.id == PULL_ACK:\\r\\n data = pack('<BHB', self.version, self.token, self.id)\\r\\n elif self.id == PULL_RESP:\\r\\n if self.version == 1:\\r\\n self.token = 0\\r\\n self.payload = self.txpk.encode()\\r\\n print(str(self.payload))\\r\\n data = pack('<BHB', self.version, self.token, self.id) + \\\\\\r\\n bytearray(self.payload,'utf-8')\\r\\n return data\",\n \"def _pack(self) -> bytes:\\n\\n return struct.pack(self.PACKAGING_FORMAT, self.ref_id)\",\n \"def __bytes__(self):\\n return (\\n bytes(self.block_header) +\\n pack_compact_int(len(self.txns)) +\\n b''.join([bytes(t) for t in self.txns])\\n )\",\n \"def _to_bytes(self, item):\\n data = bytes(type(item).write_to_string(item)) if isinstance(item, Struct) else \\\\\\n bytes(item.pack()) if isinstance(item, Buffer) else \\\\\\n '' if item is None else bytes(item)\\n return data\",\n \"def __str__(self):\\n return '\\\\n%(source)s > %(type)s (0x%(type_d).2x)\\\\n%(data)s' % \\\\\\n {'type': DGTL.pkt_type_str[self.type], 'type_d': self.type,\\n 'data': str(self.decoded) if self.decoded else 'Unknown raw data.',\\n 'source': self.source}\",\n \"def build_packets(self):\\n from scapy.all import IP, TCP\\n return IP()/TCP()\",\n \"def encode(self) -> bytes:\\n\\n # unsigned char dmac[6];\\n # unsigned char smac[6];\\n # uint16_t ethertype;\\n # unsigned char payload[];\\n\\n t = struct.pack(\\\"H\\\", socket.htons(self.typ))\\n return self.dmac + self.smac + t + self.payload\",\n \"def read_packet(self):\\n\\n\\t\\t#self.debug(\\\"READ BUFFER SIZE: %d\\\" % len(self.buff))\\n\\t\\tbackup = self.buff[:]\\n\\t\\tpacket = Packet()\\n\\t\\ttry:\\n\\t\\t\\tpacket.direction = self.node\\n\\t\\t\\tpacket.ident = self.unpack('ubyte')\\n\\t\\t\\t\\n\\t\\t\\t#Defined structs from huge dict\\n\\t\\t\\tfor datatype, name in self.get_struct(packet):\\n\\t\\t\\t\\t# this populates packet.data with {name: value}\\n\\t\\t\\t\\tpacket.data[name] = self.unpack(datatype)\\n\\n\\t\\t\\t# I believe the following are packet-type specific fixes for variable-length packets.\\n\\n\\t\\t\\t#0x17\\n\\t\\t\\tif packet.ident == 0x17:\\n\\t\\t\\t\\tif packet.data['unknown'] > 0:\\n\\t\\t\\t\\t\\tpacket.data['x2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['y2'] = self.unpack('short')\\n\\t\\t\\t\\t\\tpacket.data['z2'] = self.unpack('short')\\n\\t\\t\\n\\t\\t\\t#0x33\\n\\t\\t\\tif packet.ident in (0x33, 0x34):\\n\\t\\t\\t\\tpacket.data['data'] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n#\\t\\t\\t#0x34\\n#\\t\\t\\tif packet.ident == 0x34:\\n#\\t\\t\\t\\tcoords = self.unpack_array_fast('short', packet.data['data_size'])\\n#\\t\\t\\t\\tbtype = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tmetadata = self.unpack_array_fast('byte', packet.data['data_size'])\\n#\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n#\\t\\t\\t\\tfor i in zip(coords, btype, metadata):\\n#\\t\\t\\t\\t\\tblock = {}\\n#\\t\\t\\t\\t\\tblock[\\\"x\\\"] =\\t\\ti[0] >> 12\\n#\\t\\t\\t\\t\\tblock[\\\"z\\\"] = 0x0F & i[0] >> 8\\n#\\t\\t\\t\\t\\tblock[\\\"y\\\"] = 0xFF & i[0]\\n#\\t\\t\\t\\t\\tblock[\\\"type\\\"] = i[1]\\n#\\t\\t\\t\\t\\tblock[\\\"metadata\\\"] = i[2]\\n#\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(block)\\n#\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x3C\\n\\t\\t\\tif packet.ident == 0x3C:\\n\\t\\t\\t\\trecords = self.unpack_array_fast('byte', packet.data['data_size']*3)\\n\\t\\t\\t\\ti = 0\\n\\t\\t\\t\\tpacket.data[\\\"blocks\\\"] = []\\n\\t\\t\\t\\twhile i < packet.data['data_size']*3:\\n\\t\\t\\t\\t\\tpacket.data[\\\"blocks\\\"].append(dict(zip(('x','y','z'), records[i:i+3])))\\n\\t\\t\\t\\t\\ti+=3\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\n\\t\\t\\t#0x68\\n\\t\\t\\tif packet.ident == 0x68:\\n\\t\\t\\t\\tpacket.data[\\\"slots_data\\\"] = self.unpack_array('slot', packet.data[\\\"data_size\\\"])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\t\\t\\t#0x82:\\n\\t\\t\\tif packet.ident == 0x82:\\n\\t\\t\\t\\tpacket.data[\\\"text\\\"] = []\\n\\t\\t\\t\\tfor i in range(4):\\n\\t\\t\\t\\t\\tpacket.data[\\\"text\\\"].append(packet.data[\\\"line_%s\\\" % (i+1)])\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t#0x83\\n\\t\\t\\tif packet.ident == 0x83:\\n\\t\\t\\t\\tpacket.data[\\\"data\\\"] = self.unpack_array_fast('byte', packet.data['data_size'])\\n\\t\\t\\t\\tdel packet.data[\\\"data_size\\\"]\\n\\n\\t\\t\\t# Sets packet.original to the byte string that the packet was decoded from.\\n\\t\\t\\tpacket.original = backup[:len(backup) - len(self.buff)]\\n\\n\\t\\t\\treturn packet\\n\\n\\t\\texcept IncompleteData:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\treturn None\\n\\t\\texcept Exception, ex:\\n\\t\\t\\tself.buff = backup\\n\\t\\t\\tex.args += (self.buff[20:],)\\n\\t\\t\\traise\",\n \"def encode(self) -> bytes:\\n return pack('<B' + self.fmt, *([self.type] + self.__args))\",\n \"def encode(self):\\n packed = struct.pack(\\\"<2Bl\\\",\\n self.device_number,\\n self.command_number,\\n self.data)\\n if self.message_id is not None:\\n packed = packed[:5] + struct.pack(\\\"B\\\", self.message_id)\\n return packed\",\n \"def encode_payload(self, packets, b64=False):\\n bytes = b''\\n for packet in packets:\\n packet_bytes = self.encode_packet(packet, b64)\\n packet_len = len(packet_bytes)\\n if b64:\\n bytes += str(packet_len) + b':' + packet_bytes\\n else:\\n binary_len = b''\\n while packet_len != 0:\\n binary_len = six.int2byte(packet_len % 10) + binary_len\\n packet_len = int(packet_len / 10)\\n bytes += b'\\\\x01' if packet.binary else b'\\\\x00'\\n bytes += binary_len + b'\\\\xff' + packet_bytes\\n\\n return bytes\",\n \"def _pack(self):\\n pass\",\n \"def __bytes__(self):\\n return pack(\\\"<HH\\\", self._packet_len, self._control_ctr)\",\n \"def dump(self) : \\n mybuffer = []\\n if None not in (self.version, self.operation_id) :\\n mybuffer.append(chr(self.version[0]) + chr(self.version[1]))\\n mybuffer.append(pack(\\\">H\\\", self.operation_id))\\n mybuffer.append(pack(\\\">I\\\", self.request_id or 1))\\n for attrtype in self.attributes_types :\\n for attribute in getattr(self, \\\"_%s_attributes\\\" % attrtype) :\\n if attribute :\\n mybuffer.append(chr(self.tagvalues[\\\"%s-attributes-tag\\\" % attrtype]))\\n for (attrname, value) in attribute :\\n nameprinted = 0\\n for (vtype, val) in value :\\n mybuffer.append(chr(self.tagvalues[vtype]))\\n if not nameprinted :\\n mybuffer.append(pack(\\\">H\\\", len(attrname)))\\n mybuffer.append(attrname)\\n nameprinted = 1\\n else :\\n mybuffer.append(pack(\\\">H\\\", 0))\\n if vtype in (\\\"integer\\\", \\\"enum\\\") :\\n mybuffer.append(pack(\\\">H\\\", 4))\\n mybuffer.append(pack(\\\">I\\\", val))\\n elif vtype == \\\"boolean\\\" :\\n mybuffer.append(pack(\\\">H\\\", 1))\\n mybuffer.append(chr(val))\\n else :\\n mybuffer.append(pack(\\\">H\\\", len(val)))\\n mybuffer.append(val)\\n mybuffer.append(chr(self.tagvalues[\\\"end-of-attributes-tag\\\"]))\\n mybuffer.append(self.data)\\n return \\\"\\\".join(mybuffer)\",\n \"def _create_packet(self, request):\\n\\n data_len = struct.pack('<Q', len(request))\\n packet = b'ZBXD\\\\x01' + data_len + request\\n\\n def ord23(x):\\n if not isinstance(x, int):\\n return ord(x)\\n else:\\n return x\\n\\n logger.debug('Packet [str]: %s', packet)\\n logger.debug('Packet [hex]: %s', ':'.join(hex(ord23(x))[2:] for x in packet))\\n return packet\",\n \"def serialize_str(self, obj):\\n if len(obj) < 0x100:\\n return 'U' + struct.pack('<B', len(obj)) + obj\\n return 'T' + struct.pack('<I', len(obj)) + obj\",\n \"def _pack(self):\\n to_pack = {\\n \\\"remote_ip\\\": self.remote_ip,\\n \\\"remote_port\\\": self.remote_port,\\n \\\"min_fidelity\\\": self.min_fidelity,\\n \\\"max_time\\\": self.max_time,\\n \\\"num_pairs\\\": self.num_pairs,\\n \\\"priority\\\": self.priority,\\n \\\"store\\\": self.store,\\n \\\"atomic\\\": self.atomic,\\n \\\"measure_directly\\\": self.measure_directly,\\n }\\n request_Bitstring = bitstring.pack(self.PACKAGING_FORMAT, **to_pack)\\n requestH = request_Bitstring.tobytes()\\n\\n return requestH\",\n \"def __bytes__(self):\\n return self.header_bytes() + self.payload\",\n \"def serialize(self, buff):\\n try:\\n _x = self.name\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.compatibility\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.display_name\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.description\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.namespace\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.icon.resource_name\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.icon.format\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.icon.data\\n length = len(_x)\\n # - if encoded as a list instead, serialize as bytes instead of string\\n if type(_x) in [list, tuple]:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n length = len(self.remappings)\\n buff.write(_struct_I.pack(length))\\n for val1 in self.remappings:\\n _x = val1.remap_from\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = val1.remap_to\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self.parameters\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n buff.write(_struct_i.pack(self.max))\\n _x = self.pairing.rapp\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n length = len(self.pairing.remappings)\\n buff.write(_struct_I.pack(length))\\n for val1 in self.pairing.remappings:\\n _x = val1.remap_from\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = val1.remap_to\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n length = len(self.pairing.parameters)\\n buff.write(_struct_I.pack(length))\\n for val1 in self.pairing.parameters:\\n _x = val1.key\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = val1.value\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n buff.write(_struct_i.pack(self.hash))\\n _x = self.role\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n except struct.error as se: self._check_types(struct.error(\\\"%s: '%s' when writing '%s'\\\" % (type(se), str(se), str(locals().get('_x', self)))))\\n except TypeError as te: self._check_types(ValueError(\\\"%s: '%s' when writing '%s'\\\" % (type(te), str(te), str(locals().get('_x', self)))))\",\n \"def __bytes__(self):\\n prm = self.package(self.p, LEN_PRIME)\\n gen = self.package(self.g, LEN_GEN)\\n pbk = self.package(self.pk, LEN_PK)\\n return prm + gen + pbk\",\n \"def encode(self) -> bytes:\\n version_ihl = self._version << 4 | self._ihl\\n flags_fragoffset = self._flags << 13 | self._frag_offset\\n\\n raw = struct.pack(\\n IPHeader.fmt,\\n version_ihl,\\n self._tos,\\n self.len,\\n self.id,\\n flags_fragoffset,\\n self._ttl,\\n self.proto,\\n self._csum,\\n self.saddr,\\n self.daddr,\\n )\\n return raw + self.payload\",\n \"def _pack_data( self, data ) : \\r\\n \\r\\n # hints = self._translation_table.get( type(data), None )\\r\\n hints = self._get_hints( data ) \\r\\n \\r\\n if hints is None : \\r\\n \\r\\n ## #debug: \\r\\n ## print \\\"_pack_data(): no hints for data type %s (data repr: %s)\\\" % (type(data), repr(data))\\r\\n \\r\\n # \\\"one-level recursion\\\" : \\r\\n # return self._pack_data( repr(data) )\\r\\n return self._pack_data( str(data) )\\r\\n \\r\\n ## # our special case ( grep 'bugfix' to see why we want a zero block ) \\r\\n ## if data is None: data = 0\\r\\n \\r\\n # else ... \\r\\n \\r\\n # 'DescType' + 'length' + 'data'\\r\\n desctype = hints[0]\\r\\n if desctype == 'TEXT' : \\r\\n length = len(data)\\r\\n data_str = data \\r\\n else :\\r\\n length = struct.calcsize( hints[1] )\\r\\n data_str = struct.pack( hints[1], data )\\r\\n \\r\\n length_str = struct.pack('=H', length)\\r\\n \\r\\n \\r\\n return _cat(desctype, length_str, data_str)\",\n \"def serialize(self, buff):\\n try:\\n _x = self\\n buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))\\n _x = self.header.frame_id\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self\\n buff.write(_struct_3I.pack(_x.pan.header.seq, _x.pan.header.stamp.secs, _x.pan.header.stamp.nsecs))\\n _x = self.pan.header.frame_id\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self\\n buff.write(_struct_6f3df3I.pack(_x.pan.current, _x.pan.pos_rad, _x.pan.vel_rps, _x.pan.torque_nm, _x.pan.pwm, _x.pan.encoder_rad, _x.pan.accel.x, _x.pan.accel.y, _x.pan.accel.z, _x.pan.temperature_degC, _x.tilt.header.seq, _x.tilt.header.stamp.secs, _x.tilt.header.stamp.nsecs))\\n _x = self.tilt.header.frame_id\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n _x = self\\n buff.write(_struct_6f3df.pack(_x.tilt.current, _x.tilt.pos_rad, _x.tilt.vel_rps, _x.tilt.torque_nm, _x.tilt.pwm, _x.tilt.encoder_rad, _x.tilt.accel.x, _x.tilt.accel.y, _x.tilt.accel.z, _x.tilt.temperature_degC))\\n except struct.error as se: self._check_types(struct.error(\\\"%s: '%s' when writing '%s'\\\" % (type(se), str(se), str(locals().get('_x', self)))))\\n except TypeError as te: self._check_types(ValueError(\\\"%s: '%s' when writing '%s'\\\" % (type(te), str(te), str(locals().get('_x', self)))))\",\n \"def create_message(self, packet):\\n self._header.packet_len = len(bytes(packet))\\n \\n frame_bytes = super(EthernetTransport, self).create_message(packet) \\n \\n # Update control counter for next frame\\n self._header.update_control()\\n \\n return bytes(frame_bytes)\",\n \"def bytes2obj(buf: bytes) -> StunPacket:\\n\\n type_raw, length, magic_cookie, transaction_id = unpack_from(\\n HEADER_FORMAT, buf, 0)\\n\\n # Convert message type into bits, to parse it as a class and method.\\n type_bits: str = bin(type_raw)[2:].zfill(16)\\n if type_bits[:2] != \\\"00\\\":\\n raise Exception(\\n \\\"STUN packet invalid - most signifigant 2 bits must be zeroes.\\\")\\n type_class = type_bits[7] + type_bits[11]\\n type_method = type_bits[2:7] + type_bits[8:11] + type_bits[12:]\\n\\n message_bytes = unpack_from('!{}s'.format(\\n length), buf, calcsize(HEADER_FORMAT))[0]\\n # if magic_cookie != bytes.fromhex(\\\"2112A442\\\"):\\n # print(\\\"Warning: Request not RFC 8489 compilant.\\\")\\n\\n message_read = 0\\n message: Dict[bytes, bytes] = {}\\n while message_read < length:\\n attribute_type, attribute_length = unpack_from(\\n ATTRIBUTE_HEADER_FORMAT, message_bytes, message_read\\n )\\n attribute_val = unpack_from(\\n \\\"!{}s\\\".format(attribute_length), message_bytes, message_read +\\n calcsize(ATTRIBUTE_HEADER_FORMAT)\\n )[0]\\n message[attribute_type] = attribute_val\\n\\n message_read += calcsize(ATTRIBUTE_HEADER_FORMAT)\\n message_read += attribute_length\\n\\n return StunPacket(type_class, type_method, magic_cookie, transaction_id, message)\",\n \"def __str__(self):\\n return bytes_to_string(self._bytes)\",\n \"def __bytes__(self) -> bytes:\\n from hathor.merged_mining.bitcoin import encode_bytearray, encode_list\\n struct_bytes = self.header_head\\n struct_bytes += encode_bytearray(self.coinbase_head)\\n struct_bytes += encode_bytearray(self.coinbase_tail)\\n struct_bytes += encode_list(self.merkle_path)\\n struct_bytes += self.header_tail\\n return struct_bytes\",\n \"def to_bytes(self, **kwargs: Any) -> bytes:\\n serial = OrderedDict(\\n (\\n (\\\"spaczz_overwrite\\\", self.overwrite),\\n (\\\"spaczz_ent_id_sep\\\", self.ent_id_sep),\\n (\\\"spaczz_patterns\\\", self.patterns),\\n (\\\"spaczz_defaults\\\", self.defaults),\\n )\\n )\\n return srsly.msgpack_dumps(serial)\",\n \"def read_raw_packet(self):\\n\\n size = 0\\n\\n # Read our two-byte header from the debugger...\\n while not size:\\n size = (self._get_next_byte() << 16) | self._get_next_byte()\\n\\n # ... and read our packet.\\n packet = bytearray([self._get_next_byte() for _ in range(size)])\\n\\n # Return our packet.\\n # TODO: extract and provide status flags\\n # TODO: generate a timestamp on-device\\n return packet, datetime.now(), None\",\n \"def pack(self):\\n\\n msg = struct.pack(SentmanRequest.FORMAT,\\n self.version, self.op_type, self.msg_len)\\n return msg\",\n \"def str(self):\\n return struct.pack(\\n '!IIIIIIIIIII',\\n self.magic,\\n self.totalsize,\\n self.off_dt_struct,\\n self.off_dt_strings,\\n self.off_mem_rsvmap,\\n self.version,\\n self.last_comp_version,\\n self.size_dt_strings,\\n self.size_dt_struct\\n )\",\n \"def serialize(self):\\n\\n # The len must be multiple of 4 bits to convert unambiguously\\n\\n id_len = self.id.bit_length()\\n while (id_len % 4)!= 0:\\n id_len += 1\\n if self.payload:\\n pay_len = self.payload.bit_length()\\n while (pay_len % 4)!= 0:\\n pay_len += 1\\n else: pay_len = 0\\n if self.command:\\n com_len = self.command.bit_length()\\n while (com_len % 4)!= 0:\\n com_len += 1\\n else: com_len = 0\\n\\n values = {\\n \\\"id\\\": self.id,\\n \\\"id_len\\\": id_len,\\n \\\"payload\\\": self.payload,\\n \\\"payload_len\\\": pay_len,\\n \\\"command\\\": self.command,\\n \\\"command_len\\\": com_len\\n }\\n\\n\\n if self.id == Message.MEASURE or self.id == Message.SINGLE_MEASURE:\\n serial_format = (\\n \\\"uint:id_len=id, bits:payload_len=payload, bits:command_len = command, 0x0D0A\\\"\\n )\\n else:\\n serial_format = (\\n \\\"0x23, uint:id_len=id, bits:payload_len=payload, bits:command_len = command, 0x0D0A\\\"\\n )\\n\\n message = bitstring.pack(serial_format, **values)\\n\\n rospy.logdebug(\\\"Sent command '0x%s'\\\", message.hex)\\n\\n return message.tobytes()\",\n \"def string_raw(self):\\n return \\\"x%x\\\" % self.encoded\",\n \"def marshal(self):\\n return b'AMQP' + struct.pack('BBBB', 0, self.major, self.minor,\\n self.revision)\",\n \"def __bytes__(self):\\n if self._header.value_type in b'ZH':\\n value = self._buffer[:-1] # Omit the trailing Null\\n elif self._header.value_type in b'AB':\\n value = self._buffer\\n else:\\n value = str(self._buffer.value).encode('ASCII')\\n return self._header.tag + b':' + (self._header.value_type if self._header.value_type in b'AifZHB' else b'i') + b':' + value\",\n \"def tobytes(self):\\n\\n self.meta.msg_id = self.body.__msg_id__\\n self.meta.msg_class = self.body.__msg_class__\\n offset = HEADER_STRUCT_SIZE\\n if (\\n isinstance(self.body, Modern)\\n and not self.body.binary is None\\n and self.meta.msg_class in (MSG_CLASS_MODERN_BINARY, MSG_CLASS_MODERN_OTHER)\\n ):\\n offset += 4\\n buffer = bytearray()\\n (body_len, bin_offset) = self.body.__pack_into__(self.meta, buffer, offset)\\n self.meta.__pack_into__(buffer, body_len, bin_offset)\\n return bytes(buffer)\",\n \"def to_bytes(self, ???):\",\n \"def _pack(self):\\n header = struct.pack(self.PACKAGING_FORMAT, self.cmd_length)\\n return header\",\n \"def from_network_layer(buffer):\\r\\n packet = buffer.get_packet()\\r\\n # print(f'buffer.message:{buffer.message}')\\r\\n # if packet == None:\\r\\n # print(f\\\"[from_network_layer] packet:NULL\\\")\\r\\n print(f\\\"[from_network_layer] packet:{packet}\\\")\\r\\n return packet\",\n \"def encode(self):\\n b = 0 | self.mtype << 5 | self.major\\n data = struct.pack('B', b)\\n return data\",\n \"def to_bytes(self) -> bytes:\",\n \"def dump_payload(self, obj):\\n return want_bytes(self.serializer.dumps(obj, **self.serializer_kwargs))\",\n \"def as_packet(self, ptype):\\n return ctypes.cast(self.ptr, ctypes.POINTER(ptype))[0]\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def to_bytes(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def dump(self):\\n avps = self.get_all_avps_contents()\\n auth = self.compute_authenticator(avps)\\n header = struct.pack(RadiusMessage.RADIUS_HDR_TMPL, self.code,\\n self.pid, len(self), auth)\\n return b\\\"\\\".join([header, avps])\",\n \"def __init__(self, bytes = None):\\n version = pcs.Field(\\\"version\\\", 4, default = 4)\\n hlen = pcs.Field(\\\"hlen\\\", 4)\\n tos = pcs.Field(\\\"tos\\\", 8)\\n length = pcs.Field(\\\"length\\\", 16)\\n id = pcs.Field(\\\"id\\\", 16)\\n flags = pcs.Field(\\\"flags\\\", 3)\\n offset = pcs.Field(\\\"offset\\\", 13)\\n ttl = pcs.Field(\\\"ttl\\\", 8, default = 64)\\n protocol = pcs.Field(\\\"protocol\\\", 8)\\n checksum = pcs.Field(\\\"checksum\\\", 16)\\n src = pcs.Field(\\\"src\\\", 32)\\n dst = pcs.Field(\\\"dst\\\", 32)\\n pcs.Packet.__init__(self,\\n [version, hlen, tos, length, id, flags, offset,\\n ttl, protocol, checksum, src, dst],\\n bytes = bytes)\\n # Description MUST be set after the PCS layer init\\n self.description = \\\"IPv4\\\"\\n\\n\\n if (bytes != None):\\n offset = self.hlen << 2\\n self.data = self.next(bytes[offset:len(bytes)])\\n else:\\n self.data = None\",\n \"def make_binary_protocol(*, \\n encode_function: Callable, \\n decode_function: Callable, \\n byteEncodingString: str, # struct pattern for the header\\n infoBytes: int # amount of bytes to read off (must match the struct pattern)\\n ) -> _SocketProtocol:\\n\\n def send_message(sock: socket, packet: StrictPacket):\\n serialised = encode_function(packet)\\n bytes_ = struct.pack(byteEncodingString, len(serialised)) + serialised\\n sock.send(bytes_)\\n\\n def recv_message(sock: socket) -> Packet:\\n lengthRaw = sock.recv(infoBytes)\\n try:\\n length = struct.unpack(byteEncodingString, lengthRaw)[0]\\n except struct.error:\\n return None\\n raw = sock.recv(length)\\n try:\\n return decode_function(raw)\\n except PacketMalformedError:\\n return None\\n\\n return _SocketProtocol(send_message, recv_message)\",\n \"def __bytes__(self):\\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')\",\n \"def __bytes__(self):\\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')\",\n \"def __bytes__(self):\\n return bytes([self.type * 2, len(self.value)]) + bytes(self.value, 'utf-8')\",\n \"def object_to_bytes(obj):\\n if isinstance(obj, str):\\n return bytearray(obj, \\\"UTF-8\\\")\\n elif isinstance(obj, bool):\\n return bytearray()\\n elif isinstance(obj, int):\\n return pack(\\\"<L\\\", obj)\\n elif obj == None:\\n return bytearray()\\n elif isinstance(obj, bytearray):\\n return obj\\n else:\\n #print type(obj), obj\\n return obj.get_raw()\",\n \"def pack(self):\\n if self.originalOriginate is None:\\n os, on = divmod(self.originateNanos,1000000000)\\n else:\\n os, on = self.originalOriginate\\n rs, rn = divmod(self.receiveNanos, 1000000000)\\n ts, tn = divmod(self.transmitNanos, 1000000000)\\n msg = struct.pack(WCMessage.STRUCT_FMT, 0, self.msgtype, self.precision, 0, self.maxFreqError, os, on, rs, rn, ts, tn) \\n return msg\",\n \"def serialize(self, buff):\\n try:\\n _x = self\\n buff.write(_struct_2d2q14dq.pack(_x.tcp, _x.ori, _x.zone, _x.vacuum, _x.workx, _x.worky, _x.workz, _x.workq0, _x.workqx, _x.workqy, _x.workqz, _x.toolx, _x.tooly, _x.toolz, _x.toolq0, _x.toolqx, _x.toolqy, _x.toolqz, _x.ret))\\n _x = self.msg\\n length = len(_x)\\n if python3 or type(_x) == unicode:\\n _x = _x.encode('utf-8')\\n length = len(_x)\\n if python3:\\n buff.write(struct.pack('<I%sB'%length, length, *_x))\\n else:\\n buff.write(struct.pack('<I%ss'%length, length, _x))\\n except struct.error as se: self._check_types(struct.error(\\\"%s: '%s' when writing '%s'\\\" % (type(se), str(se), str(locals().get('_x', self)))))\\n except TypeError as te: self._check_types(ValueError(\\\"%s: '%s' when writing '%s'\\\" % (type(te), str(te), str(locals().get('_x', self)))))\",\n \"def to_bytes(self) -> bytes:\\n return pack('4B', self.tag, self.flags, self.reserved, self.params_count)\",\n \"def package(payload):\\n return salt.utils.msgpack.dumps(payload)\",\n \"def payload_from_raw(raw, linktype=1):\\n ip = iplayer_from_raw(raw, linktype)\\n try: return ip.data.data\\n except:\\n return \\\"\\\"\",\n \"def packetize(cls, source, raw_data):\\n pkt = cls(source, raw_data)\\n\\n if pkt.type not in DGTL.descriptors.keys():\\n raise Warning('Unsupported packet type! (%s)' % pkt.type)\\n\\n pkt.set_decoder(DGTL.descriptors[pkt.type][2])\\n\\n return pkt\",\n \"def _packet_string(self):\\n return 'Packet (Length: %s)%s' % (self.length, os.linesep)\",\n \"def get_binary(self):\\n data = bytes()\\n\\n for tag in self._tags:\\n value = 0\\n if tag in self.fields.keys():\\n value = self.fields[tag]\\n try:\\n data += struct.pack(\\\"<I\\\", value)\\n except struct.error as e:\\n raise TypeError(f\\\"expected integer value for {tag} but got {type(value)}: {value}\\\")\\n\\n return data\",\n \"def __str__(self):\\n return bytes_to_str(bytes(self))\",\n \"def encode(self):\\n data = struct.pack('BBB', self.cid, self.margin, self.gwcnt)\\n return data\",\n \"def __init__(self, bytes = None, timestamp = None):\\n from socket import IPPROTO_TCP\\n src = pcs.Field(\\\"src\\\", 32)\\n dst = pcs.Field(\\\"dst\\\", 32)\\n reserved = pcs.Field(\\\"reserved\\\", 8, default = 0)\\n protocol = pcs.Field(\\\"protocol\\\", 8, default = IPPROTO_TCP)\\n length = pcs.Field(\\\"length\\\", 16)\\n pcs.Packet.__init__(self, [src, dst, reserved, protocol, length],\\n bytes = bytes)\\n # Description MUST be set after the PCS layer init\\n self.description = inspect.getdoc(self)\\n if timestamp == None:\\n self.timestamp = time.time()\\n else:\\n self.timestamp = timestamp\\n\\n self.data = None\",\n \"def pack(self, *args):\\n return self._msg_struct.pack(self.message_id, *args)\",\n \"def pack(self):\\r\\n return pack('!BBHHBBBHBBHBBB',\\r\\n 17, # size\\r\\n 0xe0, # pdu type: CR\\r\\n self.dst_ref,\\r\\n self.src_ref,\\r\\n 0, # flag\\r\\n 0xc1, 2, self.src_tsap,\\r\\n 0xc2, 2, self.dst_tsap,\\r\\n 0xc0, 1, self.tpdu_size)\",\n \"def _pack(self):\\n header = struct.pack(self.PACKAGING_FORMAT, self.outcome)\\n return header\",\n \"def decode_packet(self, bytes):\\n b64 = False\\n if not isinstance(bytes, six.binary_type):\\n bytes = bytes.encode('utf-8')\\n\\n packet_type = six.byte2int(bytes[0:1])\\n if packet_type == ord('b'):\\n binary = True\\n bytes = bytes[1:]\\n packet_type = int(chr(six.byte2int(bytes[0:1])))\\n b64 = True\\n elif packet_type >= ord('0'):\\n packet_type = int(chr(packet_type))\\n binary = False\\n else:\\n binary = True\\n\\n packet_data = None\\n if len(bytes) > 1:\\n if binary:\\n if b64:\\n packet_data = base64.b64decode(bytes[1:])\\n else:\\n packet_data = bytes[1:]\\n else:\\n packet_data = bytes[1:].decode('utf-8')\\n\\n return Packet(packet_type, packet_data, binary)\",\n \"def serialize(self):\\n messageLen = len(self._messageBuf) + 1 # 1 byte for the message type\\n header = pack(self.headerFormat, messageLen)\\n msgType = pack(self.messageTypeFormat, self.messageType)\\n payload = bytes(self._messageBuf)\\n return header + msgType + payload\",\n \"def spoof_packet(packet):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6658192","0.6616389","0.661359","0.6557513","0.6539478","0.65270644","0.63207364","0.62352747","0.62149036","0.6198456","0.6153788","0.613428","0.6095934","0.605854","0.60508865","0.6032792","0.60198796","0.5980188","0.5960326","0.5957138","0.59558177","0.5952489","0.5942229","0.5931163","0.59255713","0.5909044","0.58949924","0.58709973","0.5860116","0.5850018","0.58436483","0.5788317","0.5785215","0.57714033","0.5768831","0.5763338","0.5729878","0.5723984","0.57163846","0.5710903","0.5706118","0.57034445","0.5658344","0.56558317","0.5646575","0.5645155","0.56317455","0.5631092","0.5630985","0.56292117","0.5625674","0.56228507","0.56215745","0.561975","0.5609417","0.5589504","0.5577967","0.5577126","0.55515164","0.55498546","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55492175","0.55473536","0.5545672","0.5541798","0.55384934","0.55384934","0.55384934","0.5538074","0.553485","0.5534678","0.5527371","0.5525412","0.55119485","0.55113643","0.5507895","0.550435","0.54975283","0.5496607","0.54908663","0.54867655","0.548354","0.54761016","0.54704046","0.5469726","0.54649854"],"string":"[\n \"0.6658192\",\n \"0.6616389\",\n \"0.661359\",\n \"0.6557513\",\n \"0.6539478\",\n \"0.65270644\",\n \"0.63207364\",\n \"0.62352747\",\n \"0.62149036\",\n \"0.6198456\",\n \"0.6153788\",\n \"0.613428\",\n \"0.6095934\",\n \"0.605854\",\n \"0.60508865\",\n \"0.6032792\",\n \"0.60198796\",\n \"0.5980188\",\n \"0.5960326\",\n \"0.5957138\",\n \"0.59558177\",\n \"0.5952489\",\n \"0.5942229\",\n \"0.5931163\",\n \"0.59255713\",\n \"0.5909044\",\n \"0.58949924\",\n \"0.58709973\",\n \"0.5860116\",\n \"0.5850018\",\n \"0.58436483\",\n \"0.5788317\",\n \"0.5785215\",\n \"0.57714033\",\n \"0.5768831\",\n \"0.5763338\",\n \"0.5729878\",\n \"0.5723984\",\n \"0.57163846\",\n \"0.5710903\",\n \"0.5706118\",\n \"0.57034445\",\n \"0.5658344\",\n \"0.56558317\",\n \"0.5646575\",\n \"0.5645155\",\n \"0.56317455\",\n \"0.5631092\",\n \"0.5630985\",\n \"0.56292117\",\n \"0.5625674\",\n \"0.56228507\",\n \"0.56215745\",\n \"0.561975\",\n \"0.5609417\",\n \"0.5589504\",\n \"0.5577967\",\n \"0.5577126\",\n \"0.55515164\",\n \"0.55498546\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55492175\",\n \"0.55473536\",\n \"0.5545672\",\n \"0.5541798\",\n \"0.55384934\",\n \"0.55384934\",\n \"0.55384934\",\n \"0.5538074\",\n \"0.553485\",\n \"0.5534678\",\n \"0.5527371\",\n \"0.5525412\",\n \"0.55119485\",\n \"0.55113643\",\n \"0.5507895\",\n \"0.550435\",\n \"0.54975283\",\n \"0.5496607\",\n \"0.54908663\",\n \"0.54867655\",\n \"0.548354\",\n \"0.54761016\",\n \"0.54704046\",\n \"0.5469726\",\n \"0.54649854\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64134574"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":90591,"cells":{"query":{"kind":"string","value":"Lift a sampling function to one that draws multiple iid samples."},"document":{"kind":"string","value":"def iid_sample(sample_fn, sample_shape):\n sample_shape = distribution_util.expand_to_vector(\n ps.cast(sample_shape, np.int32), tensor_name='sample_shape')\n n = ps.cast(ps.reduce_prod(sample_shape), dtype=np.int32)\n static_n = tf.get_static_value(tf.convert_to_tensor(n))\n\n def unflatten(x):\n sample_dims = 0 if static_n == 1 else 1\n unflattened_shape = ps.cast(\n ps.concat([sample_shape, ps.shape(x)[sample_dims:]], axis=0),\n dtype=np.int32)\n return tf.reshape(x, unflattened_shape)\n\n def iid_sample_fn(*args, **kwargs):\n \"\"\"Draws iid samples from `fn`.\"\"\"\n\n with tf.name_scope('iid_sample_fn'):\n\n seed = kwargs.pop('seed', None)\n if samplers.is_stateful_seed(seed):\n kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())\n def pfor_loop_body(_):\n with tf.name_scope('iid_sample_fn_stateful_body'):\n return sample_fn(*args, **kwargs)\n else:\n # If a stateless seed arg is passed, split it into `n` different\n # stateless seeds, so that we don't just get a bunch of copies of the\n # same sample.\n if not JAX_MODE:\n warnings.warn(\n 'Saw Tensor seed {}, implying stateless sampling. Autovectorized '\n 'functions that use stateless sampling may be quite slow because '\n 'the current implementation falls back to an explicit loop. This '\n 'will be fixed in the future. For now, you will likely see '\n 'better performance from stateful sampling, which you can invoke '\n 'by passing a Python `int` seed.'.format(seed))\n seed = samplers.split_seed(seed, n=n, salt='iid_sample_stateless')\n def pfor_loop_body(i):\n with tf.name_scope('iid_sample_fn_stateless_body'):\n return sample_fn(*args, seed=tf.gather(seed, i), **kwargs)\n\n if static_n == 1:\n draws = pfor_loop_body(0)\n else:\n draws = parallel_for.pfor(pfor_loop_body, n)\n return tf.nest.map_structure(unflatten, draws, expand_composites=True)\n\n return iid_sample_fn"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iid_sample_fn(*args, **kwargs):\n\n with tf.name_scope('iid_sample_fn'):\n\n seed = kwargs.pop('seed', None)\n if samplers.is_stateful_seed(seed):\n kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())\n def pfor_loop_body(_):\n with tf.name_scope('iid_sample_fn_stateful_body'):\n return sample_fn(*args, **kwargs)\n else:\n # If a stateless seed arg is passed, split it into `n` different\n # stateless seeds, so that we don't just get a bunch of copies of the\n # same sample.\n if not JAX_MODE:\n warnings.warn(\n 'Saw Tensor seed {}, implying stateless sampling. Autovectorized '\n 'functions that use stateless sampling may be quite slow because '\n 'the current implementation falls back to an explicit loop. This '\n 'will be fixed in the future. For now, you will likely see '\n 'better performance from stateful sampling, which you can invoke '\n 'by passing a Python `int` seed.'.format(seed))\n seed = samplers.split_seed(seed, n=n, salt='iid_sample_stateless')\n def pfor_loop_body(i):\n with tf.name_scope('iid_sample_fn_stateless_body'):\n return sample_fn(*args, seed=tf.gather(seed, i), **kwargs)\n\n if static_n == 1:\n draws = pfor_loop_body(0)\n else:\n draws = parallel_for.pfor(pfor_loop_body, n)\n return tf.nest.map_structure(unflatten, draws, expand_composites=True)","def __call__(self, samples_number):\n self.sampler.sample(samples_number)","def random_resample(*args, samples,\n function=None, function_kwargs=None, bundle_args=True,\n replace=True):\n samples_spec = samples.copy() # copy because use pop below\n args_sub = [obj.copy() for obj in args]\n dim_block_1 = [d for d, s in samples_spec.items() if s[1] == 1]\n\n # Do all dimensions with block_size = 1 together\n samples_block_1 = { dim: samples_spec.pop(dim) for dim in dim_block_1 }\n random_samples = {dim: \n np.random.choice(\n len(args_sub[0][dim]),\n size=n,\n replace=replace)\n for dim, (n, _) in samples_block_1.items()}\n args_sub = [obj.isel(\n {dim: random_samples[dim] \n for dim in (set(random_samples.keys()) & set(obj.dims))}) for obj in args_sub]\n\n # Do any remaining dimensions\n for dim, (n, block_size) in samples_spec.items():\n n_blocks = int(n / block_size)\n random_samples = [slice(x,x+block_size) \n for x in np.random.choice(\n len(args_sub[0][dim])-block_size+1, \n size=n_blocks,\n replace=replace)]\n args_sub = [xr.concat([obj.isel({dim: random_sample}) \n for random_sample in random_samples],\n dim=dim) \n if dim in obj.dims else obj \n for obj in args_sub]\n\n if function:\n if bundle_args:\n if function_kwargs is not None:\n res = function(*args_sub, **function_kwargs)\n else:\n res = function(*args_sub)\n else:\n if function_kwargs is not None:\n res = tuple([function(obj, **function_kwargs) for obj in args_sub])\n else:\n res = tuple([function(obj) for obj in args_sub])\n else:\n res = tuple(args_sub,)\n\n if isinstance(res, tuple):\n if len(res) == 1:\n return res[0]\n else:\n return res","def easy_sample(self, num, **kwargs):\n return self.preprocess(self.sample(num, **kwargs), **kwargs)","def generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def sample(self, x):","def _generate(self, **kwargs):\n N = self.parameter_schema['N']\n parameter_count = len(self._parameter_names)\n common_override_kwargs = {}\n override_kwargs = self._sampler_overrides(common_override_kwargs)\n if kwargs:\n kwargs.update(override_kwargs)\n else:\n kwargs = override_kwargs\n __import__(\"SALib.sample\", fromlist=[self.sampler_class])\n sampler = getattr(SALib.sample, self.sampler_class)\n problem = self.parameter_schema[\"problem\"]\n self._samples = sampler.sample(problem, N, **kwargs)\n self._samples = numpy.unique(self._samples, axis=0)\n super()._generate()","def sample(self,f,N,p=100):\n return [f(x) for x in np.linspace(0,N,p)]","def sample(self, batchsize, *args, **kwargs):\n raise NotImplementedError","def sample(self, verbose=False):\n\t\tfor i in range(self.nsamp): self.subsample(verbose)\n\t\treturn self.amps, self.pos, self.irads","def sample(self, n):\n raise NotImplementedError","def test_sampling(self):\n dim = Fidelity(\"epoch\", 1, 2)\n assert dim.sample() == [2]\n dim = Fidelity(\"epoch\", 1, 5)\n assert dim.sample() == [5]\n dim = Fidelity(\"epoch\", 1, 5)\n assert dim.sample(4) == [5] * 4","def draw_samplers(self):\n raise NotImplementedError(\" The draw_samplers() method has not been implemented \")","def sample(self, num_samples, **kwargs):\n pass","def run(self, repetitions, **kwargs):\n\t\tself.sampler.sample(repetitions, **kwargs)","def sample(f, *var_args):\n if len(var_args) == 1:\n return sample2d(f, var_args[0])\n elif len(var_args) == 2:\n return sample3d(f, var_args[0], var_args[1])\n else:\n raise ValueError(\"Only 2d and 3d sampling are supported at this time.\")","def sample(self, *args, **kwargs):","def sample_n_unique(sampling_f, n):\n res = []\n while len(res) < n:\n candidate = sampling_f()\n if candidate not in res:\n res.append(candidate)\n return res","def sample(self, features, states=None):\n sampled_ids = []\n inputs = features.unsqueeze(1)\n for i in range(30): # maximum sampling length\n hiddens, states = self.lstm(inputs, states) # (batch_size, 1, hidden_size), \n outputs = self.linear(hiddens.squeeze(1)) # (batch_size, vocab_size)\n # print(np.asarray(outputs).shape) \n # print(outputs)\n predicted = outputs.max(1)[1]\n sampled_ids.append(predicted)\n inputs = self.embed(predicted)\n inputs = inputs.unsqueeze(1) # (batch_size, 1, embed_size)\n # print(sampled_ids)\n sampled_ids = torch.cat(sampled_ids, 0) # (batch_size, 20)\n # print(sampled_ids)\n # exit(0)\n return sampled_ids.squeeze()","def sample(self, n=1):\n raise NotImplementedError","def _choose_sample(self):\n\n \t #periodically generate a new reconstruction for the purposes of sampling","def sampler(self) -> Generator[int, None, None]:\n remaining = self.num_samples\n if self.shuffled:\n while remaining > 0:\n n = min(remaining, len(self.data_source))\n for idx in torch.randperm(len(self.data_source))[0:n]:\n yield int(idx)\n remaining -= n\n else:\n current_idx = None\n while remaining > 0:\n if current_idx is None or current_idx >= len(self.data_source):\n current_idx = 0\n yield current_idx\n current_idx += 1\n remaining -= 1","def get_sampled_ids(self):\n seed = 123\n #initiate two lists, to save randomly picked positive and negative cases respectively\n positiveIds = []\n negativeIds = []\n i = 0\n print \"==> resampling ... \",\n while len(positiveIds)+len(negativeIds)<self.ntotal:\n # start a loop from 0 to total size of the new sampe\n # if it catches a number divisable by the sought ratio, update the list of positive cases ids\n # otherwise keep update the list of negative cases ids\n try:\n if i%int(100 / self.posRate) == 0: \n positiveIds.append(self.posId.next())\n else:\n negativeIds.append(self.negId.next())\n except:\n print \"Enter posRate higher than the initial rate\"\n break\n i+=1\n print \"Done sampling\"\n print \"positive:\", len(positiveIds)\n print \"negative:\", len(negativeIds)\n print \"final size:\", len(positiveIds)+len(negativeIds)\n #return sorted list of the two list of ids combined\n return sorted(positiveIds+negativeIds)","def draw_bs_pairs(x, y, func, size=1):\n\n # Set up array of indices to sample from: inds\n inds = np.arange(len(x))\n\n # Initialize replicates\n bs_slope_reps = np.empty(size)\n bs_intercept_reps = np.empty(size)\n\n # Generate replicates\n for i in range(size):\n bs_inds = np.random.choice(inds,size=len(inds))\n bs_x, bs_y = x[bs_inds],y[bs_inds]\n bs_replicates[i] = func(bs_x,bs_y)\n\n return bs_replicates","def sample(self, count):\n batch = deepcopy(random.sample(self.buffer, count))\n batch = list(zip(*batch))\n args, kwargs = batch[:-1], batch[-1]\n args = [np.stack(arr) for arr in args]\n out = dict(zip(self.keywords, list(zip(*[d.values() for d in kwargs]))))\n for k, v in out.items():\n out[k] = np.stack(v)\n return (*args, out)","def sample(self):\r\n raise NotImplementedError","def sample(self, features, states=None):\r\n sampled_ids = []\r\n inputs = features.unsqueeze(1)\r\n for i in range(105): #62\r\n hiddens, states = self.lstm(inputs, states)\r\n outputs = self.linear(hiddens.squeeze(1))\r\n a = outputs.max(1)\r\n predicted = outputs.max(1)[1]\r\n sampled_ids.append(predicted)\r\n inputs = self.embed(predicted)\r\n inputs = inputs.unsqueeze(1)\r\n return sampled_ids","def sample(self, observation):\n raise NotImplementedError","def generate_in(self, n_samples, start_sample=0):\n pass","def _sample(self, n=1):\n return [self[i] for i in np.random.choice(self.length, n, replace=False)]","def _sample_internal(self, opts, num):\n noise = utils.generate_noise(opts, num)\n sample = self._run_batch(\n opts, self._generated, self._noise_ph, noise,\n self._is_training_ph, False)\n return sample","def sample(self, num, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')","def batchwise_sample(gen, num_samples, batch_size):\n\n samples = []\n for i in range(int(ceil(num_samples/float(batch_size)))):\n samples.append(gen.sample(batch_size))\n\n return torch.cat(samples, 0)[:num_samples]","def sampler(self, *args, **kwargs):\n\n return (samples_subgraphs ** 2).tolist()","def draw_bs_pairs(x, y, func, size=1):\n\n # Set up array of indices to sample from: inds\n inds = np.arange(len(x))\n\n # Initialize replicates: bs_replicates\n bs_replicates = np.empty(size)\n\n # Generate replicates\n for i in range(size):\n bs_inds = np.random.choice(inds,size=len(inds))\n bs_x, bs_y = x[bs_inds],y[bs_inds]\n bs_replicates[i] = func(bs_x,bs_y)\n\n return bs_replicates","def n_random_resamples(*args, samples, n_repeats, \n function=None, function_kwargs=None, bundle_args=True, \n replace=True, with_dask=True):\n\n if with_dask & (n_repeats > 1000):\n n_args = itertools.repeat(args[0], times=n_repeats)\n b = db.from_sequence(n_args, npartitions=100)\n rs_list = b.map(random_resample, *(args[1:]), \n **{'samples':samples, 'function':function, \n 'function_kwargs':function_kwargs, 'replace':replace}).compute()\n else: \n resample_ = dask.delayed(random_resample) if with_dask else random_resample\n rs_list = [resample_(*args,\n samples=samples,\n function=function,\n function_kwargs=function_kwargs,\n bundle_args=bundle_args,\n replace=replace) for _ in range(n_repeats)] \n if with_dask:\n rs_list = dask.compute(rs_list)[0]\n \n if all(isinstance(r, tuple) for r in rs_list):\n return tuple([xr.concat([r.unify_chunks() for r in rs], dim='k') for rs in zip(*rs_list)])\n else:\n return xr.concat([r.unify_chunks() for r in rs_list], dim='k')","def _sampling_concrete(self, args):\n return sampling_concrete(args, (None, self.latent_disc_dim))","def forward_sample(self, n):\n return self.flow.sample(n)","def sample(self, n, include=True):\n return [self(t / n) for t in range(n + int(include))]","def sample(self):\n return self._sample_func","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def _handler_sample(self, *args, **kwargs):\n next_state = None\n timeout = time.time() + SAMPLE_TIMEOUT\n\n for i in self._units:\n self._do_command(Command.READ, i)\n\n particles = self.wait_for_particles([DataParticleType.D1000_PARSED], timeout)\n\n return next_state, (next_state, particles)","def sampling(n):\n\n def _sample(x):\n if n > x.shape[0]:\n # generate dups\n count = n // x.shape[0] + 1\n x = pd.concat([x] * count)\n return x.sample(n=n)\n else:\n return x.sample(n=n)\n\n return _sample","def mksampler(x):\n if hasattr(x, \"__call__\"):\n return x\n elif type(x) is list:\n # NB: disjoint ranges can be given as nested lists, e.g. [(1,2), (4,5)]\n if len(x) == 2 and type(x[0]) in (int,float) and type(x[1]) in (int,float):\n #print \"MKSAMPLER: Casting %s to UniformSampler\" % str(x)\n return UniformSampler(*x)\n elif len(x) > 2 or (len(x) > 0 and type(x[0]) not in (int,float)):\n #print \"MKSAMPLER: Casting %s to DisjointUniformSampler\" % str(x)\n return DisjointUniformSampler(x)\n if len(x) < 2:\n raise Exception(\"Supplied list could not be converted to a continuous sampler\")\n elif type(x) is tuple:\n #print \"MKSAMPLER: Casting %s to CyclicSeqSampler\" % str(x)\n return CyclicSeqSampler(*x)\n elif type(x) is set:\n #print \"MKSAMPLER: Casting %s to RandomSeqSampler\" % str(x)\n return RandomSeqSampler(*x)\n else:\n #print \"MKSAMPLER: Casting %s to ConstSampler\" % str(x)\n return ConstSampler(x)","def apply():\r\n result = dataSampling(str, \"hhhhhhahhhhhahhahahahahhahahha\", 5)\r\n final_res = dataScreening(result, \"ha\")\r\n print(final_res)","def resample_filters(self):\n a = len(self.filtered_ids)\n b = len(self.orig_image_ids)\n imbalance_ratio = a / b\n min_ratio = 0.5\n if imbalance_ratio > min_ratio:\n return\n minr = min_ratio\n num_req = int((minr * b - a) / (1 - minr))\n new_ids = ((num_req) // a) * self.filtered_ids\n if num_req % a != 0:\n some_more = random.sample(self.filtered_ids, k=(num_req % a))\n new_ids += some_more\n self.image_ids = self.orig_image_ids + new_ids\n print(\"Resampled total:\", len(self.image_ids))","def sample(draws, step_method, chain_state, sample_history ):\n start = time.time()\n for i in xrange(int(draws)):\n chain_state = step_method.step(chain_state)\n sample_history.record(chain_state, step_method)\n \n return (time.time() - start)","def sample(self, size=1):\n pass","def sample(self):\n raise NotImplementedError","def sample(self):\n raise NotImplementedError","def build_sampler(self, params):\n\n def sampler(logits_1, logits_2, key):\n q_kwargs = dict(transpose=True) if self.use_transpose else {}\n x = self.model.bind(params).sample(logits_1, key)\n y = self.model.bind(params).sample(logits_2, key, **q_kwargs)\n return jnp.zeros([10, 10]).at[x, y].set(1.)\n\n return sampler","def downsample_sam(self, factor):","def samples(self, gp):\r\n raise NotImplementedError","def sample(self,p0=None,nsamp=None): \r\n raise NotImplementedError('Need to implement sample function')","def load_by_ids(load_x: callable, load_y: callable, ids: Sequence, shuffle: bool = False):\n if shuffle:\n ids = np.random.permutation(ids)\n for patient_id in ids:\n yield load_x(patient_id), load_y(patient_id)","def mixrows(self, func=lambda a: random().scramble(a)):\n self.a = func(self.a)","def test_sampling2 () :\n delta = 2 * np.pi / 3\n r = Reward(partial(stepFunction, \n xRange=(-delta/2, delta/2), \n yRange=(-delta/2, delta/2)), \n (-1, 0))\n states = []\n xs = np.arange(-np.pi, np.pi, delta)\n ys = np.arange(-np.pi, np.pi, delta)\n for x, y in product(xs, ys) : \n states.append(\n toExternalStateRep([x + delta / 2, y + delta / 2, 0, 0]).astype(float)\n )\n agent = findOptimalAgent(r)\n vals = estimateValueFromAgent(states, agent, r)\n for s, v in zip(states, vals) : \n print(toInternalStateRep(s)[:2], v)","def sample(self, count):\n batch = deepcopy(random.sample(self.buffer, count))\n batch = [np.array(arr) for arr in zip(*batch)]\n\n return batch","def double_sampling(X_train, y_train, X_test, y_test, sampling_instances1, sampling_instances2, model_instances, func):\n\n list_of_df_metrics = []\n\n for sampling_instance1 in sampling_instances1:\n print('First Round:')\n if sampling_instance1 is not None:\n print('fitting sampling of 1st round '+ str(sampling_instances1.index(sampling_instance1) + 1) + ' over ' + str(len(sampling_instances1)) + ': ' + type(sampling_instance1).__name__)\n X_train_1st_round, y_train1st_round = sampling_instance1.fit_resample(X=X_train, y=y_train)\n print('Second Round:')\n else:\n print('No 1st round Sampling methods applied')\n X_train_1st_round, y_train1st_round = X_train, y_train\n\n df_metrics = sampling(X_train_1st_round, y_train1st_round, X_test, y_test, sampling_instances2, model_instances, func)\n\n list_of_df_metrics.append(df_metrics)\n\n df_metrics_all = pd.concat(list_of_df_metrics, keys=[type(x).__name__ for x in sampling_instances1], names=['First Sampling Round'])\n\n return df_metrics_all","def uniform_sample(x):\n return np.random.choice(x)","def random_sampling(elements, n):\r\n import random\r\n return [random.choice(elements) for i in range(n)]","def sample(self, n_samps):\n # print('gauss trying to sample '+str(n_samps)+' from '+str(self.dist))\n # xs = np.array([self.sample_one() for n in range(n_samps)])\n xs = np.array(self.dist.sample(n_samps))\n # print('gauss sampled '+str(n_samps)+' from '+str(self.dist))\n return xs","def sample_batch(memory, n):\n batch = rnd.sample(memory, n) # List containing tuples\n return batch","def __call__(self, params):\r\n return self.sample(params)","def next_sample(self, batch_size=1):\n\n X = []\n y = []\n for x in range(batch_size):\n if self._random_state.rand() < 1/self.abrupt_drift_rate:\n self.offset = self.offset + self._random_state.rand()\n X.append(x + self._x_idx)\n y.append(math.sin(self.offset + x/(2*math.pi*self.granularity))\n + self._random_state.normal(scale=0.05) + self.cont)\n\n self._x_idx += batch_size\n\n return (X, y)","def sample(read_sampler, n, array, res=1.0, prng = np.random.RandomState()):\n for read in read_sampler.pull_reads(n, prng):\n map_read(array, read, res)","def sample(self, list_to_sample):\n raise NotImplementedError","def iid_sampling(dataset, num_users):\n num_items = int(len(dataset) / num_users)\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\n for i in range(num_users):\n dict_users[i] = set(np.random.choice(all_idxs, num_items,\n replace=False))\n all_idxs = list(set(all_idxs) - dict_users[i])\n return dict_users","def draw_perm_reps(data_1, data_2, func, size=1):\n # Initialize array of replicates: perm_replicates\n perm_replicates = np.empty(size)\n for i in range(size):\n perm_sample_1, perm_sample_2 = permutation_sample(data_1, data_2)\n perm_replicates[i] = func(perm_sample_1, perm_sample_2)\n return perm_replicates","def _get_bootstrap_sample(x, y, num_reps):\r\n combined = array(list(x) + list(y))\r\n total_obs = len(combined)\r\n num_x = len(x)\r\n for i in range(num_reps):\r\n # sampling with replacement\r\n indices = randint(0, total_obs, total_obs)\r\n sampled = combined.take(indices)\r\n # split into the two populations\r\n sampled_x = sampled[:num_x]\r\n sampled_y = sampled[num_x:]\r\n yield sampled_x, sampled_y","def sample(self):\n return self._action_out(\n [self.action_space.sample() for _ in range(self.batch_size)]\n )","def output_multiple(self) -> \"int\":\n return _beamforming_swig.randomsampler_sptr_output_multiple(self)","def __call__(self):\n if self.numbatches is None:\n pool = self.pooler()\n if self.batchsize is None:\n self.batchsize = self.pooler.nInPool()\n self.numbatches = self.pooler.nInPool()//self.batchsize\n for i in xrange(self.numbatches):\n pool = self.pooler()\n self._reset_batch()\n if self.samplemethod == 'balance' and len(self.keysamplers)>0:\n batchinds,keyids = self._samplebalanced(pool)\n elif self.samplemethod == 'uniform':\n batchinds,keyids = self._sampleuniform(pool)\n else:\n batchinds,keyids = self._samplesequential(i)\n batch = self._extractInds(pool,batchinds,keyids)\n for k in batch:\n batch[k][np.isnan(batch[k])] = self.nanreplacement\n yield batch","def sample(self, nsamples):\n return self.dist.sample(nsamples)","def sample(self):","def sample(self):\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)","def random_batch(self):\n x = self._random_x()\n y = self._random_x()\n\n return x, y, self.f(x, y)","def sample_input_domain(num_samples):\n s1 = np.random.random(num_samples) * 10\n s2 = np.random.random(num_samples) * 2 - 5\n s3 = np.random.random(num_samples)\n s4 = np.random.random(num_samples) * 30 + 20\n return s1, s2, s3, s4","def sample(self, size=1):\n raise NotImplementedError","def sample(self, size=1):\n raise NotImplementedError","def sample(self, size=1):\n raise NotImplementedError","def sample(self, size=1):\n raise NotImplementedError","def sample(self, batch_size):\n raise NotImplementedError","def gen_arms_per_batch(\n self,\n ) -> Tuple[torch.Tensor, torch.Tensor]:\n sample_batch_idx = random.randint(0, self.num_unique_batches - 1)\n arms_ids_batch = self.all_unique_arm_ids[sample_batch_idx]\n return sample_batch_idx, arms_ids_batch","def sample(self, i):\n\t\tif self.nsamp % 2 == 0:\n\t\t\ti0 = i-(self.nsamp/2-1)\n\t\t\ti1 = i+(self.nsamp/2)\n\t\telse:\n\t\t\ti0 = i-((self.nsamp-1)/2.)\n\t\t\ti1 = i+((self.nsamp-1)/2.)\n\t\treturn self.yval[i0:i1]","def split(self, args):\n non_integer_count = sum(not arg.is_Integer for arg in args)\n assert non_integer_count <= self.count - 1\n count_split = combinatorics.uniform_non_negative_integers_with_sum(\n len(args), (self.count - 1) - non_integer_count)\n for i, arg in enumerate(args):\n if not arg.is_Integer:\n count_split[i] += 1\n if all(count == 0 for count in count_split):\n assert self.entropy == 0\n entropies = np.zeros(len(count_split))\n else:\n entropies = (\n np.random.dirichlet(np.maximum(1e-9, count_split)) * self.entropy)\n return [_SampleArgs(op_count, entropy)\n for op_count, entropy in zip(count_split, entropies)]","def data_feeder_2():\n return random.sample(range(100), 10)","def initial_sampling(y):\n samples = list(np.random.randint(0, len(y), 2))\n while len(np.unique(y[samples] > 0.5)) != 2:\n samples = list(np.random.randint(0, len(y), 2))\n return samples","def draw_bootstrap_pairs(x, y, func, size=1):\n\n # Set up array of indices to sample from: inds\n inds = np.arange(len(x))\n\n # Initialize replicates: bs_replicates\n bs_replicates = np.empty(size)\n\n # Generate replicates\n for i in range(size):\n bs_inds = np.random.choice(inds, len(inds))\n bs_x, bs_y = x[bs_inds], y[bs_inds]\n bs_replicates[i] = func(bs_x, bs_y)\n\n return bs_replicates","def sample(self, seg_logit, seg_label):","def subsample(inputs, factor, scope=None):\n if factor == 1:\n return inputs\n else:\n return slim.max_pool2d(inputs, [1, 1], stride=factor, scope=scope)","def nonblocking_sample_method(f):\n from dimod.sampleset import SampleSet # avoid circular import\n\n @wraps(f)\n def _sample(*args, **kwargs):\n iterator = f(*args, **kwargs)\n\n # resolve blocking part now, and make hook for the non-blocking part\n return SampleSet.from_future(next(iterator), lambda _: next(iterator))\n return _sample","def next_sample(self, batch_size=1):\n\n X = []\n y = []\n self.cont = 2.\n for x in range(batch_size):\n if x > batch_size/2 and self.cont == 2:\n self.cont = 5.*np.random.rand()\n if self._random_state.rand() < 1/self.abrupt_drift_rate:\n #self.offset += 1\n pass\n y.append(self.offset + (x*self.cont)/self.granularity + self._random_state.normal(scale=1))\n X.append(float(x))\n self._x_idx += batch_size\n zipped = list(zip(X, y))\n if self.shuffleData:\n shuffle(zipped)\n \n\n return ([float(zipped[i][0]) for i in range(len(X))], [float(zipped[i][1]) for i in range(len(X))])","def get_random_samplers(self, n):\n if not self.has_samplers():\n self.draw_samplers()\n \n def get_shuffledcopy(x):\n x_ = x.copy()\n np.random.shuffle(x_)\n return x_\n \n return get_shuffledcopy(self.samplers)[:n]","def sampler_to_iterator(dataset, sampler):\n for sample in sampler:\n if isinstance(sample, (list, tuple)):\n # yield a batch\n yield [dataset[i] for i in sample]\n else:\n # yield a single example\n yield dataset[sample]","def compose_sample(lfads_hps, ib_k, ic_j, ii_txi):\n ii_ti = np.reshape(ii_txi, (-1,))\n return np.concatenate([ib_k, ic_j, ii_ti], axis=0)","def sample(self, length):\n pass","def _sample_synthetic(self, X):\n n_samples = X.shape[0]\n self.y = np.concatenate((np.ones(n_samples), np.zeros(n_samples)))\n \n random_state = _forest.check_random_state(self.random_state) \n\n X_synth = np.asarray([np.apply_along_axis(random_state.choice, 0, X) for _ in range(n_samples)])\n self.X = np.concatenate((X, X_synth))\n\n return self.X, self.y","def bs_replicate(data, func=np.mean):\n bs_sample = np.random.choice(data, replace=True, size=len(data))\n return func(bs_sample)"],"string":"[\n \"def iid_sample_fn(*args, **kwargs):\\n\\n with tf.name_scope('iid_sample_fn'):\\n\\n seed = kwargs.pop('seed', None)\\n if samplers.is_stateful_seed(seed):\\n kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())\\n def pfor_loop_body(_):\\n with tf.name_scope('iid_sample_fn_stateful_body'):\\n return sample_fn(*args, **kwargs)\\n else:\\n # If a stateless seed arg is passed, split it into `n` different\\n # stateless seeds, so that we don't just get a bunch of copies of the\\n # same sample.\\n if not JAX_MODE:\\n warnings.warn(\\n 'Saw Tensor seed {}, implying stateless sampling. Autovectorized '\\n 'functions that use stateless sampling may be quite slow because '\\n 'the current implementation falls back to an explicit loop. This '\\n 'will be fixed in the future. For now, you will likely see '\\n 'better performance from stateful sampling, which you can invoke '\\n 'by passing a Python `int` seed.'.format(seed))\\n seed = samplers.split_seed(seed, n=n, salt='iid_sample_stateless')\\n def pfor_loop_body(i):\\n with tf.name_scope('iid_sample_fn_stateless_body'):\\n return sample_fn(*args, seed=tf.gather(seed, i), **kwargs)\\n\\n if static_n == 1:\\n draws = pfor_loop_body(0)\\n else:\\n draws = parallel_for.pfor(pfor_loop_body, n)\\n return tf.nest.map_structure(unflatten, draws, expand_composites=True)\",\n \"def __call__(self, samples_number):\\n self.sampler.sample(samples_number)\",\n \"def random_resample(*args, samples,\\n function=None, function_kwargs=None, bundle_args=True,\\n replace=True):\\n samples_spec = samples.copy() # copy because use pop below\\n args_sub = [obj.copy() for obj in args]\\n dim_block_1 = [d for d, s in samples_spec.items() if s[1] == 1]\\n\\n # Do all dimensions with block_size = 1 together\\n samples_block_1 = { dim: samples_spec.pop(dim) for dim in dim_block_1 }\\n random_samples = {dim: \\n np.random.choice(\\n len(args_sub[0][dim]),\\n size=n,\\n replace=replace)\\n for dim, (n, _) in samples_block_1.items()}\\n args_sub = [obj.isel(\\n {dim: random_samples[dim] \\n for dim in (set(random_samples.keys()) & set(obj.dims))}) for obj in args_sub]\\n\\n # Do any remaining dimensions\\n for dim, (n, block_size) in samples_spec.items():\\n n_blocks = int(n / block_size)\\n random_samples = [slice(x,x+block_size) \\n for x in np.random.choice(\\n len(args_sub[0][dim])-block_size+1, \\n size=n_blocks,\\n replace=replace)]\\n args_sub = [xr.concat([obj.isel({dim: random_sample}) \\n for random_sample in random_samples],\\n dim=dim) \\n if dim in obj.dims else obj \\n for obj in args_sub]\\n\\n if function:\\n if bundle_args:\\n if function_kwargs is not None:\\n res = function(*args_sub, **function_kwargs)\\n else:\\n res = function(*args_sub)\\n else:\\n if function_kwargs is not None:\\n res = tuple([function(obj, **function_kwargs) for obj in args_sub])\\n else:\\n res = tuple([function(obj) for obj in args_sub])\\n else:\\n res = tuple(args_sub,)\\n\\n if isinstance(res, tuple):\\n if len(res) == 1:\\n return res[0]\\n else:\\n return res\",\n \"def easy_sample(self, num, **kwargs):\\n return self.preprocess(self.sample(num, **kwargs), **kwargs)\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def sample(self, x):\",\n \"def _generate(self, **kwargs):\\n N = self.parameter_schema['N']\\n parameter_count = len(self._parameter_names)\\n common_override_kwargs = {}\\n override_kwargs = self._sampler_overrides(common_override_kwargs)\\n if kwargs:\\n kwargs.update(override_kwargs)\\n else:\\n kwargs = override_kwargs\\n __import__(\\\"SALib.sample\\\", fromlist=[self.sampler_class])\\n sampler = getattr(SALib.sample, self.sampler_class)\\n problem = self.parameter_schema[\\\"problem\\\"]\\n self._samples = sampler.sample(problem, N, **kwargs)\\n self._samples = numpy.unique(self._samples, axis=0)\\n super()._generate()\",\n \"def sample(self,f,N,p=100):\\n return [f(x) for x in np.linspace(0,N,p)]\",\n \"def sample(self, batchsize, *args, **kwargs):\\n raise NotImplementedError\",\n \"def sample(self, verbose=False):\\n\\t\\tfor i in range(self.nsamp): self.subsample(verbose)\\n\\t\\treturn self.amps, self.pos, self.irads\",\n \"def sample(self, n):\\n raise NotImplementedError\",\n \"def test_sampling(self):\\n dim = Fidelity(\\\"epoch\\\", 1, 2)\\n assert dim.sample() == [2]\\n dim = Fidelity(\\\"epoch\\\", 1, 5)\\n assert dim.sample() == [5]\\n dim = Fidelity(\\\"epoch\\\", 1, 5)\\n assert dim.sample(4) == [5] * 4\",\n \"def draw_samplers(self):\\n raise NotImplementedError(\\\" The draw_samplers() method has not been implemented \\\")\",\n \"def sample(self, num_samples, **kwargs):\\n pass\",\n \"def run(self, repetitions, **kwargs):\\n\\t\\tself.sampler.sample(repetitions, **kwargs)\",\n \"def sample(f, *var_args):\\n if len(var_args) == 1:\\n return sample2d(f, var_args[0])\\n elif len(var_args) == 2:\\n return sample3d(f, var_args[0], var_args[1])\\n else:\\n raise ValueError(\\\"Only 2d and 3d sampling are supported at this time.\\\")\",\n \"def sample(self, *args, **kwargs):\",\n \"def sample_n_unique(sampling_f, n):\\n res = []\\n while len(res) < n:\\n candidate = sampling_f()\\n if candidate not in res:\\n res.append(candidate)\\n return res\",\n \"def sample(self, features, states=None):\\n sampled_ids = []\\n inputs = features.unsqueeze(1)\\n for i in range(30): # maximum sampling length\\n hiddens, states = self.lstm(inputs, states) # (batch_size, 1, hidden_size), \\n outputs = self.linear(hiddens.squeeze(1)) # (batch_size, vocab_size)\\n # print(np.asarray(outputs).shape) \\n # print(outputs)\\n predicted = outputs.max(1)[1]\\n sampled_ids.append(predicted)\\n inputs = self.embed(predicted)\\n inputs = inputs.unsqueeze(1) # (batch_size, 1, embed_size)\\n # print(sampled_ids)\\n sampled_ids = torch.cat(sampled_ids, 0) # (batch_size, 20)\\n # print(sampled_ids)\\n # exit(0)\\n return sampled_ids.squeeze()\",\n \"def sample(self, n=1):\\n raise NotImplementedError\",\n \"def _choose_sample(self):\\n\\n \\t #periodically generate a new reconstruction for the purposes of sampling\",\n \"def sampler(self) -> Generator[int, None, None]:\\n remaining = self.num_samples\\n if self.shuffled:\\n while remaining > 0:\\n n = min(remaining, len(self.data_source))\\n for idx in torch.randperm(len(self.data_source))[0:n]:\\n yield int(idx)\\n remaining -= n\\n else:\\n current_idx = None\\n while remaining > 0:\\n if current_idx is None or current_idx >= len(self.data_source):\\n current_idx = 0\\n yield current_idx\\n current_idx += 1\\n remaining -= 1\",\n \"def get_sampled_ids(self):\\n seed = 123\\n #initiate two lists, to save randomly picked positive and negative cases respectively\\n positiveIds = []\\n negativeIds = []\\n i = 0\\n print \\\"==> resampling ... \\\",\\n while len(positiveIds)+len(negativeIds)<self.ntotal:\\n # start a loop from 0 to total size of the new sampe\\n # if it catches a number divisable by the sought ratio, update the list of positive cases ids\\n # otherwise keep update the list of negative cases ids\\n try:\\n if i%int(100 / self.posRate) == 0: \\n positiveIds.append(self.posId.next())\\n else:\\n negativeIds.append(self.negId.next())\\n except:\\n print \\\"Enter posRate higher than the initial rate\\\"\\n break\\n i+=1\\n print \\\"Done sampling\\\"\\n print \\\"positive:\\\", len(positiveIds)\\n print \\\"negative:\\\", len(negativeIds)\\n print \\\"final size:\\\", len(positiveIds)+len(negativeIds)\\n #return sorted list of the two list of ids combined\\n return sorted(positiveIds+negativeIds)\",\n \"def draw_bs_pairs(x, y, func, size=1):\\n\\n # Set up array of indices to sample from: inds\\n inds = np.arange(len(x))\\n\\n # Initialize replicates\\n bs_slope_reps = np.empty(size)\\n bs_intercept_reps = np.empty(size)\\n\\n # Generate replicates\\n for i in range(size):\\n bs_inds = np.random.choice(inds,size=len(inds))\\n bs_x, bs_y = x[bs_inds],y[bs_inds]\\n bs_replicates[i] = func(bs_x,bs_y)\\n\\n return bs_replicates\",\n \"def sample(self, count):\\n batch = deepcopy(random.sample(self.buffer, count))\\n batch = list(zip(*batch))\\n args, kwargs = batch[:-1], batch[-1]\\n args = [np.stack(arr) for arr in args]\\n out = dict(zip(self.keywords, list(zip(*[d.values() for d in kwargs]))))\\n for k, v in out.items():\\n out[k] = np.stack(v)\\n return (*args, out)\",\n \"def sample(self):\\r\\n raise NotImplementedError\",\n \"def sample(self, features, states=None):\\r\\n sampled_ids = []\\r\\n inputs = features.unsqueeze(1)\\r\\n for i in range(105): #62\\r\\n hiddens, states = self.lstm(inputs, states)\\r\\n outputs = self.linear(hiddens.squeeze(1))\\r\\n a = outputs.max(1)\\r\\n predicted = outputs.max(1)[1]\\r\\n sampled_ids.append(predicted)\\r\\n inputs = self.embed(predicted)\\r\\n inputs = inputs.unsqueeze(1)\\r\\n return sampled_ids\",\n \"def sample(self, observation):\\n raise NotImplementedError\",\n \"def generate_in(self, n_samples, start_sample=0):\\n pass\",\n \"def _sample(self, n=1):\\n return [self[i] for i in np.random.choice(self.length, n, replace=False)]\",\n \"def _sample_internal(self, opts, num):\\n noise = utils.generate_noise(opts, num)\\n sample = self._run_batch(\\n opts, self._generated, self._noise_ph, noise,\\n self._is_training_ph, False)\\n return sample\",\n \"def sample(self, num, **kwargs):\\n raise NotImplementedError(f'Should be implemented in derived class!')\",\n \"def batchwise_sample(gen, num_samples, batch_size):\\n\\n samples = []\\n for i in range(int(ceil(num_samples/float(batch_size)))):\\n samples.append(gen.sample(batch_size))\\n\\n return torch.cat(samples, 0)[:num_samples]\",\n \"def sampler(self, *args, **kwargs):\\n\\n return (samples_subgraphs ** 2).tolist()\",\n \"def draw_bs_pairs(x, y, func, size=1):\\n\\n # Set up array of indices to sample from: inds\\n inds = np.arange(len(x))\\n\\n # Initialize replicates: bs_replicates\\n bs_replicates = np.empty(size)\\n\\n # Generate replicates\\n for i in range(size):\\n bs_inds = np.random.choice(inds,size=len(inds))\\n bs_x, bs_y = x[bs_inds],y[bs_inds]\\n bs_replicates[i] = func(bs_x,bs_y)\\n\\n return bs_replicates\",\n \"def n_random_resamples(*args, samples, n_repeats, \\n function=None, function_kwargs=None, bundle_args=True, \\n replace=True, with_dask=True):\\n\\n if with_dask & (n_repeats > 1000):\\n n_args = itertools.repeat(args[0], times=n_repeats)\\n b = db.from_sequence(n_args, npartitions=100)\\n rs_list = b.map(random_resample, *(args[1:]), \\n **{'samples':samples, 'function':function, \\n 'function_kwargs':function_kwargs, 'replace':replace}).compute()\\n else: \\n resample_ = dask.delayed(random_resample) if with_dask else random_resample\\n rs_list = [resample_(*args,\\n samples=samples,\\n function=function,\\n function_kwargs=function_kwargs,\\n bundle_args=bundle_args,\\n replace=replace) for _ in range(n_repeats)] \\n if with_dask:\\n rs_list = dask.compute(rs_list)[0]\\n \\n if all(isinstance(r, tuple) for r in rs_list):\\n return tuple([xr.concat([r.unify_chunks() for r in rs], dim='k') for rs in zip(*rs_list)])\\n else:\\n return xr.concat([r.unify_chunks() for r in rs_list], dim='k')\",\n \"def _sampling_concrete(self, args):\\n return sampling_concrete(args, (None, self.latent_disc_dim))\",\n \"def forward_sample(self, n):\\n return self.flow.sample(n)\",\n \"def sample(self, n, include=True):\\n return [self(t / n) for t in range(n + int(include))]\",\n \"def sample(self):\\n return self._sample_func\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def _handler_sample(self, *args, **kwargs):\\n next_state = None\\n timeout = time.time() + SAMPLE_TIMEOUT\\n\\n for i in self._units:\\n self._do_command(Command.READ, i)\\n\\n particles = self.wait_for_particles([DataParticleType.D1000_PARSED], timeout)\\n\\n return next_state, (next_state, particles)\",\n \"def sampling(n):\\n\\n def _sample(x):\\n if n > x.shape[0]:\\n # generate dups\\n count = n // x.shape[0] + 1\\n x = pd.concat([x] * count)\\n return x.sample(n=n)\\n else:\\n return x.sample(n=n)\\n\\n return _sample\",\n \"def mksampler(x):\\n if hasattr(x, \\\"__call__\\\"):\\n return x\\n elif type(x) is list:\\n # NB: disjoint ranges can be given as nested lists, e.g. [(1,2), (4,5)]\\n if len(x) == 2 and type(x[0]) in (int,float) and type(x[1]) in (int,float):\\n #print \\\"MKSAMPLER: Casting %s to UniformSampler\\\" % str(x)\\n return UniformSampler(*x)\\n elif len(x) > 2 or (len(x) > 0 and type(x[0]) not in (int,float)):\\n #print \\\"MKSAMPLER: Casting %s to DisjointUniformSampler\\\" % str(x)\\n return DisjointUniformSampler(x)\\n if len(x) < 2:\\n raise Exception(\\\"Supplied list could not be converted to a continuous sampler\\\")\\n elif type(x) is tuple:\\n #print \\\"MKSAMPLER: Casting %s to CyclicSeqSampler\\\" % str(x)\\n return CyclicSeqSampler(*x)\\n elif type(x) is set:\\n #print \\\"MKSAMPLER: Casting %s to RandomSeqSampler\\\" % str(x)\\n return RandomSeqSampler(*x)\\n else:\\n #print \\\"MKSAMPLER: Casting %s to ConstSampler\\\" % str(x)\\n return ConstSampler(x)\",\n \"def apply():\\r\\n result = dataSampling(str, \\\"hhhhhhahhhhhahhahahahahhahahha\\\", 5)\\r\\n final_res = dataScreening(result, \\\"ha\\\")\\r\\n print(final_res)\",\n \"def resample_filters(self):\\n a = len(self.filtered_ids)\\n b = len(self.orig_image_ids)\\n imbalance_ratio = a / b\\n min_ratio = 0.5\\n if imbalance_ratio > min_ratio:\\n return\\n minr = min_ratio\\n num_req = int((minr * b - a) / (1 - minr))\\n new_ids = ((num_req) // a) * self.filtered_ids\\n if num_req % a != 0:\\n some_more = random.sample(self.filtered_ids, k=(num_req % a))\\n new_ids += some_more\\n self.image_ids = self.orig_image_ids + new_ids\\n print(\\\"Resampled total:\\\", len(self.image_ids))\",\n \"def sample(draws, step_method, chain_state, sample_history ):\\n start = time.time()\\n for i in xrange(int(draws)):\\n chain_state = step_method.step(chain_state)\\n sample_history.record(chain_state, step_method)\\n \\n return (time.time() - start)\",\n \"def sample(self, size=1):\\n pass\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def build_sampler(self, params):\\n\\n def sampler(logits_1, logits_2, key):\\n q_kwargs = dict(transpose=True) if self.use_transpose else {}\\n x = self.model.bind(params).sample(logits_1, key)\\n y = self.model.bind(params).sample(logits_2, key, **q_kwargs)\\n return jnp.zeros([10, 10]).at[x, y].set(1.)\\n\\n return sampler\",\n \"def downsample_sam(self, factor):\",\n \"def samples(self, gp):\\r\\n raise NotImplementedError\",\n \"def sample(self,p0=None,nsamp=None): \\r\\n raise NotImplementedError('Need to implement sample function')\",\n \"def load_by_ids(load_x: callable, load_y: callable, ids: Sequence, shuffle: bool = False):\\n if shuffle:\\n ids = np.random.permutation(ids)\\n for patient_id in ids:\\n yield load_x(patient_id), load_y(patient_id)\",\n \"def mixrows(self, func=lambda a: random().scramble(a)):\\n self.a = func(self.a)\",\n \"def test_sampling2 () :\\n delta = 2 * np.pi / 3\\n r = Reward(partial(stepFunction, \\n xRange=(-delta/2, delta/2), \\n yRange=(-delta/2, delta/2)), \\n (-1, 0))\\n states = []\\n xs = np.arange(-np.pi, np.pi, delta)\\n ys = np.arange(-np.pi, np.pi, delta)\\n for x, y in product(xs, ys) : \\n states.append(\\n toExternalStateRep([x + delta / 2, y + delta / 2, 0, 0]).astype(float)\\n )\\n agent = findOptimalAgent(r)\\n vals = estimateValueFromAgent(states, agent, r)\\n for s, v in zip(states, vals) : \\n print(toInternalStateRep(s)[:2], v)\",\n \"def sample(self, count):\\n batch = deepcopy(random.sample(self.buffer, count))\\n batch = [np.array(arr) for arr in zip(*batch)]\\n\\n return batch\",\n \"def double_sampling(X_train, y_train, X_test, y_test, sampling_instances1, sampling_instances2, model_instances, func):\\n\\n list_of_df_metrics = []\\n\\n for sampling_instance1 in sampling_instances1:\\n print('First Round:')\\n if sampling_instance1 is not None:\\n print('fitting sampling of 1st round '+ str(sampling_instances1.index(sampling_instance1) + 1) + ' over ' + str(len(sampling_instances1)) + ': ' + type(sampling_instance1).__name__)\\n X_train_1st_round, y_train1st_round = sampling_instance1.fit_resample(X=X_train, y=y_train)\\n print('Second Round:')\\n else:\\n print('No 1st round Sampling methods applied')\\n X_train_1st_round, y_train1st_round = X_train, y_train\\n\\n df_metrics = sampling(X_train_1st_round, y_train1st_round, X_test, y_test, sampling_instances2, model_instances, func)\\n\\n list_of_df_metrics.append(df_metrics)\\n\\n df_metrics_all = pd.concat(list_of_df_metrics, keys=[type(x).__name__ for x in sampling_instances1], names=['First Sampling Round'])\\n\\n return df_metrics_all\",\n \"def uniform_sample(x):\\n return np.random.choice(x)\",\n \"def random_sampling(elements, n):\\r\\n import random\\r\\n return [random.choice(elements) for i in range(n)]\",\n \"def sample(self, n_samps):\\n # print('gauss trying to sample '+str(n_samps)+' from '+str(self.dist))\\n # xs = np.array([self.sample_one() for n in range(n_samps)])\\n xs = np.array(self.dist.sample(n_samps))\\n # print('gauss sampled '+str(n_samps)+' from '+str(self.dist))\\n return xs\",\n \"def sample_batch(memory, n):\\n batch = rnd.sample(memory, n) # List containing tuples\\n return batch\",\n \"def __call__(self, params):\\r\\n return self.sample(params)\",\n \"def next_sample(self, batch_size=1):\\n\\n X = []\\n y = []\\n for x in range(batch_size):\\n if self._random_state.rand() < 1/self.abrupt_drift_rate:\\n self.offset = self.offset + self._random_state.rand()\\n X.append(x + self._x_idx)\\n y.append(math.sin(self.offset + x/(2*math.pi*self.granularity))\\n + self._random_state.normal(scale=0.05) + self.cont)\\n\\n self._x_idx += batch_size\\n\\n return (X, y)\",\n \"def sample(read_sampler, n, array, res=1.0, prng = np.random.RandomState()):\\n for read in read_sampler.pull_reads(n, prng):\\n map_read(array, read, res)\",\n \"def sample(self, list_to_sample):\\n raise NotImplementedError\",\n \"def iid_sampling(dataset, num_users):\\n num_items = int(len(dataset) / num_users)\\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\\n for i in range(num_users):\\n dict_users[i] = set(np.random.choice(all_idxs, num_items,\\n replace=False))\\n all_idxs = list(set(all_idxs) - dict_users[i])\\n return dict_users\",\n \"def draw_perm_reps(data_1, data_2, func, size=1):\\n # Initialize array of replicates: perm_replicates\\n perm_replicates = np.empty(size)\\n for i in range(size):\\n perm_sample_1, perm_sample_2 = permutation_sample(data_1, data_2)\\n perm_replicates[i] = func(perm_sample_1, perm_sample_2)\\n return perm_replicates\",\n \"def _get_bootstrap_sample(x, y, num_reps):\\r\\n combined = array(list(x) + list(y))\\r\\n total_obs = len(combined)\\r\\n num_x = len(x)\\r\\n for i in range(num_reps):\\r\\n # sampling with replacement\\r\\n indices = randint(0, total_obs, total_obs)\\r\\n sampled = combined.take(indices)\\r\\n # split into the two populations\\r\\n sampled_x = sampled[:num_x]\\r\\n sampled_y = sampled[num_x:]\\r\\n yield sampled_x, sampled_y\",\n \"def sample(self):\\n return self._action_out(\\n [self.action_space.sample() for _ in range(self.batch_size)]\\n )\",\n \"def output_multiple(self) -> \\\"int\\\":\\n return _beamforming_swig.randomsampler_sptr_output_multiple(self)\",\n \"def __call__(self):\\n if self.numbatches is None:\\n pool = self.pooler()\\n if self.batchsize is None:\\n self.batchsize = self.pooler.nInPool()\\n self.numbatches = self.pooler.nInPool()//self.batchsize\\n for i in xrange(self.numbatches):\\n pool = self.pooler()\\n self._reset_batch()\\n if self.samplemethod == 'balance' and len(self.keysamplers)>0:\\n batchinds,keyids = self._samplebalanced(pool)\\n elif self.samplemethod == 'uniform':\\n batchinds,keyids = self._sampleuniform(pool)\\n else:\\n batchinds,keyids = self._samplesequential(i)\\n batch = self._extractInds(pool,batchinds,keyids)\\n for k in batch:\\n batch[k][np.isnan(batch[k])] = self.nanreplacement\\n yield batch\",\n \"def sample(self, nsamples):\\n return self.dist.sample(nsamples)\",\n \"def sample(self):\",\n \"def sample(self):\\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)\",\n \"def random_batch(self):\\n x = self._random_x()\\n y = self._random_x()\\n\\n return x, y, self.f(x, y)\",\n \"def sample_input_domain(num_samples):\\n s1 = np.random.random(num_samples) * 10\\n s2 = np.random.random(num_samples) * 2 - 5\\n s3 = np.random.random(num_samples)\\n s4 = np.random.random(num_samples) * 30 + 20\\n return s1, s2, s3, s4\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def sample(self, size=1):\\n raise NotImplementedError\",\n \"def sample(self, batch_size):\\n raise NotImplementedError\",\n \"def gen_arms_per_batch(\\n self,\\n ) -> Tuple[torch.Tensor, torch.Tensor]:\\n sample_batch_idx = random.randint(0, self.num_unique_batches - 1)\\n arms_ids_batch = self.all_unique_arm_ids[sample_batch_idx]\\n return sample_batch_idx, arms_ids_batch\",\n \"def sample(self, i):\\n\\t\\tif self.nsamp % 2 == 0:\\n\\t\\t\\ti0 = i-(self.nsamp/2-1)\\n\\t\\t\\ti1 = i+(self.nsamp/2)\\n\\t\\telse:\\n\\t\\t\\ti0 = i-((self.nsamp-1)/2.)\\n\\t\\t\\ti1 = i+((self.nsamp-1)/2.)\\n\\t\\treturn self.yval[i0:i1]\",\n \"def split(self, args):\\n non_integer_count = sum(not arg.is_Integer for arg in args)\\n assert non_integer_count <= self.count - 1\\n count_split = combinatorics.uniform_non_negative_integers_with_sum(\\n len(args), (self.count - 1) - non_integer_count)\\n for i, arg in enumerate(args):\\n if not arg.is_Integer:\\n count_split[i] += 1\\n if all(count == 0 for count in count_split):\\n assert self.entropy == 0\\n entropies = np.zeros(len(count_split))\\n else:\\n entropies = (\\n np.random.dirichlet(np.maximum(1e-9, count_split)) * self.entropy)\\n return [_SampleArgs(op_count, entropy)\\n for op_count, entropy in zip(count_split, entropies)]\",\n \"def data_feeder_2():\\n return random.sample(range(100), 10)\",\n \"def initial_sampling(y):\\n samples = list(np.random.randint(0, len(y), 2))\\n while len(np.unique(y[samples] > 0.5)) != 2:\\n samples = list(np.random.randint(0, len(y), 2))\\n return samples\",\n \"def draw_bootstrap_pairs(x, y, func, size=1):\\n\\n # Set up array of indices to sample from: inds\\n inds = np.arange(len(x))\\n\\n # Initialize replicates: bs_replicates\\n bs_replicates = np.empty(size)\\n\\n # Generate replicates\\n for i in range(size):\\n bs_inds = np.random.choice(inds, len(inds))\\n bs_x, bs_y = x[bs_inds], y[bs_inds]\\n bs_replicates[i] = func(bs_x, bs_y)\\n\\n return bs_replicates\",\n \"def sample(self, seg_logit, seg_label):\",\n \"def subsample(inputs, factor, scope=None):\\n if factor == 1:\\n return inputs\\n else:\\n return slim.max_pool2d(inputs, [1, 1], stride=factor, scope=scope)\",\n \"def nonblocking_sample_method(f):\\n from dimod.sampleset import SampleSet # avoid circular import\\n\\n @wraps(f)\\n def _sample(*args, **kwargs):\\n iterator = f(*args, **kwargs)\\n\\n # resolve blocking part now, and make hook for the non-blocking part\\n return SampleSet.from_future(next(iterator), lambda _: next(iterator))\\n return _sample\",\n \"def next_sample(self, batch_size=1):\\n\\n X = []\\n y = []\\n self.cont = 2.\\n for x in range(batch_size):\\n if x > batch_size/2 and self.cont == 2:\\n self.cont = 5.*np.random.rand()\\n if self._random_state.rand() < 1/self.abrupt_drift_rate:\\n #self.offset += 1\\n pass\\n y.append(self.offset + (x*self.cont)/self.granularity + self._random_state.normal(scale=1))\\n X.append(float(x))\\n self._x_idx += batch_size\\n zipped = list(zip(X, y))\\n if self.shuffleData:\\n shuffle(zipped)\\n \\n\\n return ([float(zipped[i][0]) for i in range(len(X))], [float(zipped[i][1]) for i in range(len(X))])\",\n \"def get_random_samplers(self, n):\\n if not self.has_samplers():\\n self.draw_samplers()\\n \\n def get_shuffledcopy(x):\\n x_ = x.copy()\\n np.random.shuffle(x_)\\n return x_\\n \\n return get_shuffledcopy(self.samplers)[:n]\",\n \"def sampler_to_iterator(dataset, sampler):\\n for sample in sampler:\\n if isinstance(sample, (list, tuple)):\\n # yield a batch\\n yield [dataset[i] for i in sample]\\n else:\\n # yield a single example\\n yield dataset[sample]\",\n \"def compose_sample(lfads_hps, ib_k, ic_j, ii_txi):\\n ii_ti = np.reshape(ii_txi, (-1,))\\n return np.concatenate([ib_k, ic_j, ii_ti], axis=0)\",\n \"def sample(self, length):\\n pass\",\n \"def _sample_synthetic(self, X):\\n n_samples = X.shape[0]\\n self.y = np.concatenate((np.ones(n_samples), np.zeros(n_samples)))\\n \\n random_state = _forest.check_random_state(self.random_state) \\n\\n X_synth = np.asarray([np.apply_along_axis(random_state.choice, 0, X) for _ in range(n_samples)])\\n self.X = np.concatenate((X, X_synth))\\n\\n return self.X, self.y\",\n \"def bs_replicate(data, func=np.mean):\\n bs_sample = np.random.choice(data, replace=True, size=len(data))\\n return func(bs_sample)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6780334","0.6380335","0.5978483","0.59762675","0.5962528","0.5962528","0.59488493","0.58723915","0.5839884","0.5820229","0.5768919","0.5750288","0.5728591","0.57276875","0.5725391","0.57026887","0.5686771","0.5677376","0.56756586","0.5674957","0.5672077","0.5666422","0.5638749","0.56366074","0.5619334","0.55901","0.55880785","0.55842245","0.55810356","0.5579495","0.5575602","0.5568534","0.55429876","0.5539835","0.5538324","0.55323946","0.5530796","0.55298615","0.55143696","0.55034167","0.5500204","0.54793423","0.5473486","0.5473248","0.54661316","0.5465791","0.5454317","0.5452285","0.544268","0.54425997","0.54425997","0.5442456","0.5429637","0.5428007","0.5424249","0.5414884","0.5407101","0.53918403","0.538522","0.5381295","0.5380069","0.5374194","0.53679466","0.53645635","0.5363794","0.5344478","0.53441185","0.53424454","0.5338585","0.5312355","0.5309634","0.53048885","0.5302677","0.5300906","0.52904254","0.52871823","0.5282344","0.5280801","0.52730167","0.52729386","0.52729386","0.52729386","0.52729386","0.52690744","0.5268995","0.5265407","0.5260431","0.52587503","0.5258364","0.5257403","0.5244287","0.5241622","0.5231988","0.5227224","0.5220882","0.5218505","0.5216995","0.5215757","0.5215396","0.5213534"],"string":"[\n \"0.6780334\",\n \"0.6380335\",\n \"0.5978483\",\n \"0.59762675\",\n \"0.5962528\",\n \"0.5962528\",\n \"0.59488493\",\n \"0.58723915\",\n \"0.5839884\",\n \"0.5820229\",\n \"0.5768919\",\n \"0.5750288\",\n \"0.5728591\",\n \"0.57276875\",\n \"0.5725391\",\n \"0.57026887\",\n \"0.5686771\",\n \"0.5677376\",\n \"0.56756586\",\n \"0.5674957\",\n \"0.5672077\",\n \"0.5666422\",\n \"0.5638749\",\n \"0.56366074\",\n \"0.5619334\",\n \"0.55901\",\n \"0.55880785\",\n \"0.55842245\",\n \"0.55810356\",\n \"0.5579495\",\n \"0.5575602\",\n \"0.5568534\",\n \"0.55429876\",\n \"0.5539835\",\n \"0.5538324\",\n \"0.55323946\",\n \"0.5530796\",\n \"0.55298615\",\n \"0.55143696\",\n \"0.55034167\",\n \"0.5500204\",\n \"0.54793423\",\n \"0.5473486\",\n \"0.5473248\",\n \"0.54661316\",\n \"0.5465791\",\n \"0.5454317\",\n \"0.5452285\",\n \"0.544268\",\n \"0.54425997\",\n \"0.54425997\",\n \"0.5442456\",\n \"0.5429637\",\n \"0.5428007\",\n \"0.5424249\",\n \"0.5414884\",\n \"0.5407101\",\n \"0.53918403\",\n \"0.538522\",\n \"0.5381295\",\n \"0.5380069\",\n \"0.5374194\",\n \"0.53679466\",\n \"0.53645635\",\n \"0.5363794\",\n \"0.5344478\",\n \"0.53441185\",\n \"0.53424454\",\n \"0.5338585\",\n \"0.5312355\",\n \"0.5309634\",\n \"0.53048885\",\n \"0.5302677\",\n \"0.5300906\",\n \"0.52904254\",\n \"0.52871823\",\n \"0.5282344\",\n \"0.5280801\",\n \"0.52730167\",\n \"0.52729386\",\n \"0.52729386\",\n \"0.52729386\",\n \"0.52729386\",\n \"0.52690744\",\n \"0.5268995\",\n \"0.5265407\",\n \"0.5260431\",\n \"0.52587503\",\n \"0.5258364\",\n \"0.5257403\",\n \"0.5244287\",\n \"0.5241622\",\n \"0.5231988\",\n \"0.5227224\",\n \"0.5220882\",\n \"0.5218505\",\n \"0.5216995\",\n \"0.5215757\",\n \"0.5215396\",\n \"0.5213534\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6582716"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":90592,"cells":{"query":{"kind":"string","value":"Draws iid samples from `fn`."},"document":{"kind":"string","value":"def iid_sample_fn(*args, **kwargs):\n\n with tf.name_scope('iid_sample_fn'):\n\n seed = kwargs.pop('seed', None)\n if samplers.is_stateful_seed(seed):\n kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())\n def pfor_loop_body(_):\n with tf.name_scope('iid_sample_fn_stateful_body'):\n return sample_fn(*args, **kwargs)\n else:\n # If a stateless seed arg is passed, split it into `n` different\n # stateless seeds, so that we don't just get a bunch of copies of the\n # same sample.\n if not JAX_MODE:\n warnings.warn(\n 'Saw Tensor seed {}, implying stateless sampling. Autovectorized '\n 'functions that use stateless sampling may be quite slow because '\n 'the current implementation falls back to an explicit loop. This '\n 'will be fixed in the future. For now, you will likely see '\n 'better performance from stateful sampling, which you can invoke '\n 'by passing a Python `int` seed.'.format(seed))\n seed = samplers.split_seed(seed, n=n, salt='iid_sample_stateless')\n def pfor_loop_body(i):\n with tf.name_scope('iid_sample_fn_stateless_body'):\n return sample_fn(*args, seed=tf.gather(seed, i), **kwargs)\n\n if static_n == 1:\n draws = pfor_loop_body(0)\n else:\n draws = parallel_for.pfor(pfor_loop_body, n)\n return tf.nest.map_structure(unflatten, draws, expand_composites=True)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iid_sample(sample_fn, sample_shape):\n sample_shape = distribution_util.expand_to_vector(\n ps.cast(sample_shape, np.int32), tensor_name='sample_shape')\n n = ps.cast(ps.reduce_prod(sample_shape), dtype=np.int32)\n static_n = tf.get_static_value(tf.convert_to_tensor(n))\n\n def unflatten(x):\n sample_dims = 0 if static_n == 1 else 1\n unflattened_shape = ps.cast(\n ps.concat([sample_shape, ps.shape(x)[sample_dims:]], axis=0),\n dtype=np.int32)\n return tf.reshape(x, unflattened_shape)\n\n def iid_sample_fn(*args, **kwargs):\n \"\"\"Draws iid samples from `fn`.\"\"\"\n\n with tf.name_scope('iid_sample_fn'):\n\n seed = kwargs.pop('seed', None)\n if samplers.is_stateful_seed(seed):\n kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())\n def pfor_loop_body(_):\n with tf.name_scope('iid_sample_fn_stateful_body'):\n return sample_fn(*args, **kwargs)\n else:\n # If a stateless seed arg is passed, split it into `n` different\n # stateless seeds, so that we don't just get a bunch of copies of the\n # same sample.\n if not JAX_MODE:\n warnings.warn(\n 'Saw Tensor seed {}, implying stateless sampling. Autovectorized '\n 'functions that use stateless sampling may be quite slow because '\n 'the current implementation falls back to an explicit loop. This '\n 'will be fixed in the future. For now, you will likely see '\n 'better performance from stateful sampling, which you can invoke '\n 'by passing a Python `int` seed.'.format(seed))\n seed = samplers.split_seed(seed, n=n, salt='iid_sample_stateless')\n def pfor_loop_body(i):\n with tf.name_scope('iid_sample_fn_stateless_body'):\n return sample_fn(*args, seed=tf.gather(seed, i), **kwargs)\n\n if static_n == 1:\n draws = pfor_loop_body(0)\n else:\n draws = parallel_for.pfor(pfor_loop_body, n)\n return tf.nest.map_structure(unflatten, draws, expand_composites=True)\n\n return iid_sample_fn","def draw(function):\n def f(**kwargs):\n rand = random.random()\n x = function(**kwargs)\n return int(rand < x)\n return f","def apply():\r\n result = dataSampling(str, \"hhhhhhahhhhhahhahahahahhahahha\", 5)\r\n final_res = dataScreening(result, \"ha\")\r\n print(final_res)","def clean_line_generator_v2(df_pkl=None, fn='untitled'):","def visualize_attention(test_seq,\n model,\n id2wrd,\n n):\n\n get_layer_output = K.function([model.layers[0].input, K.learning_phase()], [model.layers[4].output])\n out = get_layer_output([test_seq, ])[0] # test mode\n\n att_w = model.layers[5].get_weights()\n\n eij = np.tanh(np.dot(out[0], att_w[0]))\n ai = np.exp(eij)\n weights = ai/np.sum(ai)\n weights = np.sum(weights,axis=1)\n\n topKeys = np.argpartition(weights,-n)[-n:]\n\n print(' '.join([id2wrd[wrd_id] for wrd_id in test_seq[0] if wrd_id != 0.])) \n \n for k in test_seq[0][topKeys]:\n if k != 0.:\n print(id2wrd[k])\n \n return","def id2ind(ngrid,nspecies,filename):\n ntot=ngrid[0]*ngrid[1]*ngrid[2]*nspecies\n np_icell=np.empty((3,ntot),dtype=np.intc)\n np_ispecies=np.empty(ntot,dtype=np.intc)\n icell=np_icell\n ispecies=np_ispecies\n \n f=StringIO.StringIO()\n\n for ii in xrange(ntot):\n tmp,ispecies[ii]=divmod(ii,nspecies)\n tmp,icell[0,ii]=divmod(tmp,ngrid[0])\n icell[2,ii],icell[1,ii]=divmod(tmp,ngrid[1])\n jj=(icell[0,ii]+1)*(icell[1,ii]+1)*(icell[2,ii]+1)\n f.write(\"{:>6d} {:>6d} {:>6d}\\n\".format(ii+1,(ii+nspecies)//nspecies,ispecies[ii]))\n ffinal=open(filename,\"w\")\n ffinal.write(f.getvalue())\n f.close()\n ffinal.close()","def fn():","def seq_idty():\n\n # load distance matrices\n fams_to_plot = [ f for f in famlist if f not in ignored ]\n fam_arrays = []\n for f in fams_to_plot:\n if path.isfile(\"data/\"+f+\".npy\"):\n fam_arrays.append(np.load(\"data/\"+f+\".npy\") / 100.0) # normalize percentages in [0,1]\n else:\n warn(\"data/\"+f+\".npy not found !\")\n fam_arrays.append(np.array([]))\n\n # Update database with identity percentages\n conn = sqlite3.connect(runDir + \"/results/RNANet.db\")\n conn.execute('pragma journal_mode=wal')\n for f, D in zip(fams_to_plot, fam_arrays):\n if not len(D): continue\n if D.shape[0] > 1:\n a = np.sum(D) * 2 / D.shape[0] / (D.shape[0] - 1) # SUM(D) / (n(n-1)/2)\n else:\n a = D[0][0]\n conn.execute(f\"UPDATE family SET idty_percent = {round(float(a),2)} WHERE rfam_acc = '{f}';\")\n conn.commit()\n conn.close()\n\n # Plots plots plots\n fig, axs = plt.subplots(4,17, figsize=(17,5.75))\n axs = axs.ravel()\n [axi.set_axis_off() for axi in axs]\n im = \"\" # Just to declare the variable, it will be set in the loop\n for f, D, ax in zip(fams_to_plot, fam_arrays, axs):\n D = D + D.T # Copy the lower triangle to upper, to get a symetrical matrix\n if D.shape[0] > 2: # Cluster only if there is more than 2 sequences to organize\n D = 1.0 - D\n np.fill_diagonal(D, 0.0)\n condensedD = squareform(D)\n\n # Compute basic dendrogram by Ward's method\n Y = sch.linkage(condensedD, method='ward')\n Z = sch.dendrogram(Y, orientation='left', no_plot=True)\n\n # Reorganize rows and cols\n idx1 = Z['leaves']\n D = D[idx1[::-1],:]\n D = D[:,idx1[::-1]]\n D = 1.0 - D\n elif D.shape[0] == 2:\n np.fill_diagonal(D, 1.0) # the diagonal has been ignored until now\n ax.text(np.floor(D.shape[0]/2.0)-(0.5 if not D.shape[0]%2 else 0), -0.5, f + \"\\n(\" + str(D.shape[0]) + \" chains)\", \n fontsize=9, horizontalalignment = 'center', verticalalignment='bottom')\n im = ax.matshow(D, vmin=0, vmax=1)\n\n fig.tight_layout()\n fig.subplots_adjust(hspace=0.3, wspace=0.1)\n fig.colorbar(im, ax=axs[-4], shrink=0.8)\n fig.savefig(runDir + f\"/results/figures/distances_{res_thr}.png\")\n print(\"> Computed all identity matrices and saved the figure.\", flush=True)","def dev_sample_generator(self, fi):\n for line in fi:\n line_list = line.split(\" \")\n label = int(line_list[-1])\n sequence = np.array(line_list[:-1], dtype=np.intp)\n yield sequence, sequence.shape[0], np.unique(sequence).shape[0], label","def gen_feats_file(data_feats,ids,feat_filename):\n if not os.path.isfile(feat_filename) :\n new_feats=np.empty((0,2))\n for iid in ids:\n print(iid)\n indices = [i for i, v in enumerate(data_feats[:,0]) if iid in v]\n new_feats=np.vstack((new_feats,data_feats[indices,:]))\n np.savetxt(feat_filename,new_feats,fmt=\"%s\")","def sample(f, n):\n entries = list(SeqIO.parse(f, 'fasta'))\n for seqnum in range(n):\n loc = round(random.uniform(0, len(entries) - 1))\n entry = entries[loc] # get index of randomly-selected FASTA entry\n header = '>' + str(seqnum + 1) + '-' + entry.description # header\n print(header + '\\n' + str(entry.seq)) # print-out entire entry","def drawOnImg(file1, imgBW, chosenDis,iteration):\n nP, IDrange = upDate(iteration)\n chosenContour = []\n x, y, w, h = cv2.boundingRect(shapesContours[len(chosenDis) - 1])\n cv2.rectangle(imgBW, (x - nP, y - nP), (x + w + nP, y + h + nP), (128, 0, 128), 4)\n chosenContour.append(shapesContours[len(chosenDis) - 1])\n file1.write(str(chosenDis[len(chosenDis) - 1]) + \" **\\n\")\n print(chosenDis[len(chosenDis) - 1], \"**\")\n\n file1.write(str(chosenDis[len(chosenDis) - 1]) + '\\n')\n print(chosenDis[len(chosenDis) - 1])","def f5(seq, idfun=None):\n if idfun is None:\n def idfun(x):\n return x\n\n seen = {}\n result = []\n for item in seq:\n marker = idfun(item)\n if marker in seen:\n continue\n seen[marker] = 1\n result.append(item)\n return result","def input_fn(params):\n print(params)\n batch_size = 500\n\n num_examples = len(features)\n\n d = tf.data.Dataset.from_tensor_slices({\n \"input_ids\":\n tf.constant(\n all_input_ids, shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"input_mask\":\n tf.constant(\n all_input_mask,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"segment_ids\":\n tf.constant(\n all_segment_ids,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"label_ids\":\n tf.constant(all_label_ids, shape=[num_examples], dtype=tf.int32),\n })\n\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\n return d","def sample(self, seg_logit, seg_label):","def draw_elem_numbers(n):\n return drawNumbers(named(n))","def fiducial_snapshots(Nsnap=5):\n \n times = np.linspace(0,0.5,Nsnap)\n \n for t in times:\n generate_fiducial(time=t)","def get_sample_ids(maptable):\n return [line[0] for line in maptable[1:]]","def draw_stratas(enum_func):\n maximum_strata_index = 7\n graph = ot.Graph(\"\", \"$\\\\alpha_1$\", \"$\\\\alpha_2$\", True)\n if enum_func.__class__.__name__ == \"LinearEnumerateFunction\":\n graph.setTitle(\"Linear enumeration rule\")\n elif enum_func.__class__.__name__ == \"HyperbolicAnisotropicEnumerateFunction\":\n graph.setTitle(f\"q={enum_func.getQ()}\")\n offset = 0\n for strata_index in range(maximum_strata_index):\n strata_cardinal = enum_func.getStrataCardinal(strata_index)\n sample_in_layer = [enum_func(idx + offset) for idx in range(strata_cardinal)]\n offset += strata_cardinal\n cloud = ot.Cloud(sample_in_layer)\n cloud.setLegend(str(strata_index))\n cloud.setPointStyle(\"circle\")\n graph.add(cloud)\n palette = ot.DrawableImplementation.BuildDefaultPalette(maximum_strata_index)\n graph.setColors(palette)\n graph.setIntegerXTick(True)\n graph.setIntegerYTick(True)\n graph.setLegendPosition(\"topright\")\n return graph","def _create_fake_dataset(output_path, seq_length, include_sentence_id):\n writer = tf.io.TFRecordWriter(output_path)\n\n def create_int_feature(values):\n f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))\n return f\n\n for i in range(100):\n features = {}\n input_ids = np.random.randint(100, size=(seq_length))\n features['input_ids'] = create_int_feature(input_ids)\n features['input_mask'] = create_int_feature(np.ones_like(input_ids))\n features['segment_ids'] = create_int_feature(np.ones_like(input_ids))\n features['label_ids'] = create_int_feature(\n np.random.randint(10, size=(seq_length)))\n if include_sentence_id:\n features['sentence_id'] = create_int_feature([i])\n features['sub_sentence_id'] = create_int_feature([0])\n\n tf_example = tf.train.Example(features=tf.train.Features(feature=features))\n writer.write(tf_example.SerializeToString())\n writer.close()","def sample(self,f,N,p=100):\n return [f(x) for x in np.linspace(0,N,p)]","def _pds_plot_iterator(pds, dim, funcId):\n i = 0\n for (algname, ds) in pds.algds_dimfunc((dim, funcId)):\n yield ('algorithm', algname, ds, _style_algorithm(algname, i))\n i += 1\n yield ('oracle', 'oracle', pds.oracle((dim, funcId)), _style_oracle())\n yield ('unifpf', 'eUNIF', pds.unifpf().dictByDimFunc()[dim][funcId][0], _style_unifpf())\n i = 0\n for (stratname, ds) in pds.stratds_dimfunc((dim, funcId)):\n yield ('strategy', stratname, ds, _style_strategy(stratname, i))\n i += 1","def process(dataset, f):\n logger.info('processing dataset ({0})'.format(len(dataset.samples)))\n for sample in dataset.samples:\n sample.proc = f(sample.image)","def test_draw_two(self):\n f = txn_oracle.draw_two\n\n for _ in range(1000):\n max_n = random.randint(4, 20)\n i, j = f(max_n)\n assert i != j","def generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def generate_in(self, n_samples, start_sample=0):\n pass","def gen_ind_params(self, x, hist_cr, hist_f):\n mi = self.integers(self.hist_mem_size) # a random pair of f cr is selected form historical memory\n m_cr = hist_cr[mi]\n m_f = hist_f[mi]\n cr = self.normal(m_cr, 0.1) if m_cr != -1 else 0\n # cr is randomised from normal distribution and then repaired if needed\n cr = np.clip(cr, 0, 1)\n f = self.cauchy(m_f, 0.1)\n # f is randomised from cauchy distribution until the value is >0 and then repaired if needed\n f = np.clip(f, 0, 1)\n return self.individual_type(x=x.x, differential_weight=f, crossover_probability=cr, e=False)","def make_art(functions, filename, lambdas, x_size=def_x_size, y_size=def_y_size):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (color_map(evaluate_random_function(functions[0], x, y, lambdas)),\n color_map(evaluate_random_function(functions[1], x, y, lambdas)),\n color_map(evaluate_random_function(functions[2], x, y, lambdas)))\n im.save(filename+\".png\")","def count_and_draw(fileinfos, args, name=\"\"):\n els_counted = count_items(fileinfos,\"el\",name)\n atts_counted = count_items(fileinfos,\"att\",name)\n draw_figure(els_counted, atts_counted, args, name)","def idensity(n):\n I = zeroes(n, n)\n for i in range(n):\n I.g[i][i] = 1.0\n return I","def plot_sample_imgs(get_imgs_fun, img_shape, plot_side=5, savepath=None, cmap='gray'):\n f, axarr = plt.subplots(plot_side, plot_side)\n samples = get_imgs_fun(plot_side*plot_side)\n for row in range(plot_side):\n for col in range(plot_side):\n axarr[row, col].imshow(samples[plot_side*row+col].reshape(img_shape), cmap=cmap)\n axarr[row, col].set_title('')\n axarr[row, col].axis('off')\n if savepath:\n f.savefig(savepath)\n plt.close()\n else:\n plt.show()","def skim(lines, file):\n for line in skim_generator(lines, file):\n sys.stdout.write(line)","def plot_obs_noise_dist(obs_fn, obs_noise, min_dist=0, max_dist=10):\n x = np.linspace(min_dist, max_dist, 100)\n y = [obs_fn(xi) for xi in x]\n plt.plot(x, y)\n plt.xlabel(\"Distance\")\n plt.ylabel(\"Probability\")\n plt.xlim((min_dist, max_dist))\n plt.ylim((0, 1))\n plt.axvline(x=obs_noise, color='red', alpha=0.7)\n plt.annotate(\"Observation noise stddev\", xy=(obs_noise, 0))","def drawSamples(self, numberOfSamples, from_where=\"image\"):\n\n #drawing n random numbers between 0 and 1\n randomVector = np.random.random(int(numberOfSamples))\n\n #creating the CDF function by linearizing and normalizing the image\n CDF = np.cumsum(self.blurred_image)/np.sum(self.blurred_image)\n\n #sample the CDF function\n Indexes1D = np.searchsorted(CDF, randomVector)\n Indexes2D = np.unravel_index(Indexes1D, self.blurred_image.shape)\n\n sampledPDF = np.zeros(self.blurred_image.shape)\n\n Indexes2D = list(zip(Indexes2D[0], Indexes2D[1]))\n for (Idx, Idy) in Indexes2D:\n sampledPDF[Idx, Idy] += 1\n\n return sampledPDF, Indexes2D","def visualize_attention(test_seq, i,\n model,\n id2wrd, # word_index.\n n):\n \n id2wrd = dict((v, k) for k, v in id2wrd.items()) # Exchange key with values.\n\n get_layer_output = K.function([model.layers[0].input, K.learning_phase()], [model.layers[4].output])\n out = get_layer_output([test_seq, ])[0] # test mode\n\n att_w = model.layers[5].get_weights() # The attention layer is the sixth layer.\n\n eij = np.tanh(np.dot(out[i], att_w[0]))\n# print(\"1 eij is ............\")\n# print(eij)\n ListToCSV(eij, 'eij.csv') # added by Shigang\n ai = np.exp(eij)\n# print(\"1 ai is ............\")\n# print(ai)\n ListToCSV(ai, 'ai.csv') # added by Shigang\n weights = ai/np.sum(ai)\n# print(\"1 weights is ............\")\n# print(weights)\n ListToCSV(weights, '1weights.csv') # added by Shigang\n weights = np.sum(weights,axis=1)\n# print(\"2 weights is ............\")\n# print(weights)\n ListToCSV(weights, '2weights.csv') # added by Shigang\n topKeys = np.argpartition(weights,-n)[-n:]\n\n print (' '.join([id2wrd[wrd_id] for wrd_id in test_seq[i] if wrd_id != 0.]))\n print ('--------------------------Attentive Words start: --------------------------------------')\n \n for k in test_seq[i][topKeys]:\n if k != 0.:\n print (id2wrd[k])\n print ('--------------------------Attentive Words end: --------------------------------------')\n \n return","def batch_process(minID, maxID, side='blue', **kwargs):\r\n\r\n if side == 'both':\r\n sides = ['blue','red']\r\n else:\r\n sides = [side]\r\n for side in sides:\r\n for i in range(minID, maxID+1, 1):\r\n filename = '%s%04d.fits' % (side, i)\r\n if os.path.exists(filename):\r\n try:\r\n extract1D(i, side=side, **kwargs)\r\n except iraf.IrafError:\r\n # some errors just require you to try again...\r\n print 'Hit error, retrying...'\r\n extract1D(i, side=side, **kwargs)","def GenId(self, func=None, *param):\n\tcurrent_count = 0\n\told_time = self.GenerateTime()\n\twhile True:\t\n\t current_count += 1\n\t if self.GenerateTime() != old_time:\n\t\tcurrent_count = 0\n\t old_time = self.GenerateTime()\n\t CurrentId = format(current_count, 11)\n\t #id = str(int(self.GenerateTime(), 2) + int(self.GenDistinctId(), 2) + int(CurrentId, 2))\n\t id = str(int(self.GenerateTime(), 2)) + str(int(self.GenDistinctId(), 2)) + str(int(CurrentId, 2))\n\t yield(func(id, *param))","def repeat(fn):\n def repeated():\n i = 0\n while i < random_test_iterations:\n fn()\n i += 1\n # nosetest runs functions that start with 'test_'\n repeated.__name__ = fn.__name__\n return repeated","def testing_input_fn():\n dataset = tf.data.Dataset.range(len(cube_features))\n dataset = dataset.batch(16)\n dataset = dataset.map(mapping_function)\n return dataset","def function_uuid():\r\n yield uuid.uuid4()","def input_fn_builder(features, seq_length):\n\n all_label_ids = []\n all_input_ids = []\n all_input_mask = []\n all_segment_ids = []\n\n for feature in features:\n all_label_ids.append(feature.label_ids)\n all_input_ids.append(feature.input_ids)\n all_input_mask.append(feature.input_mask)\n all_segment_ids.append(feature.segment_ids)\n\n def input_fn(params):\n \"\"\"The actual input function.\"\"\"\n batch_size = params[\"batch_size\"]\n\n num_examples = len(features)\n\n # This is for demo purposes and does NOT scale to large data sets. We do\n # not use Dataset.from_generator() because that uses tf.py_func which is\n # not TPU compatible. The right way to load data is with TFRecordReader.\n d = tf.data.Dataset.from_tensor_slices(\n {\n \"label_ids\": tf.constant(\n all_label_ids, shape=[num_examples], dtype=tf.int32\n ),\n \"input_ids\": tf.constant(\n all_input_ids, shape=[num_examples, seq_length], dtype=tf.int32\n ),\n \"input_mask\": tf.constant(\n all_input_mask, shape=[num_examples, seq_length], dtype=tf.int32\n ),\n \"segment_ids\": tf.constant(\n all_segment_ids, shape=[num_examples, seq_length], dtype=tf.int32\n ),\n }\n )\n\n d = d.batch(batch_size=batch_size, drop_remainder=False)\n return d\n\n return input_fn","def draw_bs_pairs(x, y, func, size=1):\n\n # Set up array of indices to sample from: inds\n inds = np.arange(len(x))\n\n # Initialize replicates: bs_replicates\n bs_replicates = np.empty(size)\n\n # Generate replicates\n for i in range(size):\n bs_inds = np.random.choice(inds,size=len(inds))\n bs_x, bs_y = x[bs_inds],y[bs_inds]\n bs_replicates[i] = func(bs_x,bs_y)\n\n return bs_replicates","def example_generator(self, mode: str):\n raise NotImplementedError","def generate_identifiers(training_file):\r\n with open('identifiers.csv', mode='r') as identifier_file, open('new_identifiers.csv', mode='w', newline='') as new_identifier_file:\r\n reader = csv.reader(identifier_file, delimiter=',')\r\n for row in reader:\r\n show = row[0]\r\n\r\n # generate a corpus for only the desired show\r\n dataset = generate_corpus(show, training_file)\r\n\r\n dct = Dictionary(dataset)\r\n\r\n # Create a tfidf model to evaluate word rank\r\n corpus = [dct.doc2bow(line) for line in dataset]\r\n tfidf_model = TfidfModel(corpus)\r\n\r\n tfidf_freq = {}\r\n for doc in tfidf_model[corpus]:\r\n for id, freq in doc:\r\n tfidf_freq[dct[id]] = freq\r\n \r\n tfidf_freq = sorted(tfidf_freq.items(), key=lambda x: x[1], reverse=True)\r\n\r\n for word, freq in tfidf_freq[:500]:\r\n print('%s, %s' % (word, freq), end='\\n')\r\n\r\n writer = csv.writer(new_identifier_file, delimiter=',')\r\n keywords = []\r\n for word, freq in tfidf_freq[:10]:\r\n keywords.append(word)\r\n writer.writerow([show, \";\".join(keywords)])","def test_plot_insertion_indices(mock_plot, sampler, filename):\n nlive = 10\n indices = list(range(20))\n sampler.nlive = nlive\n sampler.insertion_indices = indices\n fig = NestedSampler.plot_insertion_indices(\n sampler, filename=filename, k=True\n )\n assert fig == \"fig\"\n mock_plot.assert_called_once_with(\n indices, nlive, filename=filename, k=True\n )","def create_input(ids):\n\n df = ids.copy()\n df = create_dataframes_with_features(df)\n lines = to_vwlines(df)\n\n # release memory\n df = None \n gc.collect()\n return lines","def plot_sample_imgs(get_imgs_fun, img_shape, plot_side=5, savepath=None):\n f, axarr = plt.subplots(plot_side, plot_side)\n samples = get_imgs_fun(plot_side*plot_side)\n for row in range(plot_side):\n for col in range(plot_side):\n axarr[row, col].imshow(samples[plot_side*row+col].reshape(img_shape))\n axarr[row, col].set_title('')\n axarr[row, col].axis('off')\n if savepath:\n f.savefig(savepath)\n plt.close()\n else:\n plt.show()","def draw_250():\r\n red = 0\r\n grn = 0\r\n arr = urn_setup()\r\n for v in range(250):\r\n n = np.random.randint(0,len(arr))\r\n x, arr = draw_remove_element(arr, np.random.randint(0,len(arr)))\r\n if x == 'R':\r\n red += 1\r\n elif x == 'G':\r\n grn += 1\r\n print(\"Red: %d :: Grn: %d\" % (red, grn))\r\n return red, grn","def draw():","def generate_synth_data(n):","def map_ids(x, indices, map_fn):\n indices = tf.reshape(indices, [-1])\n\n t_i = tf.constant(0)\n # batch_coordinates start at 0\n t_batch_size = tf.reduce_max(indices) + 1\n\n # ta_stack_out will store the intermediate results for each individual id\n # As alternative to tf.TensorArray, scatter_update could potentially be used\n # but that would require an additional mutable tensor.\n ta_stack_out = tf.TensorArray(\n x.dtype,\n size=t_batch_size,\n )\n\n # Then we iterate over each sequence individually and compute the\n # transformation for each id\n while_condition = lambda t_i, *args: tf.less(t_i, t_batch_size)\n\n def body(t_i, ta_stack_out):\n \"\"\"Loop body.\"\"\"\n # Gather the ids\n current_ids = tf.to_int32(tf.where(tf.equal(indices, t_i)))\n t_row = tf.gather_nd(x, indices=current_ids)\n\n # TODO(epot): Should not call map_fn if t_row size is 0\n\n # Apply transformation to each id\n # Restore batch_dim=1 as most function expect [batch_dim, length, ...] as\n # input\n t_row = tf.expand_dims(t_row, axis=0)\n t_row = map_fn(t_row)\n t_row = tf.squeeze(t_row, axis=0) # Squeeze for concatenation\n ta_stack_out = ta_stack_out.write(t_i, t_row)\n\n return [tf.add(t_i, 1), ta_stack_out] # ++i\n\n # Run the loop, equivalent to:\n # stack_out = []\n # while i < batch_size:\n # stack_out.expand(map_fn(x[indices==i]))\n _, ta_stack_out = tf.while_loop(while_condition, body, [t_i, ta_stack_out])\n\n # Merge all results\n return ta_stack_out.concat()","def draw_samplers(self):\n raise NotImplementedError(\" The draw_samplers() method has not been implemented \")","def input_fn(filenames, batch_size, num_epochs): \n # Create a dataset out of the raw TFRecord file. See the Data Generator for more\n dataset = tf.contrib.data.TFRecordDataset(filenames)\n # Map the tf.example to tensor using the _parse_function\n dataset = dataset.map(_parse_function, num_threads=4)\n # Create an arbitrary bucket range.\n buckets = [tf.constant(num, dtype=tf.int64) for num in range(0, 500, 15)]\n # Number of elements per bucket.\n window_size = 1000\n # Group the dataset according to a bucket key (see bucketing_fn).\n # Every element in the dataset is attributed a key (here a bucket id)\n # The elements are then bucketed according to these keys. A group of \n # `window_size` having the same keys are given to the reduc_fn. \n dataset = dataset.group_by_window(\n lambda x, y, z: bucketing_fn(x, buckets), \n lambda key, x: reduc_fn(key, x, window_size), window_size)\n # We now have buckets of `window_size` size, let's batch and pad them\n dataset = dataset.padded_batch(batch_size, padded_shapes=(\n tf.TensorShape([]), tf.TensorShape([]), tf.Dimension(None)))\n dataset = dataset.map(lambda x, y, z: \n ({\"sentence\":z, \"sequence_length\":x}, y))\n # Repeat the dataset for a given number of epoch\n dataset = dataset.repeat(num_epochs)\n # Create the iterator to enumerate the elements of the dataset.\n iterator = dataset.make_one_shot_iterator()\n # Generator returned by the iterator.\n features, labels = iterator.get_next()\n return features, labels","def cifar_iid(dataset, num_users):\n print(\"Sampling dataset: CIFAR-10 IID\")\n num_items = int(len(dataset)/num_users)\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\n for i in range(num_users):\n dict_users[i] = set(np.random.choice(all_idxs, num_items, replace=False))\n all_idxs = list(set(all_idxs) - dict_users[i])\n return dict_users","def input_fn(params):\n\n batch_size = params[\"batch_size\"]\n output_buffer_size = batch_size * 1000\n\n def extract_fn(data_record):\n features = {\n \"query_ids\": tf.FixedLenSequenceFeature(\n [], tf.int64, allow_missing=True),\n \"doc_ids\": tf.FixedLenSequenceFeature(\n [], tf.int64, allow_missing=True),\n \"label\": tf.FixedLenFeature([], tf.int64),\n }\n sample = tf.parse_single_example(data_record, features)\n\n query_ids = tf.cast(sample[\"query_ids\"], tf.int32)\n doc_ids = tf.cast(sample[\"doc_ids\"], tf.int32)\n label_ids = tf.cast(sample[\"label\"], tf.int32)\n input_ids = tf.concat((query_ids, doc_ids), 0)\n\n query_segment_id = tf.zeros_like(query_ids)\n doc_segment_id = tf.ones_like(doc_ids)\n segment_ids = tf.concat((query_segment_id, doc_segment_id), 0)\n\n input_mask = tf.ones_like(input_ids)\n\n features = {\n \"input_ids\": input_ids,\n \"segment_ids\": segment_ids,\n \"input_mask\": input_mask,\n \"label_ids\": label_ids,\n }\n return features\n\n dataset = tf.data.TFRecordDataset([dataset_path])\n dataset = dataset.map(\n extract_fn, num_parallel_calls=4).prefetch(output_buffer_size)\n\n if is_training:\n dataset = dataset.repeat()\n dataset = dataset.shuffle(buffer_size=1000)\n else:\n if max_eval_examples:\n # Use at most this number of examples (debugging only).\n dataset = dataset.take(max_eval_examples)\n # pass\n\n dataset = dataset.padded_batch(\n batch_size=batch_size,\n padded_shapes={\n \"input_ids\": [seq_length],\n \"segment_ids\": [seq_length],\n \"input_mask\": [seq_length],\n \"label_ids\": [],\n },\n padding_values={\n \"input_ids\": 0,\n \"segment_ids\": 0,\n \"input_mask\": 0,\n \"label_ids\": 0,\n },\n drop_remainder=True)\n\n return dataset","def draw_strat_sample(self, T, n, excl_idxs=None):\n\n if n == 0:\n return np.array([], dtype=np.uint)\n\n if T.size == n: # TODO: this only works if excl_idxs=None\n return np.arange(n)\n\n if n == 1:\n idxs_all_non_excl = np.setdiff1d(\n np.arange(T.size), excl_idxs, assume_unique=True\n )\n return np.array([np.random.choice(idxs_all_non_excl)])\n\n # Freedman-Diaconis rule\n h = 2 * np.subtract(*np.percentile(T, [75, 25])) / np.cbrt(n)\n n_bins = int(np.ceil((np.max(T) - np.min(T)) / h)) if h > 0 else 1\n n_bins = min(\n n_bins, n / 2\n ) # Limit number of bins to half of requested subset size.\n\n bins = np.linspace(np.min(T), np.max(T), n_bins, endpoint=False)\n idxs = np.digitize(T, bins)\n\n # Exclude restricted indices.\n if excl_idxs is not None and excl_idxs.size > 0:\n idxs[excl_idxs] = n_bins + 1 # Impossible bin.\n\n uniq_all, cnts_all = np.unique(idxs, return_counts=True)\n\n # Remove restricted bin.\n if excl_idxs is not None and excl_idxs.size > 0:\n excl_bin_idx = np.where(uniq_all == n_bins + 1)\n cnts_all = np.delete(cnts_all, excl_bin_idx)\n uniq_all = np.delete(uniq_all, excl_bin_idx)\n\n # Compute reduced bin counts.\n reduced_cnts = np.ceil(cnts_all / np.sum(cnts_all, dtype=float) * n).astype(int)\n reduced_cnts = np.minimum(\n reduced_cnts, cnts_all\n ) # limit reduced_cnts to what is available in cnts_all\n\n # Reduce/increase bin counts to desired total number of points.\n reduced_cnts_delta = n - np.sum(reduced_cnts)\n\n while np.abs(reduced_cnts_delta) > 0:\n\n # How many members can we remove from an arbitrary bucket, without any bucket with more than one member going to zero?\n max_bin_reduction = np.min(reduced_cnts[np.where(reduced_cnts > 1)]) - 1\n\n # Generate additional bin members to fill up/drain bucket counts of subset. This array contains (repeated) bucket IDs.\n outstanding = np.random.choice(\n uniq_all,\n min(max_bin_reduction, np.abs(reduced_cnts_delta)),\n p=(reduced_cnts - 1) / np.sum(reduced_cnts - 1, dtype=float),\n )\n uniq_outstanding, cnts_outstanding = np.unique(\n outstanding, return_counts=True\n ) # Aggregate bucket IDs.\n\n outstanding_bucket_idx = np.where(\n np.in1d(uniq_all, uniq_outstanding, assume_unique=True)\n )[\n 0\n ] # Bucket IDs to Idxs.\n reduced_cnts[outstanding_bucket_idx] += (\n np.sign(reduced_cnts_delta) * cnts_outstanding\n )\n reduced_cnts_delta = n - np.sum(reduced_cnts)\n\n # Draw examples for each bin.\n idxs_train = np.empty((0,), dtype=int)\n for uniq_idx, bin_cnt in zip(uniq_all, reduced_cnts):\n idx_in_bin_all = np.where(idxs.ravel() == uniq_idx)[0]\n idxs_train = np.append(\n idxs_train, np.random.choice(idx_in_bin_all, bin_cnt, replace=False)\n )\n return idxs_train","def draw(self, state):\n\n def sample(s):\n return self._rng.choice(\n self.transition_matrix.shape[1], p=self.transition_matrix[s, :]\n )\n\n array_sample = np.frompyfunc(sample, 1, 1)\n\n return array_sample(state)","def draw(self, nsamples):\n \n if self.dist == 'normal':\n mean = self.mean\n sd = self.sd\n self.sample = sd * np.random.randn(nsamples) + mean\n \n elif self.dist == 'poisson':\n lam = self.lam\n self.sample = np.random.poisson(lam, size=nsamples)\n \n elif self.dist == 'binomial':\n n = self.n\n p = self.p\n self.sample = np.random.binomial(n, p, size=nsamples)\n \n else:\n print('dist must be normal, poisson or binomial')","def input_fn(is_training, data_dir, reid_data_dir= None,batch_size=32, num_epochs=1):\n dataset = tf.data.Dataset.from_tensor_slices(get_filenames(is_training, data_dir))\n dataset_seg = dataset.flat_map(tf.data.TFRecordDataset)\n\n # dataset_reid = tf.data.Dataset.from_tensor_slices(get_filenames_reid(is_training, reid_data_dir))\n # dataset_reid = dataset_reid.flat_map(tf.data.TFRecordDataset)\n\n\n if is_training:\n # When choosing shuffle buffer sizes, larger sizes result in better\n # randomness, while smaller sizes have better performance.\n # is a relatively small dataset, we choose to shuffle the full epoch.\n dataset_seg = dataset_seg.shuffle(buffer_size=_NUM_IMAGES['train'])\n # dataset_reid = dataset_reid.shuffle(buffer_size=30248)\n\n\n dataset_seg = dataset_seg.map(parse_record)\n dataset_seg = dataset_seg.map(lambda image, label: preprocess_image(image, label, is_training))\n dataset_seg = dataset_seg.prefetch(batch_size)\n dataset_seg = dataset_seg.repeat(num_epochs)\n dataset_seg = dataset_seg.batch(batch_size)\n\n # dataset_reid = dataset_reid.map(parse_record_reid)\n # dataset_reid = dataset_reid.map(lambda image, label: preprocess_image_reid(image, label, is_training))\n # dataset_reid = dataset_reid.prefetch(batch_size)\n # dataset_reid = dataset_reid.repeat(num_epochs)\n # dataset_reid = dataset_reid.batch(batch_size)\n\n # iterator = dataset_reid.make_one_shot_iterator()\n # images_reid, label_reid = iterator.get_next()\n\n train_record_file = os.path.join(reid_data_dir, 'train-512-170.tfrecords')\n val_record_file = os.path.join(reid_data_dir, 'val-512-170.tfrecords')\n\n train_images, train_labels = read_records(train_record_file, _HEIGHT, _WIDTH, type='normalization')\n train_images_batch, train_labels_batch = get_batch_images(train_images, train_labels,\n batch_size=batch_size, labels_nums=labels_nums,\n one_hot=True, shuffle=True)\n print(\"reid2222222\", train_images_batch.shape, train_labels_batch.shape)\n val_images, val_labels = read_records(val_record_file, _HEIGHT, _WIDTH, type='normalization')\n val_images_batch, val_labels_batch = get_batch_images(val_images, val_labels,\n batch_size=batch_size, labels_nums=labels_nums,\n one_hot=True, shuffle=False)\n images_reid = train_images_batch\n label_reid = train_labels_batch\n # if is_training:\n # images_reid = train_images_batch\n # label_reid = train_labels_batch\n # else:\n # images_reid = val_images_batch\n # label_reid = val_labels_batch\n iterator = dataset_seg.make_one_shot_iterator()\n images_seg, label_seg = iterator.get_next()\n\n images = {\"seg\": images_seg, \"reid\": images_reid}\n labels = {\"seg\": label_seg, \"reid\": label_reid}\n\n # labels_seg_reid = tf.zeros(shape=[batch_size, labels_nums], dtype=tf.int32)\n # labels_reid_seg = tf.zeros(shape=[batch_size, 512, 170, 1], dtype=tf.int32)\n\n # images = tf.concat([images_seg, images_reid], 0)\n # labels_seg_all = tf.concat([label_seg, labels_reid_seg], 0)\n # labels_reid_all = tf.concat([labels_seg_reid, label_reid], 0)\n # labels = {\"seg\": labels_seg_all, \"reid\": labels_reid_all}\n # batch_out= 1\n\n return images, labels","def export_sample_indications(args):\n clarity_epp.export.sample.sample_indications(\n lims, args.output_file, args.artifact_name, args.sequencing_run, args.sequencing_run_project\n )","def new_func():\n dirname, _ = os.path.split(os.path.abspath(__file__))\n pngfile = os.path.sep.join([dirname, \"out.png\"])\n img = [\"110010010011\", \"101011010100\", \"110010110101\", \"100010010011\"]\n img = [[int(val) for val in value] for value in img]\n writer = png.Writer(len(img[0]), len(img), greyscale=True, bitdepth=16)\n with open(pngfile, \"wb\") as file:\n writer.write(file, img)\n try:\n func(pngfile)\n finally:\n os.remove(pngfile)","def __call__(self, samples_number):\n self.sampler.sample(samples_number)","def test_sampling(self):\n dim = Fidelity(\"epoch\", 1, 2)\n assert dim.sample() == [2]\n dim = Fidelity(\"epoch\", 1, 5)\n assert dim.sample() == [5]\n dim = Fidelity(\"epoch\", 1, 5)\n assert dim.sample(4) == [5] * 4","def input_fn(params):\n batch_size = params[\"batch_size\"]\n\n num_examples = len(features)\n\n d = tf.data.Dataset.from_tensor_slices({\n \"input_ids\":\n tf.constant(\n all_input_ids, shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"input_mask\":\n tf.constant(\n all_input_mask,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"segment_ids\":\n tf.constant(\n all_segment_ids,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"label_ids\":\n tf.constant(all_label_ids, shape=[num_examples, len(LABEL_COLUMNS)], dtype=tf.int32),\n })\n\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\n return d","def input_fn_builder(features, seq_length):\n\n all_unique_ids = []\n all_input_ids = []\n all_input_mask = []\n all_input_type_ids = []\n\n for feature in features:\n all_unique_ids.append(feature.unique_id)\n all_input_ids.append(feature.input_ids)\n all_input_mask.append(feature.input_mask)\n all_input_type_ids.append(feature.input_type_ids)\n\n def input_fn(params):\n \"\"\"The actual input function.\"\"\"\n batch_size = params[\"batch_size\"]\n\n num_examples = len(features)\n\n # This is for demo purposes and does NOT scale to large data sets. We do\n # not use Dataset.from_generator() because that uses tf.py_func which is\n # not TPU compatible. The right way to load data is with TFRecordReader.\n d = tf.data.Dataset.from_tensor_slices({\n \"unique_ids\":\n tf.constant(all_unique_ids, shape=[num_examples], dtype=tf.int32),\n \"input_ids\":\n tf.constant(all_input_ids, \n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"input_mask\":\n tf.constant(all_input_mask,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"input_type_ids\":\n tf.constant(all_input_type_ids,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n })\n\n d = d.batch(batch_size=batch_size, drop_remainder=False)\n return d\n\n return input_fn","def test(model,gen,n_id,threshold=0.5,verbose=True,print_every_n=10):\n t_start = time()\n ce_avg,tp,tn,fp,fn = 0.,0.,0.,0.,0.\n for i in range(n_id):\n X_test,y_test = gen.next()\n y_test = y_test.mean()\n Y_pred = model.predict(X_test)\n y_pred = Y_pred.max(axis=0)\n ce = np.mean(- y_test * np.log(y_pred) - (1-y_test) * np.log(1-y_pred))\n ce_avg += ce/n_id\n y_predr = y_pred.round()\n tp += sum((y_test == 1) & (y_predr == 1))\n tn += sum((y_test == 0) & (y_predr == 0))\n fp += sum((y_test == 0) & (y_predr == 1))\n fn += sum((y_test == 1) & (y_predr == 0))\n if i % print_every_n == 0:\n print(i)\n prec,recall,acc = tp/(tp+fp+1e-15),tp/(tp+fn+1e-15),(tp+tn)/n_id\n F1 = 2*tp/(2*tp+fp+fn)\n if verbose:\n print('Valid F1 %.3f tp %.3f tn %.3f fp %.3f fn %.3f' % (F1,tp,tn,fp,fn))\n print('Took %.1fs' % (time()-t_start))\n return(ce_avg,prec,recall,F1,acc,tp,tn,fp,fn)","def input_fn(dir):\r\n\r\n dataset = tf.data.Dataset.list_files(dir+\"*.tif\")\r\n dataset = dataset.shuffle(buffer_size=shuffle_buffer_size)\r\n dataset = dataset.map(\r\n lambda file: tuple(tf.py_func(parser, [file, dir], [tf.float32, tf.float32])),\r\n num_parallel_calls=num_parallel_calls)\r\n #dataset = dataset.batch(batch_size=batch_size)\r\n dataset = dataset.prefetch(buffer_size=prefetch_buffer_size)\r\n dataset = dataset.repeat(num_epochs)\r\n \r\n iter = dataset.make_one_shot_iterator()\r\n\r\n lq, img = iter.get_next()\r\n\r\n return lq, img","def input_fn(params):\n\t\tbatch_size = params[\"batch_size\"]\n\t\toutput_buffer_size = batch_size * 1000\n\t\tmax_seq_len = {0: max_q_len, 1:max_p_len}\n\n\n\t\tdef extract_fn(data_record):\n\t\t\tif is_training:\n\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"raw_query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"rewrite_query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"rewrite_query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"rewrite_query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"doc_ids0\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"doc_ids1\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"label\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t\t\t}\n\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\n\t\t\t\traw_query_ids = tf.cast(sample[\"raw_query_ids\"][:max_q_len], tf.int32)\n\t\t\t\traw_query_segment_ids = tf.cast(sample[\"raw_query_segment_ids\"][:max_q_len], tf.int32)\n\t\t\t\traw_query_mask = tf.ones_like(raw_query_ids)\n\t\t\t\t# effective_raw_query_mask = tf.ones_like(query_ids)\n\t\t\t\teffective_raw_query_mask = tf.cast(sample[\"raw_query_mask\"][:max_q_len], tf.int32)\n\n\t\t\t\trewrite_query_ids = tf.cast(sample[\"rewrite_query_ids\"][:max_q_len], tf.int32)\n\t\t\t\trewrite_query_segment_ids = tf.cast(sample[\"rewrite_query_segment_ids\"][:max_q_len], tf.int32)\n\t\t\t\trewrite_query_mask = tf.ones_like(rewrite_query_ids)\n\t\t\t\teffective_rewrite_query_mask = tf.cast(sample[\"rewrite_query_mask\"][:max_q_len], tf.int32)\n\n\n\t\t\t\tdoc0_ids = tf.cast(sample[\"doc_ids0\"][:max_p_len], tf.int32)\n\t\t\t\tdoc0_segment_ids = tf.zeros_like(doc0_ids)\n\t\t\t\tdoc0_mask = tf.ones_like(doc0_ids)\n\t\t\t\teffective_doc0_mask = tf.ones_like(doc0_ids)\n\n\n\t\t\t\tdoc1_ids = tf.cast(sample[\"doc_ids1\"][:max_p_len], tf.int32)\n\t\t\t\tdoc1_segment_ids = tf.zeros_like(doc1_ids)\n\t\t\t\tdoc1_mask = tf.ones_like(doc1_ids)\n\t\t\t\teffective_doc1_mask = tf.ones_like(doc1_ids)\n\n\n\t\t\t\tlabel = tf.cast(sample[\"label\"], tf.float32)\n\n\n\t\t\t\tfeatures = {\n\t\t\t\t\t\"raw_query_ids\": raw_query_ids,\n\t\t\t\t\t\"raw_query_segment_ids\": raw_query_segment_ids,\n\t\t\t\t\t\"raw_query_mask\": raw_query_mask,\n\t\t\t\t\t\"effective_raw_query_mask\": effective_raw_query_mask,\n\t\t\t\t\t\"rewrite_query_ids\": rewrite_query_ids,\n\t\t\t\t\t\"rewrite_query_segment_ids\": rewrite_query_segment_ids,\n\t\t\t\t\t\"rewrite_query_mask\": rewrite_query_mask,\n\t\t\t\t\t\"effective_rewrite_query_mask\": effective_rewrite_query_mask,\n\t\t\t\t\t\"doc0_ids\": doc0_ids,\n\t\t\t\t\t\"doc0_segment_ids\": doc0_segment_ids,\n\t\t\t\t\t\"doc0_mask\": doc0_mask,\n\t\t\t\t\t\"effective_doc0_mask\": effective_doc0_mask,\n\t\t\t\t\t\"doc1_ids\": doc1_ids,\n\t\t\t\t\t\"doc1_segment_ids\": doc1_segment_ids,\n\t\t\t\t\t\"doc1_mask\": doc1_mask,\n\t\t\t\t\t\"effective_doc1_mask\": effective_doc1_mask,\n\t\t\t\t\t\"label\": label,\n\t\t\t\t\t}\n\t\t\telse:\n\t\t\t\tif is_output:\n\t\t\t\t\tif doc_type==0:\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"raw_query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"query_id\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\t\t\t\t\t\tinput_ids = tf.cast(sample[\"raw_query_ids\"][:max_seq_len[doc_type]], tf.int32)\n\t\t\t\t\t\tsegment_ids = tf.cast(sample[\"raw_query_segment_ids\"][:max_seq_len[doc_type]], tf.int32)\n\t\t\t\t\t\tinput_mask = tf.ones_like(input_ids)\n\t\t\t\t\t\teffective_input_mask = tf.cast(sample[\"raw_query_mask\"][:max_seq_len[doc_type]], tf.int32)\n\t\t\t\t\t\tdocid = tf.cast(sample[\"query_id\"], tf.int32)\n\t\t\t\t\t\tlabel = tf.cast(0, tf.int32) #dummy\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"input_ids\": input_ids,\n\t\t\t\t\t\t\t\"segment_ids\": segment_ids,\n\t\t\t\t\t\t\t\"input_mask\": input_mask,\n\t\t\t\t\t\t\t\"effective_input_mask\": effective_input_mask,\n\t\t\t\t\t\t\t\"docid\": docid,\n\t\t\t\t\t\t\t\"label\": label,\n\t\t\t\t\t\t}\n\t\t\t\t\telif doc_type==1:\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"doc_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\t\"docid\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\t\t\t\t\t\tdoc_ids = sample[\"doc_ids\"][:max_seq_len[doc_type]]\n\n\t\t\t\t\t\tinput_ids = tf.cast(doc_ids, tf.int32)\n\t\t\t\t\t\tsegment_ids = tf.zeros_like(input_ids)\n\t\t\t\t\t\tinput_mask = tf.ones_like(input_ids)\n\t\t\t\t\t\tdocid = tf.cast(sample[\"docid\"], tf.int32)\n\t\t\t\t\t\tlabel = tf.cast(0, tf.int32) #dummy\n\t\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\t\"input_ids\": input_ids,\n\t\t\t\t\t\t\t\"segment_ids\": segment_ids,\n\t\t\t\t\t\t\t\"input_mask\": input_mask,\n\t\t\t\t\t\t\t\"effective_input_mask\": input_mask,\n\t\t\t\t\t\t\t\"docid\": docid,\n\t\t\t\t\t\t\t\"label\": label,\n\t\t\t\t\t\t}\n\t\t\t\telif is_eval:\n\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\"query_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"query_segment_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"query_mask\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"doc_ids\": tf.FixedLenSequenceFeature(\n\t\t\t\t\t\t\t[], tf.int64, allow_missing=True),\n\t\t\t\t\t\t\"label\": tf.FixedLenFeature([], tf.int64),\n\t\t\t\t\t}\n\t\t\t\t\tsample = tf.parse_single_example(data_record, features)\n\n\t\t\t\t\tquery_ids = tf.cast(sample[\"query_ids\"][:max_q_len], tf.int32)\n\t\t\t\t\tquery_segment_ids = tf.cast(sample[\"query_segment_ids\"][:max_q_len], tf.int32)\n\t\t\t\t\t# query_segment_ids = tf.zeros_like(query_ids)\n\t\t\t\t\tquery_mask = tf.ones_like(query_ids)\n\t\t\t\t\teffective_query_mask = tf.cast(sample[\"query_mask\"][:max_q_len], tf.int32)\n\t\t\t\t\t# effective_query_mask = tf.ones_like(query_ids)\n\n\t\t\t\t\tdocx_ids = tf.cast(sample[\"doc_ids\"][:max_p_len], tf.int32)\n\t\t\t\t\tdocx_segment_ids = tf.zeros_like(docx_ids)\n\t\t\t\t\tdocx_mask = tf.ones_like(docx_ids)\n\t\t\t\t\teffective_docx_mask = tf.ones_like(docx_ids)\n\n\n\t\t\t\t\tlabel = tf.cast(sample[\"label\"], tf.int32)\n\n\t\t\t\t\tfeatures = {\n\t\t\t\t\t\t\"query_ids\": query_ids,\n\t\t\t\t\t\t\"query_segment_ids\": query_segment_ids,\n\t\t\t\t\t\t\"query_mask\": query_mask,\n\t\t\t\t\t\t\"effective_query_mask\": effective_query_mask,\n\t\t\t\t\t\t\"docx_ids\": docx_ids,\n\t\t\t\t\t\t\"docx_segment_ids\": docx_segment_ids,\n\t\t\t\t\t\t\"docx_mask\": docx_mask,\n\t\t\t\t\t\t\"effective_docx_mask\": effective_docx_mask,\n\t\t\t\t\t\t\"label\": label,\n\t\t\t\t\t}\n\n\n\t\t\treturn features\n\n\t\tdataset = tf.data.TFRecordDataset([dataset_path])\n\t\tdataset = dataset.map(\n\t\t\textract_fn, num_parallel_calls=4).prefetch(output_buffer_size)\n\n\t\tif is_training:\n\t\t\tdataset = dataset.repeat()\n\t\t\tdataset = dataset.shuffle(buffer_size=1000)\n\t\t\tdataset = dataset.padded_batch(\n\t\t\t\t\t\tbatch_size=batch_size,\n\t\t\t\t\t\tpadded_shapes={\n\t\t\t\t\t\t\t\"raw_query_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"raw_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"effective_raw_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"rewrite_query_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"rewrite_query_segment_ids\": [max_q_len],\n\t\t\t\t\t\t\t\"rewrite_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"effective_rewrite_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\"doc0_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc0_segment_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc0_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"effective_doc0_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"doc1_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc1_segment_ids\": [max_p_len],\n\t\t\t\t\t\t\t\"doc1_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"effective_doc1_mask\": [max_p_len],\n\t\t\t\t\t\t\t\"label\": []\n\t\t\t\t\t\t},\n\t\t\t\t\t\tpadding_values={\n\t\t\t\t\t\t\t\"raw_query_ids\": 0,\n\t\t\t\t\t\t\t\"raw_query_segment_ids\": 0,\n\t\t\t\t\t\t\t\"raw_query_mask\": 0,\n\t\t\t\t\t\t\t\"effective_raw_query_mask\":0,\n\t\t\t\t\t\t\t\"rewrite_query_ids\": 0,\n\t\t\t\t\t\t\t\"rewrite_query_segment_ids\": 0,\n\t\t\t\t\t\t\t\"rewrite_query_mask\": 0,\n\t\t\t\t\t\t\t\"effective_rewrite_query_mask\":0,\n\t\t\t\t\t\t\t\"doc0_ids\": 0,\n\t\t\t\t\t\t\t\"doc0_segment_ids\": 0,\n\t\t\t\t\t\t\t\"doc0_mask\": 0,\n\t\t\t\t\t\t\t\"effective_doc0_mask\": 0,\n\t\t\t\t\t\t\t\"doc1_ids\": 0,\n\t\t\t\t\t\t\t\"doc1_segment_ids\": 0,\n\t\t\t\t\t\t\t\"doc1_mask\": 0,\n\t\t\t\t\t\t\t\"effective_doc1_mask\": 0,\n\t\t\t\t\t\t\t\"label\": 0.0,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tdrop_remainder=True)\n\t\telse:\n\t\t\tif max_eval_examples:\n\t\t\t\t# Use at most this number of examples (debugging only).\n\t\t\t\tdataset = dataset.take(max_eval_examples)\n\t\t\tif is_output:\n\t\t\t\tdataset = dataset.padded_batch(\n\t\t\t\t\t\t\tbatch_size=batch_size,\n\t\t\t\t\t\t\tpadded_shapes={\n\t\t\t\t\t\t\t\t\"input_ids\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"segment_ids\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"input_mask\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"effective_input_mask\": [max_seq_len[doc_type]],\n\t\t\t\t\t\t\t\t\"docid\": [],\n\t\t\t\t\t\t\t\t\"label\": [],\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tpadding_values={\n\t\t\t\t\t\t\t\t\"input_ids\": 0,\n\t\t\t\t\t\t\t\t\"segment_ids\": 0,\n\t\t\t\t\t\t\t\t\"input_mask\": 0,\n\t\t\t\t\t\t\t\t\"effective_input_mask\": 0,\n\t\t\t\t\t\t\t\t\"docid\": 0,\n\t\t\t\t\t\t\t\t\"label\": 0,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tdrop_remainder=True)\n\n\t\t\telif is_eval:\n\t\t\t\tdataset = dataset.padded_batch(\n\t\t\t\t\t\t\t\tbatch_size=batch_size,\n\t\t\t\t\t\t\t\tpadded_shapes={\n\t\t\t\t\t\t\t\t\t\"query_ids\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"query_segment_ids\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"effective_query_mask\": [max_q_len],\n\t\t\t\t\t\t\t\t\t\"docx_ids\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"docx_segment_ids\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"docx_mask\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"effective_docx_mask\": [max_p_len],\n\t\t\t\t\t\t\t\t\t\"label\": []\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tpadding_values={\n\t\t\t\t\t\t\t\t\t\"query_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"query_segment_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"query_mask\": 0,\n\t\t\t\t\t\t\t\t\t\"effective_query_mask\": 0,\n\t\t\t\t\t\t\t\t\t\"docx_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"docx_segment_ids\": 0,\n\t\t\t\t\t\t\t\t\t\"docx_mask\": 0,\n\t\t\t\t\t\t\t\t\t\"effective_docx_mask\":0,\n\t\t\t\t\t\t\t\t\t\"label\": 0,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tdrop_remainder=True)\n\t\treturn dataset","def input_fn_builder(features, seq_length, is_training, drop_remainder):\n \"\"\"This is used to make the proper format of the prediction variable\"\"\"\n\n all_input_ids = []\n all_input_mask = []\n all_segment_ids = []\n all_label_ids = []\n\n for feature in features:\n all_input_ids.append(feature.input_ids)\n all_input_mask.append(feature.input_mask)\n all_segment_ids.append(feature.segment_ids)\n all_label_ids.append(feature.label_id)\n\n def input_fn(params):\n \"\"\"The actual input function.\"\"\"\n print(params)\n batch_size = 500\n\n num_examples = len(features)\n\n d = tf.data.Dataset.from_tensor_slices({\n \"input_ids\":\n tf.constant(\n all_input_ids, shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"input_mask\":\n tf.constant(\n all_input_mask,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"segment_ids\":\n tf.constant(\n all_segment_ids,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"label_ids\":\n tf.constant(all_label_ids, shape=[num_examples], dtype=tf.int32),\n })\n\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\n return d\n\n return input_fn","def outline_geoids(sf, df, geoids, include_labels=True):\n# df = read_shapefile(sf)\n# df['tract_geoid'] = df.GEOID.str[:11]\n bg_id = []\n for i in geoids:\n bg_id.append(df[df.GEOID==i].index[0])\n\n itr = 0\n for shape in sf.shapeRecords():\n if itr in bg_id:\n x = [i[0] for i in shape.shape.points[:]]\n y = [i[1] for i in shape.shape.points[:]]\n plt.plot(x, y, 'k')\n \n \n if include_labels:\n x0 = np.mean(x)\n y0 = np.mean(y)\n label = df.iloc[itr].density_label\n\n plt.text(x0, y0, label, fontsize=8)\n \n itr = itr+1","def sample(self, x):","def regenerate_art(filename=def_rep_name, x_size=def_x_size,\n y_size=def_y_size, func_filename=def_func_name, index=def_index):\n functions = read_func(func_filename, index)\n make_art(functions, filename, False, x_size, y_size)","def _draw_sample_diff_traj(self, idx):\n # Get a good pair of samples\n src_dataset_idx, src_traj_id, src_idx = self._locate_sample(idx)\n\n src_traj = self.fds[src_dataset_idx][src_traj_id]\n map_name = src_traj.attrs[\"map\"].decode(\"ascii\")\n\n idx2 = self.rng.randint(self.samples_per_map[map_name])\n dst_dataset_idx, dst_traj_id, dst_idx = self._locate_sample_single_map(\n idx2, map_name\n )\n dst_traj = self.fds[dst_dataset_idx][dst_traj_id]\n\n src_sample = src_traj[src_idx]\n dst_sample = dst_traj[dst_idx]\n\n return map_name, src_sample, dst_sample","def input_fn(self,features, labels, batch_size, shuffle_num, mode):\r\n dataset = tf.data.Dataset.from_tensor_slices((features, labels))\r\n if mode == tf.estimator.ModeKeys.TRAIN:\r\n dataset = dataset.shuffle(shuffle_num).batch(batch_size).repeat(self.epochs)\r\n else:\r\n dataset = dataset.batch(batch_size)\r\n iterator = dataset.make_one_shot_iterator()\r\n data, labels = iterator.get_next()\r\n return data, labels","def generate_data(func, points, seed=0):\n np.random.seed(seed)\n\n data = []\n for segment in points:\n x = np.linspace(*segment[\"xlim\"], num=segment[\"n_points\"])\n distribution = func(x)\n # Generate observations\n y = distribution.rvs()\n df = pd.DataFrame({\"x\": x, \"y\": y})\n data.append(df)\n\n return pd.concat(data, ignore_index=True)","def cifar_100_iid(dataset, num_users):\n print(\"Sampling dataset: CIFAR-100 IID\")\n num_items = int(len(dataset) / num_users)\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\n for i in range(num_users):\n dict_users[i] = set(np.random.choice(all_idxs, num_items, replace=False))\n all_idxs = list(set(all_idxs) - dict_users[i])\n return dict_users","def dense_sample(data, indint, metric = np.linspace, **kwargs):\r\n \r\n datab = np.zeros((indint))\r\n n_interp = len(data) - 1\r\n excess = indint - len(data) # excess indices\r\n base_interpol = excess / n_interp # minimum number of middle values in each interpolation\r\n remainder = excess % n_interp # extra middle values. (< n_interp). distribute evenly throughout datab.\r\n \r\n if remainder == 1:\r\n left_edge_tack_ons = np.array([np.median(range(n_interp))])\r\n else:\r\n left_edge_tack_ons = np.linspace(0, n_interp-1, remainder) \r\n \r\n datab_ind_counter = 0# keep track of inds of output vector\r\n for i, item in enumerate(data[:-1]):\r\n if np.size(left_edge_tack_ons) > 0:\r\n if i >= left_edge_tack_ons[0]:\r\n tack_on = 1\r\n left_edge_tack_ons = left_edge_tack_ons[1:]\r\n else:\r\n tack_on = 0\r\n else:\r\n tack_on = 0\r\n \r\n datab[datab_ind_counter:(datab_ind_counter+base_interpol+tack_on+1)] = metric(data[i], data[i+1], base_interpol+tack_on+2)[:-1]\r\n datab_ind_counter += (base_interpol+tack_on+1)\r\n datab[-1] = data[-1]\r\n return datab","def _draw_sample_diff_traj(self, idx):\n # Get a good pair of samples\n src_dataset_idx, src_traj_id, src_idx = self._locate_sample(idx)\n\n src_traj = self.fds[src_dataset_idx][src_traj_id]\n map_name = src_traj.attrs[\"map\"].decode(\"ascii\")\n\n idx2 = self.rng.randint(self.samples_per_map[map_name])\n dst_dataset_idx, dst_traj_id, dst_idx = self._locate_sample_single_map(\n idx2, map_name\n )\n dst_traj = self.fds[dst_dataset_idx][dst_traj_id]\n\n src_sample = self._jitter(src_traj[src_idx], self.maps[map_name])\n dst_samples = self._make_sample_seq(dst_traj, dst_idx)\n return map_name, src_sample, dst_samples","def lattice_sample_taken(self, ind, series):","def input_fn(params):\n batch_size = params[\"batch_size\"]\n\n num_examples = len(features)\n\n # This is for demo purposes and does NOT scale to large data sets. We do\n # not use Dataset.from_generator() because that uses tf.py_func which is\n # not TPU compatible. The right way to load data is with TFRecordReader.\n d = tf.data.Dataset.from_tensor_slices({\n \"input_ids\":\n tf.constant(\n all_input_ids, shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"input_mask\":\n tf.constant(\n all_input_mask,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"segment_ids\":\n tf.constant(\n all_segment_ids,\n shape=[num_examples, seq_length],\n dtype=tf.int32),\n \"label_ids\":\n tf.constant(all_label_ids, shape=[num_examples], dtype=tf.int32),\n })\n\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\n return d","def wrapped_f(*args):\n input_docs = func(*args)\n output_doc_cnt = 0\n # split input_docs into chunks of size self.batch_size\n for batchiter in iter_n(input_docs, int(self.batch_size / len(self.input_types))):\n output_docs = self.key_lookup_batch(batchiter)\n for odoc in output_docs:\n # print debug information if the original id is the in the debug list\n if \"dt_debug\" in odoc:\n if isinstance(self.debug, list) and odoc[\"dt_debug\"][\"orig_id\"] in self.debug:\n self.logger.debug(\"DataTransform Debug doc['dt_debug']: {}\".format(odoc[\"dt_debug\"]))\n output_doc_cnt += 1\n yield odoc\n self.logger.info(\"wrapped_f Num. output_docs: {}\".format(output_doc_cnt))\n self.logger.info(\"DataTransform.histogram: {}\".format(self.histogram))","def get_cui_sample_it(self):\n while True:\n i = rd.sample(range(len(self.id2sense)), 1)[0]\n cui = self.id2sense[i]\n if cui in self.cui2def:\n sdef = self.cui2def[cui]\n else:\n sdef = [self.voc.encode(PAD)] * self.model_config.max_def_len\n\n if cui in self.cui2stype:\n stype = self.cui2stype[cui]\n else:\n stype = self.stype2id['unk']\n\n for abbr_id in self.cuiud2abbrid[i]:\n obj = {\n 'abbr_id': abbr_id,\n 'cui_id': i,\n 'def': sdef,\n 'stype': stype}\n yield obj","def generate_lambda_art(filename, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n r_lb = random.randint(1, 2)\n g_lb = random.randint(1, 2)\n b_lb = random.randint(1, 2)\n red_function = r_lambda_func(1)\n green_function = r_lambda_func(1)\n blue_function = r_lambda_func(1)\n print(red_function)\n print(red_function)\n print(red_function(0.0, 1.0))\n print(red_function(1.0, 0.05))\n print(red_function(1.0, 0.0))\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(red_function(x, y)),\n color_map(green_function(x, y)),\n color_map(blue_function(x, y))\n )\n im.save(filename)\n return 'saved'","def train_input_fn():\n # Initialize `iterator` with training data.\n train_filenames = [os.path.join(FLAGS.out_dir, FLAGS.train_records)]\n return _input_fn(train_filenames, FLAGS.epochs, FLAGS.batch_size, shuffle=True)","def file_based_convert_examples_to_features(path, label2id, max_seq_length, tokenize_fn, output_file):\n tf.logging.info(\"Create new tfrecord {}.\".format(output_file))\n writer = tf.python_io.TFRecordWriter(output_file)\n df = pd.read_csv(path, index_col=0)\n df = shuffle(df)\n count = 0\n for index, row in df.iterrows():\n # label = label2id[row[\"topic\"].strip()]\n feature = convert_single_example(row[config[\"column_name_x1\"]],\n row[config[\"column_name_x2\"]] if config[\"column_name_x2\"] != \"\" else None,\n max_seq_length, tokenize_fn)\n\n def create_int_feature(values):\n f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))\n return f\n\n def create_float_feature(values):\n f = tf.train.Feature(float_list=tf.train.FloatList(value=list(values)))\n return f\n\n label = label2id.get(str(row[config[\"column_name_y\"]]))\n features = collections.OrderedDict()\n features[\"input_ids\"] = create_int_feature(feature[0])\n features[\"input_mask\"] = create_float_feature(feature[1])\n features[\"segment_ids\"] = create_int_feature(feature[2])\n features[\"label_ids\"] = create_int_feature([label])\n count += 1\n if count < 5:\n print(\"*** Example ***\")\n print(\"input_ids: %s\" % \" \".join([str(x) for x in feature[0]]))\n print(\"input_mask: %s\" % \" \".join([str(x) for x in feature[1]]))\n print(\"segment_ids: %s\" % \" \".join([str(x) for x in feature[2]]))\n\n print(\"label: %s (id = %s)\" % (row[config[\"column_name_y\"]], str(label)))\n\n tf_example = tf.train.Example(features=tf.train.Features(feature=features))\n writer.write(tf_example.SerializeToString())\n if count % 1000 == 0:\n print(count)\n writer.close()\n print(\"example count:\", count)","def make_returnn_audio_features_func():\n return _extract","def input_fn(params):\n batch_size = self.batch_size\n\n num_examples = len(features)\n\n d = tf.data.Dataset.from_tensor_slices({\n \"input_ids\":\n tf.constant(\n all_input_ids, shape=[num_examples, max_seq_len],\n dtype=tf.int32),\n \"input_mask\":\n tf.constant(\n all_input_mask,\n shape=[num_examples, max_seq_len],\n dtype=tf.int32),\n \"label_ids\":\n tf.constant(\n all_input_ids, shape=[num_examples, max_seq_len],\n dtype=tf.int32),\n \"label_mask\":\n tf.constant(\n all_input_mask,\n shape=[num_examples, max_seq_len],\n dtype=tf.int32),\n })\n\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.batch(batch_size=batch_size)\n return d","def sample(self, features, states=None):\r\n sampled_ids = []\r\n inputs = features.unsqueeze(1)\r\n for i in range(105): #62\r\n hiddens, states = self.lstm(inputs, states)\r\n outputs = self.linear(hiddens.squeeze(1))\r\n a = outputs.max(1)\r\n predicted = outputs.max(1)[1]\r\n sampled_ids.append(predicted)\r\n inputs = self.embed(predicted)\r\n inputs = inputs.unsqueeze(1)\r\n return sampled_ids","def _imageid_and_mids_generator(filepath):\n with open(filepath, 'rb') as fp:\n imageid2mids = pickle.load(fp)\n \n for imageid, mids in imageid2mids.items():\n Np = MAX_N_MIDS - len(mids)\n if Np < 0:\n tf.logging.warn(f'Np = {Np}.')\n # pad to MAX_N_MIDS\n mids.extend([''.encode('utf-8')]*Np)\n yield imageid.encode('utf-8'), mids, Np","def run_trials(f, n):\n\tfor value in range(2, 3):\n\t\tprint(\"{:>3}:{:>5}\".format(value, f(n, value)))","def iid_sampling(dataset, num_users):\n num_items = int(len(dataset) / num_users)\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\n for i in range(num_users):\n dict_users[i] = set(np.random.choice(all_idxs, num_items,\n replace=False))\n all_idxs = list(set(all_idxs) - dict_users[i])\n return dict_users","def input_fn():\n bos_id = tf.constant(BOS_ID, tf.int32)\n eos_id = tf.constant(EOS_ID, tf.int32)\n\n # For training, we want a lot of parallel reading and shuffling.\n # For eval, we want no shuffling and parallel reading doesn't matter.\n d = tf.data.TFRecordDataset(input_files)\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.map(lambda record: _decode_record(record, name_to_features))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n tf.concat([[bos_id], src_ids, [eos_id]], 0),\n tf.concat([tgt_ids, [eos_id]], 0),\n label))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n src_ids[:FLAGS.max_sequence_length],\n tgt_ids[:FLAGS.max_sequence_length],\n label\n ))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n tf.concat([src_ids, tgt_ids], 0),\n tf.concat([tf.zeros_like(src_ids), tf.ones_like(tgt_ids)], 0),\n label\n ))\n\n d = d.map(lambda input_ids, segment_ids, label_ids: (\n input_ids,\n segment_ids,\n tf.ones_like(input_ids),\n label_ids\n ))\n\n def batching_func(x):\n return x.padded_batch(\n batch_size,\n # The entry is the source line rows;\n # this has unknown-length vectors. The last entry is\n # the source row size; this is a scalar.\n padded_shapes=(\n tf.TensorShape([None]), # src\n tf.TensorShape([None]), # tgt\n tf.TensorShape([None]),\n tf.TensorShape([])), # src_len\n # Pad the source sequences with eos tokens.\n # (Though notice we don't generally need to do this since\n # later on we will be masking out calculations past the true sequence.\n padding_values=(\n PAD_ID, # src\n PAD_ID,\n PAD_ID,\n 0)) # src_len -- unused\n\n batched_dataset = batching_func(d)\n features = batched_dataset.map(lambda input_ids, segment_ids, input_mask, label:\n {\n \"input_ids\": input_ids,\n \"segment_ids\": segment_ids,\n \"input_mask\": input_mask,\n \"label_ids\": label\n\n })\n\n return features","def get_itr_snapshot(self, itr, samples_data):\n raise NotImplementedError","def get_itr_snapshot(self, itr, samples_data):\n raise NotImplementedError","def get_itr_snapshot(self, itr, samples_data):\n raise NotImplementedError","def sample(self):\n return self._sample_func","def taxi_rides_sample(path, n, storage_options=None):\n return next(taxi_rides_iterator(path, n, storage_options))","def make_data_iter_fn(filename, batch_size, is_train):\n def parse_fn(example_proto):\n features = {\n 'input': tf.FixedLenSequenceFeature([], tf.int64, allow_missing=True),\n 'target': tf.VarLenFeature(tf.int64),\n 'input_length': tf.FixedLenFeature([1], tf.int64),\n 'target_length': tf.FixedLenFeature([1], tf.int64)\n }\n parsed_features = tf.parse_single_example(example_proto, features=features)\n\n parsed_features['input'] = tf.cast(parsed_features['input'], tf.int32)\n t = parsed_features['target']\n parsed_features['target'] = tf.SparseTensor(indices=t.indices, \n values=tf.cast(t.values, tf.int32),\n dense_shape=t.dense_shape)\n \n parsed_features['input_length'] = tf.cast(parsed_features['input_length'], tf.int32)\n parsed_features['target_length'] = tf.cast(parsed_features['target_length'], tf.int32)\n\n return parsed_features\n\n def input_fn():\n dataset = tf.data.TFRecordDataset(filename)\n dataset = dataset.map(parse_fn)\n \n if is_train:\n dataset = dataset.shuffle(500).repeat()\n \n dataset = dataset.batch(batch_size).prefetch(2)\n features = dataset.make_one_shot_iterator().get_next()\n return features, features['target']\n\n return input_fn","def sample(draws, step_method, chain_state, sample_history ):\n start = time.time()\n for i in xrange(int(draws)):\n chain_state = step_method.step(chain_state)\n sample_history.record(chain_state, step_method)\n \n return (time.time() - start)"],"string":"[\n \"def iid_sample(sample_fn, sample_shape):\\n sample_shape = distribution_util.expand_to_vector(\\n ps.cast(sample_shape, np.int32), tensor_name='sample_shape')\\n n = ps.cast(ps.reduce_prod(sample_shape), dtype=np.int32)\\n static_n = tf.get_static_value(tf.convert_to_tensor(n))\\n\\n def unflatten(x):\\n sample_dims = 0 if static_n == 1 else 1\\n unflattened_shape = ps.cast(\\n ps.concat([sample_shape, ps.shape(x)[sample_dims:]], axis=0),\\n dtype=np.int32)\\n return tf.reshape(x, unflattened_shape)\\n\\n def iid_sample_fn(*args, **kwargs):\\n \\\"\\\"\\\"Draws iid samples from `fn`.\\\"\\\"\\\"\\n\\n with tf.name_scope('iid_sample_fn'):\\n\\n seed = kwargs.pop('seed', None)\\n if samplers.is_stateful_seed(seed):\\n kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())\\n def pfor_loop_body(_):\\n with tf.name_scope('iid_sample_fn_stateful_body'):\\n return sample_fn(*args, **kwargs)\\n else:\\n # If a stateless seed arg is passed, split it into `n` different\\n # stateless seeds, so that we don't just get a bunch of copies of the\\n # same sample.\\n if not JAX_MODE:\\n warnings.warn(\\n 'Saw Tensor seed {}, implying stateless sampling. Autovectorized '\\n 'functions that use stateless sampling may be quite slow because '\\n 'the current implementation falls back to an explicit loop. This '\\n 'will be fixed in the future. For now, you will likely see '\\n 'better performance from stateful sampling, which you can invoke '\\n 'by passing a Python `int` seed.'.format(seed))\\n seed = samplers.split_seed(seed, n=n, salt='iid_sample_stateless')\\n def pfor_loop_body(i):\\n with tf.name_scope('iid_sample_fn_stateless_body'):\\n return sample_fn(*args, seed=tf.gather(seed, i), **kwargs)\\n\\n if static_n == 1:\\n draws = pfor_loop_body(0)\\n else:\\n draws = parallel_for.pfor(pfor_loop_body, n)\\n return tf.nest.map_structure(unflatten, draws, expand_composites=True)\\n\\n return iid_sample_fn\",\n \"def draw(function):\\n def f(**kwargs):\\n rand = random.random()\\n x = function(**kwargs)\\n return int(rand < x)\\n return f\",\n \"def apply():\\r\\n result = dataSampling(str, \\\"hhhhhhahhhhhahhahahahahhahahha\\\", 5)\\r\\n final_res = dataScreening(result, \\\"ha\\\")\\r\\n print(final_res)\",\n \"def clean_line_generator_v2(df_pkl=None, fn='untitled'):\",\n \"def visualize_attention(test_seq,\\n model,\\n id2wrd,\\n n):\\n\\n get_layer_output = K.function([model.layers[0].input, K.learning_phase()], [model.layers[4].output])\\n out = get_layer_output([test_seq, ])[0] # test mode\\n\\n att_w = model.layers[5].get_weights()\\n\\n eij = np.tanh(np.dot(out[0], att_w[0]))\\n ai = np.exp(eij)\\n weights = ai/np.sum(ai)\\n weights = np.sum(weights,axis=1)\\n\\n topKeys = np.argpartition(weights,-n)[-n:]\\n\\n print(' '.join([id2wrd[wrd_id] for wrd_id in test_seq[0] if wrd_id != 0.])) \\n \\n for k in test_seq[0][topKeys]:\\n if k != 0.:\\n print(id2wrd[k])\\n \\n return\",\n \"def id2ind(ngrid,nspecies,filename):\\n ntot=ngrid[0]*ngrid[1]*ngrid[2]*nspecies\\n np_icell=np.empty((3,ntot),dtype=np.intc)\\n np_ispecies=np.empty(ntot,dtype=np.intc)\\n icell=np_icell\\n ispecies=np_ispecies\\n \\n f=StringIO.StringIO()\\n\\n for ii in xrange(ntot):\\n tmp,ispecies[ii]=divmod(ii,nspecies)\\n tmp,icell[0,ii]=divmod(tmp,ngrid[0])\\n icell[2,ii],icell[1,ii]=divmod(tmp,ngrid[1])\\n jj=(icell[0,ii]+1)*(icell[1,ii]+1)*(icell[2,ii]+1)\\n f.write(\\\"{:>6d} {:>6d} {:>6d}\\\\n\\\".format(ii+1,(ii+nspecies)//nspecies,ispecies[ii]))\\n ffinal=open(filename,\\\"w\\\")\\n ffinal.write(f.getvalue())\\n f.close()\\n ffinal.close()\",\n \"def fn():\",\n \"def seq_idty():\\n\\n # load distance matrices\\n fams_to_plot = [ f for f in famlist if f not in ignored ]\\n fam_arrays = []\\n for f in fams_to_plot:\\n if path.isfile(\\\"data/\\\"+f+\\\".npy\\\"):\\n fam_arrays.append(np.load(\\\"data/\\\"+f+\\\".npy\\\") / 100.0) # normalize percentages in [0,1]\\n else:\\n warn(\\\"data/\\\"+f+\\\".npy not found !\\\")\\n fam_arrays.append(np.array([]))\\n\\n # Update database with identity percentages\\n conn = sqlite3.connect(runDir + \\\"/results/RNANet.db\\\")\\n conn.execute('pragma journal_mode=wal')\\n for f, D in zip(fams_to_plot, fam_arrays):\\n if not len(D): continue\\n if D.shape[0] > 1:\\n a = np.sum(D) * 2 / D.shape[0] / (D.shape[0] - 1) # SUM(D) / (n(n-1)/2)\\n else:\\n a = D[0][0]\\n conn.execute(f\\\"UPDATE family SET idty_percent = {round(float(a),2)} WHERE rfam_acc = '{f}';\\\")\\n conn.commit()\\n conn.close()\\n\\n # Plots plots plots\\n fig, axs = plt.subplots(4,17, figsize=(17,5.75))\\n axs = axs.ravel()\\n [axi.set_axis_off() for axi in axs]\\n im = \\\"\\\" # Just to declare the variable, it will be set in the loop\\n for f, D, ax in zip(fams_to_plot, fam_arrays, axs):\\n D = D + D.T # Copy the lower triangle to upper, to get a symetrical matrix\\n if D.shape[0] > 2: # Cluster only if there is more than 2 sequences to organize\\n D = 1.0 - D\\n np.fill_diagonal(D, 0.0)\\n condensedD = squareform(D)\\n\\n # Compute basic dendrogram by Ward's method\\n Y = sch.linkage(condensedD, method='ward')\\n Z = sch.dendrogram(Y, orientation='left', no_plot=True)\\n\\n # Reorganize rows and cols\\n idx1 = Z['leaves']\\n D = D[idx1[::-1],:]\\n D = D[:,idx1[::-1]]\\n D = 1.0 - D\\n elif D.shape[0] == 2:\\n np.fill_diagonal(D, 1.0) # the diagonal has been ignored until now\\n ax.text(np.floor(D.shape[0]/2.0)-(0.5 if not D.shape[0]%2 else 0), -0.5, f + \\\"\\\\n(\\\" + str(D.shape[0]) + \\\" chains)\\\", \\n fontsize=9, horizontalalignment = 'center', verticalalignment='bottom')\\n im = ax.matshow(D, vmin=0, vmax=1)\\n\\n fig.tight_layout()\\n fig.subplots_adjust(hspace=0.3, wspace=0.1)\\n fig.colorbar(im, ax=axs[-4], shrink=0.8)\\n fig.savefig(runDir + f\\\"/results/figures/distances_{res_thr}.png\\\")\\n print(\\\"> Computed all identity matrices and saved the figure.\\\", flush=True)\",\n \"def dev_sample_generator(self, fi):\\n for line in fi:\\n line_list = line.split(\\\" \\\")\\n label = int(line_list[-1])\\n sequence = np.array(line_list[:-1], dtype=np.intp)\\n yield sequence, sequence.shape[0], np.unique(sequence).shape[0], label\",\n \"def gen_feats_file(data_feats,ids,feat_filename):\\n if not os.path.isfile(feat_filename) :\\n new_feats=np.empty((0,2))\\n for iid in ids:\\n print(iid)\\n indices = [i for i, v in enumerate(data_feats[:,0]) if iid in v]\\n new_feats=np.vstack((new_feats,data_feats[indices,:]))\\n np.savetxt(feat_filename,new_feats,fmt=\\\"%s\\\")\",\n \"def sample(f, n):\\n entries = list(SeqIO.parse(f, 'fasta'))\\n for seqnum in range(n):\\n loc = round(random.uniform(0, len(entries) - 1))\\n entry = entries[loc] # get index of randomly-selected FASTA entry\\n header = '>' + str(seqnum + 1) + '-' + entry.description # header\\n print(header + '\\\\n' + str(entry.seq)) # print-out entire entry\",\n \"def drawOnImg(file1, imgBW, chosenDis,iteration):\\n nP, IDrange = upDate(iteration)\\n chosenContour = []\\n x, y, w, h = cv2.boundingRect(shapesContours[len(chosenDis) - 1])\\n cv2.rectangle(imgBW, (x - nP, y - nP), (x + w + nP, y + h + nP), (128, 0, 128), 4)\\n chosenContour.append(shapesContours[len(chosenDis) - 1])\\n file1.write(str(chosenDis[len(chosenDis) - 1]) + \\\" **\\\\n\\\")\\n print(chosenDis[len(chosenDis) - 1], \\\"**\\\")\\n\\n file1.write(str(chosenDis[len(chosenDis) - 1]) + '\\\\n')\\n print(chosenDis[len(chosenDis) - 1])\",\n \"def f5(seq, idfun=None):\\n if idfun is None:\\n def idfun(x):\\n return x\\n\\n seen = {}\\n result = []\\n for item in seq:\\n marker = idfun(item)\\n if marker in seen:\\n continue\\n seen[marker] = 1\\n result.append(item)\\n return result\",\n \"def input_fn(params):\\n print(params)\\n batch_size = 500\\n\\n num_examples = len(features)\\n\\n d = tf.data.Dataset.from_tensor_slices({\\n \\\"input_ids\\\":\\n tf.constant(\\n all_input_ids, shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"input_mask\\\":\\n tf.constant(\\n all_input_mask,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"segment_ids\\\":\\n tf.constant(\\n all_segment_ids,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"label_ids\\\":\\n tf.constant(all_label_ids, shape=[num_examples], dtype=tf.int32),\\n })\\n\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\\n return d\",\n \"def sample(self, seg_logit, seg_label):\",\n \"def draw_elem_numbers(n):\\n return drawNumbers(named(n))\",\n \"def fiducial_snapshots(Nsnap=5):\\n \\n times = np.linspace(0,0.5,Nsnap)\\n \\n for t in times:\\n generate_fiducial(time=t)\",\n \"def get_sample_ids(maptable):\\n return [line[0] for line in maptable[1:]]\",\n \"def draw_stratas(enum_func):\\n maximum_strata_index = 7\\n graph = ot.Graph(\\\"\\\", \\\"$\\\\\\\\alpha_1$\\\", \\\"$\\\\\\\\alpha_2$\\\", True)\\n if enum_func.__class__.__name__ == \\\"LinearEnumerateFunction\\\":\\n graph.setTitle(\\\"Linear enumeration rule\\\")\\n elif enum_func.__class__.__name__ == \\\"HyperbolicAnisotropicEnumerateFunction\\\":\\n graph.setTitle(f\\\"q={enum_func.getQ()}\\\")\\n offset = 0\\n for strata_index in range(maximum_strata_index):\\n strata_cardinal = enum_func.getStrataCardinal(strata_index)\\n sample_in_layer = [enum_func(idx + offset) for idx in range(strata_cardinal)]\\n offset += strata_cardinal\\n cloud = ot.Cloud(sample_in_layer)\\n cloud.setLegend(str(strata_index))\\n cloud.setPointStyle(\\\"circle\\\")\\n graph.add(cloud)\\n palette = ot.DrawableImplementation.BuildDefaultPalette(maximum_strata_index)\\n graph.setColors(palette)\\n graph.setIntegerXTick(True)\\n graph.setIntegerYTick(True)\\n graph.setLegendPosition(\\\"topright\\\")\\n return graph\",\n \"def _create_fake_dataset(output_path, seq_length, include_sentence_id):\\n writer = tf.io.TFRecordWriter(output_path)\\n\\n def create_int_feature(values):\\n f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))\\n return f\\n\\n for i in range(100):\\n features = {}\\n input_ids = np.random.randint(100, size=(seq_length))\\n features['input_ids'] = create_int_feature(input_ids)\\n features['input_mask'] = create_int_feature(np.ones_like(input_ids))\\n features['segment_ids'] = create_int_feature(np.ones_like(input_ids))\\n features['label_ids'] = create_int_feature(\\n np.random.randint(10, size=(seq_length)))\\n if include_sentence_id:\\n features['sentence_id'] = create_int_feature([i])\\n features['sub_sentence_id'] = create_int_feature([0])\\n\\n tf_example = tf.train.Example(features=tf.train.Features(feature=features))\\n writer.write(tf_example.SerializeToString())\\n writer.close()\",\n \"def sample(self,f,N,p=100):\\n return [f(x) for x in np.linspace(0,N,p)]\",\n \"def _pds_plot_iterator(pds, dim, funcId):\\n i = 0\\n for (algname, ds) in pds.algds_dimfunc((dim, funcId)):\\n yield ('algorithm', algname, ds, _style_algorithm(algname, i))\\n i += 1\\n yield ('oracle', 'oracle', pds.oracle((dim, funcId)), _style_oracle())\\n yield ('unifpf', 'eUNIF', pds.unifpf().dictByDimFunc()[dim][funcId][0], _style_unifpf())\\n i = 0\\n for (stratname, ds) in pds.stratds_dimfunc((dim, funcId)):\\n yield ('strategy', stratname, ds, _style_strategy(stratname, i))\\n i += 1\",\n \"def process(dataset, f):\\n logger.info('processing dataset ({0})'.format(len(dataset.samples)))\\n for sample in dataset.samples:\\n sample.proc = f(sample.image)\",\n \"def test_draw_two(self):\\n f = txn_oracle.draw_two\\n\\n for _ in range(1000):\\n max_n = random.randint(4, 20)\\n i, j = f(max_n)\\n assert i != j\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_in(self, n_samples, start_sample=0):\\n pass\",\n \"def gen_ind_params(self, x, hist_cr, hist_f):\\n mi = self.integers(self.hist_mem_size) # a random pair of f cr is selected form historical memory\\n m_cr = hist_cr[mi]\\n m_f = hist_f[mi]\\n cr = self.normal(m_cr, 0.1) if m_cr != -1 else 0\\n # cr is randomised from normal distribution and then repaired if needed\\n cr = np.clip(cr, 0, 1)\\n f = self.cauchy(m_f, 0.1)\\n # f is randomised from cauchy distribution until the value is >0 and then repaired if needed\\n f = np.clip(f, 0, 1)\\n return self.individual_type(x=x.x, differential_weight=f, crossover_probability=cr, e=False)\",\n \"def make_art(functions, filename, lambdas, x_size=def_x_size, y_size=def_y_size):\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (color_map(evaluate_random_function(functions[0], x, y, lambdas)),\\n color_map(evaluate_random_function(functions[1], x, y, lambdas)),\\n color_map(evaluate_random_function(functions[2], x, y, lambdas)))\\n im.save(filename+\\\".png\\\")\",\n \"def count_and_draw(fileinfos, args, name=\\\"\\\"):\\n els_counted = count_items(fileinfos,\\\"el\\\",name)\\n atts_counted = count_items(fileinfos,\\\"att\\\",name)\\n draw_figure(els_counted, atts_counted, args, name)\",\n \"def idensity(n):\\n I = zeroes(n, n)\\n for i in range(n):\\n I.g[i][i] = 1.0\\n return I\",\n \"def plot_sample_imgs(get_imgs_fun, img_shape, plot_side=5, savepath=None, cmap='gray'):\\n f, axarr = plt.subplots(plot_side, plot_side)\\n samples = get_imgs_fun(plot_side*plot_side)\\n for row in range(plot_side):\\n for col in range(plot_side):\\n axarr[row, col].imshow(samples[plot_side*row+col].reshape(img_shape), cmap=cmap)\\n axarr[row, col].set_title('')\\n axarr[row, col].axis('off')\\n if savepath:\\n f.savefig(savepath)\\n plt.close()\\n else:\\n plt.show()\",\n \"def skim(lines, file):\\n for line in skim_generator(lines, file):\\n sys.stdout.write(line)\",\n \"def plot_obs_noise_dist(obs_fn, obs_noise, min_dist=0, max_dist=10):\\n x = np.linspace(min_dist, max_dist, 100)\\n y = [obs_fn(xi) for xi in x]\\n plt.plot(x, y)\\n plt.xlabel(\\\"Distance\\\")\\n plt.ylabel(\\\"Probability\\\")\\n plt.xlim((min_dist, max_dist))\\n plt.ylim((0, 1))\\n plt.axvline(x=obs_noise, color='red', alpha=0.7)\\n plt.annotate(\\\"Observation noise stddev\\\", xy=(obs_noise, 0))\",\n \"def drawSamples(self, numberOfSamples, from_where=\\\"image\\\"):\\n\\n #drawing n random numbers between 0 and 1\\n randomVector = np.random.random(int(numberOfSamples))\\n\\n #creating the CDF function by linearizing and normalizing the image\\n CDF = np.cumsum(self.blurred_image)/np.sum(self.blurred_image)\\n\\n #sample the CDF function\\n Indexes1D = np.searchsorted(CDF, randomVector)\\n Indexes2D = np.unravel_index(Indexes1D, self.blurred_image.shape)\\n\\n sampledPDF = np.zeros(self.blurred_image.shape)\\n\\n Indexes2D = list(zip(Indexes2D[0], Indexes2D[1]))\\n for (Idx, Idy) in Indexes2D:\\n sampledPDF[Idx, Idy] += 1\\n\\n return sampledPDF, Indexes2D\",\n \"def visualize_attention(test_seq, i,\\n model,\\n id2wrd, # word_index.\\n n):\\n \\n id2wrd = dict((v, k) for k, v in id2wrd.items()) # Exchange key with values.\\n\\n get_layer_output = K.function([model.layers[0].input, K.learning_phase()], [model.layers[4].output])\\n out = get_layer_output([test_seq, ])[0] # test mode\\n\\n att_w = model.layers[5].get_weights() # The attention layer is the sixth layer.\\n\\n eij = np.tanh(np.dot(out[i], att_w[0]))\\n# print(\\\"1 eij is ............\\\")\\n# print(eij)\\n ListToCSV(eij, 'eij.csv') # added by Shigang\\n ai = np.exp(eij)\\n# print(\\\"1 ai is ............\\\")\\n# print(ai)\\n ListToCSV(ai, 'ai.csv') # added by Shigang\\n weights = ai/np.sum(ai)\\n# print(\\\"1 weights is ............\\\")\\n# print(weights)\\n ListToCSV(weights, '1weights.csv') # added by Shigang\\n weights = np.sum(weights,axis=1)\\n# print(\\\"2 weights is ............\\\")\\n# print(weights)\\n ListToCSV(weights, '2weights.csv') # added by Shigang\\n topKeys = np.argpartition(weights,-n)[-n:]\\n\\n print (' '.join([id2wrd[wrd_id] for wrd_id in test_seq[i] if wrd_id != 0.]))\\n print ('--------------------------Attentive Words start: --------------------------------------')\\n \\n for k in test_seq[i][topKeys]:\\n if k != 0.:\\n print (id2wrd[k])\\n print ('--------------------------Attentive Words end: --------------------------------------')\\n \\n return\",\n \"def batch_process(minID, maxID, side='blue', **kwargs):\\r\\n\\r\\n if side == 'both':\\r\\n sides = ['blue','red']\\r\\n else:\\r\\n sides = [side]\\r\\n for side in sides:\\r\\n for i in range(minID, maxID+1, 1):\\r\\n filename = '%s%04d.fits' % (side, i)\\r\\n if os.path.exists(filename):\\r\\n try:\\r\\n extract1D(i, side=side, **kwargs)\\r\\n except iraf.IrafError:\\r\\n # some errors just require you to try again...\\r\\n print 'Hit error, retrying...'\\r\\n extract1D(i, side=side, **kwargs)\",\n \"def GenId(self, func=None, *param):\\n\\tcurrent_count = 0\\n\\told_time = self.GenerateTime()\\n\\twhile True:\\t\\n\\t current_count += 1\\n\\t if self.GenerateTime() != old_time:\\n\\t\\tcurrent_count = 0\\n\\t old_time = self.GenerateTime()\\n\\t CurrentId = format(current_count, 11)\\n\\t #id = str(int(self.GenerateTime(), 2) + int(self.GenDistinctId(), 2) + int(CurrentId, 2))\\n\\t id = str(int(self.GenerateTime(), 2)) + str(int(self.GenDistinctId(), 2)) + str(int(CurrentId, 2))\\n\\t yield(func(id, *param))\",\n \"def repeat(fn):\\n def repeated():\\n i = 0\\n while i < random_test_iterations:\\n fn()\\n i += 1\\n # nosetest runs functions that start with 'test_'\\n repeated.__name__ = fn.__name__\\n return repeated\",\n \"def testing_input_fn():\\n dataset = tf.data.Dataset.range(len(cube_features))\\n dataset = dataset.batch(16)\\n dataset = dataset.map(mapping_function)\\n return dataset\",\n \"def function_uuid():\\r\\n yield uuid.uuid4()\",\n \"def input_fn_builder(features, seq_length):\\n\\n all_label_ids = []\\n all_input_ids = []\\n all_input_mask = []\\n all_segment_ids = []\\n\\n for feature in features:\\n all_label_ids.append(feature.label_ids)\\n all_input_ids.append(feature.input_ids)\\n all_input_mask.append(feature.input_mask)\\n all_segment_ids.append(feature.segment_ids)\\n\\n def input_fn(params):\\n \\\"\\\"\\\"The actual input function.\\\"\\\"\\\"\\n batch_size = params[\\\"batch_size\\\"]\\n\\n num_examples = len(features)\\n\\n # This is for demo purposes and does NOT scale to large data sets. We do\\n # not use Dataset.from_generator() because that uses tf.py_func which is\\n # not TPU compatible. The right way to load data is with TFRecordReader.\\n d = tf.data.Dataset.from_tensor_slices(\\n {\\n \\\"label_ids\\\": tf.constant(\\n all_label_ids, shape=[num_examples], dtype=tf.int32\\n ),\\n \\\"input_ids\\\": tf.constant(\\n all_input_ids, shape=[num_examples, seq_length], dtype=tf.int32\\n ),\\n \\\"input_mask\\\": tf.constant(\\n all_input_mask, shape=[num_examples, seq_length], dtype=tf.int32\\n ),\\n \\\"segment_ids\\\": tf.constant(\\n all_segment_ids, shape=[num_examples, seq_length], dtype=tf.int32\\n ),\\n }\\n )\\n\\n d = d.batch(batch_size=batch_size, drop_remainder=False)\\n return d\\n\\n return input_fn\",\n \"def draw_bs_pairs(x, y, func, size=1):\\n\\n # Set up array of indices to sample from: inds\\n inds = np.arange(len(x))\\n\\n # Initialize replicates: bs_replicates\\n bs_replicates = np.empty(size)\\n\\n # Generate replicates\\n for i in range(size):\\n bs_inds = np.random.choice(inds,size=len(inds))\\n bs_x, bs_y = x[bs_inds],y[bs_inds]\\n bs_replicates[i] = func(bs_x,bs_y)\\n\\n return bs_replicates\",\n \"def example_generator(self, mode: str):\\n raise NotImplementedError\",\n \"def generate_identifiers(training_file):\\r\\n with open('identifiers.csv', mode='r') as identifier_file, open('new_identifiers.csv', mode='w', newline='') as new_identifier_file:\\r\\n reader = csv.reader(identifier_file, delimiter=',')\\r\\n for row in reader:\\r\\n show = row[0]\\r\\n\\r\\n # generate a corpus for only the desired show\\r\\n dataset = generate_corpus(show, training_file)\\r\\n\\r\\n dct = Dictionary(dataset)\\r\\n\\r\\n # Create a tfidf model to evaluate word rank\\r\\n corpus = [dct.doc2bow(line) for line in dataset]\\r\\n tfidf_model = TfidfModel(corpus)\\r\\n\\r\\n tfidf_freq = {}\\r\\n for doc in tfidf_model[corpus]:\\r\\n for id, freq in doc:\\r\\n tfidf_freq[dct[id]] = freq\\r\\n \\r\\n tfidf_freq = sorted(tfidf_freq.items(), key=lambda x: x[1], reverse=True)\\r\\n\\r\\n for word, freq in tfidf_freq[:500]:\\r\\n print('%s, %s' % (word, freq), end='\\\\n')\\r\\n\\r\\n writer = csv.writer(new_identifier_file, delimiter=',')\\r\\n keywords = []\\r\\n for word, freq in tfidf_freq[:10]:\\r\\n keywords.append(word)\\r\\n writer.writerow([show, \\\";\\\".join(keywords)])\",\n \"def test_plot_insertion_indices(mock_plot, sampler, filename):\\n nlive = 10\\n indices = list(range(20))\\n sampler.nlive = nlive\\n sampler.insertion_indices = indices\\n fig = NestedSampler.plot_insertion_indices(\\n sampler, filename=filename, k=True\\n )\\n assert fig == \\\"fig\\\"\\n mock_plot.assert_called_once_with(\\n indices, nlive, filename=filename, k=True\\n )\",\n \"def create_input(ids):\\n\\n df = ids.copy()\\n df = create_dataframes_with_features(df)\\n lines = to_vwlines(df)\\n\\n # release memory\\n df = None \\n gc.collect()\\n return lines\",\n \"def plot_sample_imgs(get_imgs_fun, img_shape, plot_side=5, savepath=None):\\n f, axarr = plt.subplots(plot_side, plot_side)\\n samples = get_imgs_fun(plot_side*plot_side)\\n for row in range(plot_side):\\n for col in range(plot_side):\\n axarr[row, col].imshow(samples[plot_side*row+col].reshape(img_shape))\\n axarr[row, col].set_title('')\\n axarr[row, col].axis('off')\\n if savepath:\\n f.savefig(savepath)\\n plt.close()\\n else:\\n plt.show()\",\n \"def draw_250():\\r\\n red = 0\\r\\n grn = 0\\r\\n arr = urn_setup()\\r\\n for v in range(250):\\r\\n n = np.random.randint(0,len(arr))\\r\\n x, arr = draw_remove_element(arr, np.random.randint(0,len(arr)))\\r\\n if x == 'R':\\r\\n red += 1\\r\\n elif x == 'G':\\r\\n grn += 1\\r\\n print(\\\"Red: %d :: Grn: %d\\\" % (red, grn))\\r\\n return red, grn\",\n \"def draw():\",\n \"def generate_synth_data(n):\",\n \"def map_ids(x, indices, map_fn):\\n indices = tf.reshape(indices, [-1])\\n\\n t_i = tf.constant(0)\\n # batch_coordinates start at 0\\n t_batch_size = tf.reduce_max(indices) + 1\\n\\n # ta_stack_out will store the intermediate results for each individual id\\n # As alternative to tf.TensorArray, scatter_update could potentially be used\\n # but that would require an additional mutable tensor.\\n ta_stack_out = tf.TensorArray(\\n x.dtype,\\n size=t_batch_size,\\n )\\n\\n # Then we iterate over each sequence individually and compute the\\n # transformation for each id\\n while_condition = lambda t_i, *args: tf.less(t_i, t_batch_size)\\n\\n def body(t_i, ta_stack_out):\\n \\\"\\\"\\\"Loop body.\\\"\\\"\\\"\\n # Gather the ids\\n current_ids = tf.to_int32(tf.where(tf.equal(indices, t_i)))\\n t_row = tf.gather_nd(x, indices=current_ids)\\n\\n # TODO(epot): Should not call map_fn if t_row size is 0\\n\\n # Apply transformation to each id\\n # Restore batch_dim=1 as most function expect [batch_dim, length, ...] as\\n # input\\n t_row = tf.expand_dims(t_row, axis=0)\\n t_row = map_fn(t_row)\\n t_row = tf.squeeze(t_row, axis=0) # Squeeze for concatenation\\n ta_stack_out = ta_stack_out.write(t_i, t_row)\\n\\n return [tf.add(t_i, 1), ta_stack_out] # ++i\\n\\n # Run the loop, equivalent to:\\n # stack_out = []\\n # while i < batch_size:\\n # stack_out.expand(map_fn(x[indices==i]))\\n _, ta_stack_out = tf.while_loop(while_condition, body, [t_i, ta_stack_out])\\n\\n # Merge all results\\n return ta_stack_out.concat()\",\n \"def draw_samplers(self):\\n raise NotImplementedError(\\\" The draw_samplers() method has not been implemented \\\")\",\n \"def input_fn(filenames, batch_size, num_epochs): \\n # Create a dataset out of the raw TFRecord file. See the Data Generator for more\\n dataset = tf.contrib.data.TFRecordDataset(filenames)\\n # Map the tf.example to tensor using the _parse_function\\n dataset = dataset.map(_parse_function, num_threads=4)\\n # Create an arbitrary bucket range.\\n buckets = [tf.constant(num, dtype=tf.int64) for num in range(0, 500, 15)]\\n # Number of elements per bucket.\\n window_size = 1000\\n # Group the dataset according to a bucket key (see bucketing_fn).\\n # Every element in the dataset is attributed a key (here a bucket id)\\n # The elements are then bucketed according to these keys. A group of \\n # `window_size` having the same keys are given to the reduc_fn. \\n dataset = dataset.group_by_window(\\n lambda x, y, z: bucketing_fn(x, buckets), \\n lambda key, x: reduc_fn(key, x, window_size), window_size)\\n # We now have buckets of `window_size` size, let's batch and pad them\\n dataset = dataset.padded_batch(batch_size, padded_shapes=(\\n tf.TensorShape([]), tf.TensorShape([]), tf.Dimension(None)))\\n dataset = dataset.map(lambda x, y, z: \\n ({\\\"sentence\\\":z, \\\"sequence_length\\\":x}, y))\\n # Repeat the dataset for a given number of epoch\\n dataset = dataset.repeat(num_epochs)\\n # Create the iterator to enumerate the elements of the dataset.\\n iterator = dataset.make_one_shot_iterator()\\n # Generator returned by the iterator.\\n features, labels = iterator.get_next()\\n return features, labels\",\n \"def cifar_iid(dataset, num_users):\\n print(\\\"Sampling dataset: CIFAR-10 IID\\\")\\n num_items = int(len(dataset)/num_users)\\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\\n for i in range(num_users):\\n dict_users[i] = set(np.random.choice(all_idxs, num_items, replace=False))\\n all_idxs = list(set(all_idxs) - dict_users[i])\\n return dict_users\",\n \"def input_fn(params):\\n\\n batch_size = params[\\\"batch_size\\\"]\\n output_buffer_size = batch_size * 1000\\n\\n def extract_fn(data_record):\\n features = {\\n \\\"query_ids\\\": tf.FixedLenSequenceFeature(\\n [], tf.int64, allow_missing=True),\\n \\\"doc_ids\\\": tf.FixedLenSequenceFeature(\\n [], tf.int64, allow_missing=True),\\n \\\"label\\\": tf.FixedLenFeature([], tf.int64),\\n }\\n sample = tf.parse_single_example(data_record, features)\\n\\n query_ids = tf.cast(sample[\\\"query_ids\\\"], tf.int32)\\n doc_ids = tf.cast(sample[\\\"doc_ids\\\"], tf.int32)\\n label_ids = tf.cast(sample[\\\"label\\\"], tf.int32)\\n input_ids = tf.concat((query_ids, doc_ids), 0)\\n\\n query_segment_id = tf.zeros_like(query_ids)\\n doc_segment_id = tf.ones_like(doc_ids)\\n segment_ids = tf.concat((query_segment_id, doc_segment_id), 0)\\n\\n input_mask = tf.ones_like(input_ids)\\n\\n features = {\\n \\\"input_ids\\\": input_ids,\\n \\\"segment_ids\\\": segment_ids,\\n \\\"input_mask\\\": input_mask,\\n \\\"label_ids\\\": label_ids,\\n }\\n return features\\n\\n dataset = tf.data.TFRecordDataset([dataset_path])\\n dataset = dataset.map(\\n extract_fn, num_parallel_calls=4).prefetch(output_buffer_size)\\n\\n if is_training:\\n dataset = dataset.repeat()\\n dataset = dataset.shuffle(buffer_size=1000)\\n else:\\n if max_eval_examples:\\n # Use at most this number of examples (debugging only).\\n dataset = dataset.take(max_eval_examples)\\n # pass\\n\\n dataset = dataset.padded_batch(\\n batch_size=batch_size,\\n padded_shapes={\\n \\\"input_ids\\\": [seq_length],\\n \\\"segment_ids\\\": [seq_length],\\n \\\"input_mask\\\": [seq_length],\\n \\\"label_ids\\\": [],\\n },\\n padding_values={\\n \\\"input_ids\\\": 0,\\n \\\"segment_ids\\\": 0,\\n \\\"input_mask\\\": 0,\\n \\\"label_ids\\\": 0,\\n },\\n drop_remainder=True)\\n\\n return dataset\",\n \"def draw_strat_sample(self, T, n, excl_idxs=None):\\n\\n if n == 0:\\n return np.array([], dtype=np.uint)\\n\\n if T.size == n: # TODO: this only works if excl_idxs=None\\n return np.arange(n)\\n\\n if n == 1:\\n idxs_all_non_excl = np.setdiff1d(\\n np.arange(T.size), excl_idxs, assume_unique=True\\n )\\n return np.array([np.random.choice(idxs_all_non_excl)])\\n\\n # Freedman-Diaconis rule\\n h = 2 * np.subtract(*np.percentile(T, [75, 25])) / np.cbrt(n)\\n n_bins = int(np.ceil((np.max(T) - np.min(T)) / h)) if h > 0 else 1\\n n_bins = min(\\n n_bins, n / 2\\n ) # Limit number of bins to half of requested subset size.\\n\\n bins = np.linspace(np.min(T), np.max(T), n_bins, endpoint=False)\\n idxs = np.digitize(T, bins)\\n\\n # Exclude restricted indices.\\n if excl_idxs is not None and excl_idxs.size > 0:\\n idxs[excl_idxs] = n_bins + 1 # Impossible bin.\\n\\n uniq_all, cnts_all = np.unique(idxs, return_counts=True)\\n\\n # Remove restricted bin.\\n if excl_idxs is not None and excl_idxs.size > 0:\\n excl_bin_idx = np.where(uniq_all == n_bins + 1)\\n cnts_all = np.delete(cnts_all, excl_bin_idx)\\n uniq_all = np.delete(uniq_all, excl_bin_idx)\\n\\n # Compute reduced bin counts.\\n reduced_cnts = np.ceil(cnts_all / np.sum(cnts_all, dtype=float) * n).astype(int)\\n reduced_cnts = np.minimum(\\n reduced_cnts, cnts_all\\n ) # limit reduced_cnts to what is available in cnts_all\\n\\n # Reduce/increase bin counts to desired total number of points.\\n reduced_cnts_delta = n - np.sum(reduced_cnts)\\n\\n while np.abs(reduced_cnts_delta) > 0:\\n\\n # How many members can we remove from an arbitrary bucket, without any bucket with more than one member going to zero?\\n max_bin_reduction = np.min(reduced_cnts[np.where(reduced_cnts > 1)]) - 1\\n\\n # Generate additional bin members to fill up/drain bucket counts of subset. This array contains (repeated) bucket IDs.\\n outstanding = np.random.choice(\\n uniq_all,\\n min(max_bin_reduction, np.abs(reduced_cnts_delta)),\\n p=(reduced_cnts - 1) / np.sum(reduced_cnts - 1, dtype=float),\\n )\\n uniq_outstanding, cnts_outstanding = np.unique(\\n outstanding, return_counts=True\\n ) # Aggregate bucket IDs.\\n\\n outstanding_bucket_idx = np.where(\\n np.in1d(uniq_all, uniq_outstanding, assume_unique=True)\\n )[\\n 0\\n ] # Bucket IDs to Idxs.\\n reduced_cnts[outstanding_bucket_idx] += (\\n np.sign(reduced_cnts_delta) * cnts_outstanding\\n )\\n reduced_cnts_delta = n - np.sum(reduced_cnts)\\n\\n # Draw examples for each bin.\\n idxs_train = np.empty((0,), dtype=int)\\n for uniq_idx, bin_cnt in zip(uniq_all, reduced_cnts):\\n idx_in_bin_all = np.where(idxs.ravel() == uniq_idx)[0]\\n idxs_train = np.append(\\n idxs_train, np.random.choice(idx_in_bin_all, bin_cnt, replace=False)\\n )\\n return idxs_train\",\n \"def draw(self, state):\\n\\n def sample(s):\\n return self._rng.choice(\\n self.transition_matrix.shape[1], p=self.transition_matrix[s, :]\\n )\\n\\n array_sample = np.frompyfunc(sample, 1, 1)\\n\\n return array_sample(state)\",\n \"def draw(self, nsamples):\\n \\n if self.dist == 'normal':\\n mean = self.mean\\n sd = self.sd\\n self.sample = sd * np.random.randn(nsamples) + mean\\n \\n elif self.dist == 'poisson':\\n lam = self.lam\\n self.sample = np.random.poisson(lam, size=nsamples)\\n \\n elif self.dist == 'binomial':\\n n = self.n\\n p = self.p\\n self.sample = np.random.binomial(n, p, size=nsamples)\\n \\n else:\\n print('dist must be normal, poisson or binomial')\",\n \"def input_fn(is_training, data_dir, reid_data_dir= None,batch_size=32, num_epochs=1):\\n dataset = tf.data.Dataset.from_tensor_slices(get_filenames(is_training, data_dir))\\n dataset_seg = dataset.flat_map(tf.data.TFRecordDataset)\\n\\n # dataset_reid = tf.data.Dataset.from_tensor_slices(get_filenames_reid(is_training, reid_data_dir))\\n # dataset_reid = dataset_reid.flat_map(tf.data.TFRecordDataset)\\n\\n\\n if is_training:\\n # When choosing shuffle buffer sizes, larger sizes result in better\\n # randomness, while smaller sizes have better performance.\\n # is a relatively small dataset, we choose to shuffle the full epoch.\\n dataset_seg = dataset_seg.shuffle(buffer_size=_NUM_IMAGES['train'])\\n # dataset_reid = dataset_reid.shuffle(buffer_size=30248)\\n\\n\\n dataset_seg = dataset_seg.map(parse_record)\\n dataset_seg = dataset_seg.map(lambda image, label: preprocess_image(image, label, is_training))\\n dataset_seg = dataset_seg.prefetch(batch_size)\\n dataset_seg = dataset_seg.repeat(num_epochs)\\n dataset_seg = dataset_seg.batch(batch_size)\\n\\n # dataset_reid = dataset_reid.map(parse_record_reid)\\n # dataset_reid = dataset_reid.map(lambda image, label: preprocess_image_reid(image, label, is_training))\\n # dataset_reid = dataset_reid.prefetch(batch_size)\\n # dataset_reid = dataset_reid.repeat(num_epochs)\\n # dataset_reid = dataset_reid.batch(batch_size)\\n\\n # iterator = dataset_reid.make_one_shot_iterator()\\n # images_reid, label_reid = iterator.get_next()\\n\\n train_record_file = os.path.join(reid_data_dir, 'train-512-170.tfrecords')\\n val_record_file = os.path.join(reid_data_dir, 'val-512-170.tfrecords')\\n\\n train_images, train_labels = read_records(train_record_file, _HEIGHT, _WIDTH, type='normalization')\\n train_images_batch, train_labels_batch = get_batch_images(train_images, train_labels,\\n batch_size=batch_size, labels_nums=labels_nums,\\n one_hot=True, shuffle=True)\\n print(\\\"reid2222222\\\", train_images_batch.shape, train_labels_batch.shape)\\n val_images, val_labels = read_records(val_record_file, _HEIGHT, _WIDTH, type='normalization')\\n val_images_batch, val_labels_batch = get_batch_images(val_images, val_labels,\\n batch_size=batch_size, labels_nums=labels_nums,\\n one_hot=True, shuffle=False)\\n images_reid = train_images_batch\\n label_reid = train_labels_batch\\n # if is_training:\\n # images_reid = train_images_batch\\n # label_reid = train_labels_batch\\n # else:\\n # images_reid = val_images_batch\\n # label_reid = val_labels_batch\\n iterator = dataset_seg.make_one_shot_iterator()\\n images_seg, label_seg = iterator.get_next()\\n\\n images = {\\\"seg\\\": images_seg, \\\"reid\\\": images_reid}\\n labels = {\\\"seg\\\": label_seg, \\\"reid\\\": label_reid}\\n\\n # labels_seg_reid = tf.zeros(shape=[batch_size, labels_nums], dtype=tf.int32)\\n # labels_reid_seg = tf.zeros(shape=[batch_size, 512, 170, 1], dtype=tf.int32)\\n\\n # images = tf.concat([images_seg, images_reid], 0)\\n # labels_seg_all = tf.concat([label_seg, labels_reid_seg], 0)\\n # labels_reid_all = tf.concat([labels_seg_reid, label_reid], 0)\\n # labels = {\\\"seg\\\": labels_seg_all, \\\"reid\\\": labels_reid_all}\\n # batch_out= 1\\n\\n return images, labels\",\n \"def export_sample_indications(args):\\n clarity_epp.export.sample.sample_indications(\\n lims, args.output_file, args.artifact_name, args.sequencing_run, args.sequencing_run_project\\n )\",\n \"def new_func():\\n dirname, _ = os.path.split(os.path.abspath(__file__))\\n pngfile = os.path.sep.join([dirname, \\\"out.png\\\"])\\n img = [\\\"110010010011\\\", \\\"101011010100\\\", \\\"110010110101\\\", \\\"100010010011\\\"]\\n img = [[int(val) for val in value] for value in img]\\n writer = png.Writer(len(img[0]), len(img), greyscale=True, bitdepth=16)\\n with open(pngfile, \\\"wb\\\") as file:\\n writer.write(file, img)\\n try:\\n func(pngfile)\\n finally:\\n os.remove(pngfile)\",\n \"def __call__(self, samples_number):\\n self.sampler.sample(samples_number)\",\n \"def test_sampling(self):\\n dim = Fidelity(\\\"epoch\\\", 1, 2)\\n assert dim.sample() == [2]\\n dim = Fidelity(\\\"epoch\\\", 1, 5)\\n assert dim.sample() == [5]\\n dim = Fidelity(\\\"epoch\\\", 1, 5)\\n assert dim.sample(4) == [5] * 4\",\n \"def input_fn(params):\\n batch_size = params[\\\"batch_size\\\"]\\n\\n num_examples = len(features)\\n\\n d = tf.data.Dataset.from_tensor_slices({\\n \\\"input_ids\\\":\\n tf.constant(\\n all_input_ids, shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"input_mask\\\":\\n tf.constant(\\n all_input_mask,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"segment_ids\\\":\\n tf.constant(\\n all_segment_ids,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"label_ids\\\":\\n tf.constant(all_label_ids, shape=[num_examples, len(LABEL_COLUMNS)], dtype=tf.int32),\\n })\\n\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\\n return d\",\n \"def input_fn_builder(features, seq_length):\\n\\n all_unique_ids = []\\n all_input_ids = []\\n all_input_mask = []\\n all_input_type_ids = []\\n\\n for feature in features:\\n all_unique_ids.append(feature.unique_id)\\n all_input_ids.append(feature.input_ids)\\n all_input_mask.append(feature.input_mask)\\n all_input_type_ids.append(feature.input_type_ids)\\n\\n def input_fn(params):\\n \\\"\\\"\\\"The actual input function.\\\"\\\"\\\"\\n batch_size = params[\\\"batch_size\\\"]\\n\\n num_examples = len(features)\\n\\n # This is for demo purposes and does NOT scale to large data sets. We do\\n # not use Dataset.from_generator() because that uses tf.py_func which is\\n # not TPU compatible. The right way to load data is with TFRecordReader.\\n d = tf.data.Dataset.from_tensor_slices({\\n \\\"unique_ids\\\":\\n tf.constant(all_unique_ids, shape=[num_examples], dtype=tf.int32),\\n \\\"input_ids\\\":\\n tf.constant(all_input_ids, \\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"input_mask\\\":\\n tf.constant(all_input_mask,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"input_type_ids\\\":\\n tf.constant(all_input_type_ids,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n })\\n\\n d = d.batch(batch_size=batch_size, drop_remainder=False)\\n return d\\n\\n return input_fn\",\n \"def test(model,gen,n_id,threshold=0.5,verbose=True,print_every_n=10):\\n t_start = time()\\n ce_avg,tp,tn,fp,fn = 0.,0.,0.,0.,0.\\n for i in range(n_id):\\n X_test,y_test = gen.next()\\n y_test = y_test.mean()\\n Y_pred = model.predict(X_test)\\n y_pred = Y_pred.max(axis=0)\\n ce = np.mean(- y_test * np.log(y_pred) - (1-y_test) * np.log(1-y_pred))\\n ce_avg += ce/n_id\\n y_predr = y_pred.round()\\n tp += sum((y_test == 1) & (y_predr == 1))\\n tn += sum((y_test == 0) & (y_predr == 0))\\n fp += sum((y_test == 0) & (y_predr == 1))\\n fn += sum((y_test == 1) & (y_predr == 0))\\n if i % print_every_n == 0:\\n print(i)\\n prec,recall,acc = tp/(tp+fp+1e-15),tp/(tp+fn+1e-15),(tp+tn)/n_id\\n F1 = 2*tp/(2*tp+fp+fn)\\n if verbose:\\n print('Valid F1 %.3f tp %.3f tn %.3f fp %.3f fn %.3f' % (F1,tp,tn,fp,fn))\\n print('Took %.1fs' % (time()-t_start))\\n return(ce_avg,prec,recall,F1,acc,tp,tn,fp,fn)\",\n \"def input_fn(dir):\\r\\n\\r\\n dataset = tf.data.Dataset.list_files(dir+\\\"*.tif\\\")\\r\\n dataset = dataset.shuffle(buffer_size=shuffle_buffer_size)\\r\\n dataset = dataset.map(\\r\\n lambda file: tuple(tf.py_func(parser, [file, dir], [tf.float32, tf.float32])),\\r\\n num_parallel_calls=num_parallel_calls)\\r\\n #dataset = dataset.batch(batch_size=batch_size)\\r\\n dataset = dataset.prefetch(buffer_size=prefetch_buffer_size)\\r\\n dataset = dataset.repeat(num_epochs)\\r\\n \\r\\n iter = dataset.make_one_shot_iterator()\\r\\n\\r\\n lq, img = iter.get_next()\\r\\n\\r\\n return lq, img\",\n \"def input_fn(params):\\n\\t\\tbatch_size = params[\\\"batch_size\\\"]\\n\\t\\toutput_buffer_size = batch_size * 1000\\n\\t\\tmax_seq_len = {0: max_q_len, 1:max_p_len}\\n\\n\\n\\t\\tdef extract_fn(data_record):\\n\\t\\t\\tif is_training:\\n\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc_ids0\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc_ids1\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\n\\t\\t\\t\\traw_query_ids = tf.cast(sample[\\\"raw_query_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\traw_query_segment_ids = tf.cast(sample[\\\"raw_query_segment_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\traw_query_mask = tf.ones_like(raw_query_ids)\\n\\t\\t\\t\\t# effective_raw_query_mask = tf.ones_like(query_ids)\\n\\t\\t\\t\\teffective_raw_query_mask = tf.cast(sample[\\\"raw_query_mask\\\"][:max_q_len], tf.int32)\\n\\n\\t\\t\\t\\trewrite_query_ids = tf.cast(sample[\\\"rewrite_query_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\trewrite_query_segment_ids = tf.cast(sample[\\\"rewrite_query_segment_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\trewrite_query_mask = tf.ones_like(rewrite_query_ids)\\n\\t\\t\\t\\teffective_rewrite_query_mask = tf.cast(sample[\\\"rewrite_query_mask\\\"][:max_q_len], tf.int32)\\n\\n\\n\\t\\t\\t\\tdoc0_ids = tf.cast(sample[\\\"doc_ids0\\\"][:max_p_len], tf.int32)\\n\\t\\t\\t\\tdoc0_segment_ids = tf.zeros_like(doc0_ids)\\n\\t\\t\\t\\tdoc0_mask = tf.ones_like(doc0_ids)\\n\\t\\t\\t\\teffective_doc0_mask = tf.ones_like(doc0_ids)\\n\\n\\n\\t\\t\\t\\tdoc1_ids = tf.cast(sample[\\\"doc_ids1\\\"][:max_p_len], tf.int32)\\n\\t\\t\\t\\tdoc1_segment_ids = tf.zeros_like(doc1_ids)\\n\\t\\t\\t\\tdoc1_mask = tf.ones_like(doc1_ids)\\n\\t\\t\\t\\teffective_doc1_mask = tf.ones_like(doc1_ids)\\n\\n\\n\\t\\t\\t\\tlabel = tf.cast(sample[\\\"label\\\"], tf.float32)\\n\\n\\n\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": raw_query_ids,\\n\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": raw_query_segment_ids,\\n\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": raw_query_mask,\\n\\t\\t\\t\\t\\t\\\"effective_raw_query_mask\\\": effective_raw_query_mask,\\n\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": rewrite_query_ids,\\n\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": rewrite_query_segment_ids,\\n\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": rewrite_query_mask,\\n\\t\\t\\t\\t\\t\\\"effective_rewrite_query_mask\\\": effective_rewrite_query_mask,\\n\\t\\t\\t\\t\\t\\\"doc0_ids\\\": doc0_ids,\\n\\t\\t\\t\\t\\t\\\"doc0_segment_ids\\\": doc0_segment_ids,\\n\\t\\t\\t\\t\\t\\\"doc0_mask\\\": doc0_mask,\\n\\t\\t\\t\\t\\t\\\"effective_doc0_mask\\\": effective_doc0_mask,\\n\\t\\t\\t\\t\\t\\\"doc1_ids\\\": doc1_ids,\\n\\t\\t\\t\\t\\t\\\"doc1_segment_ids\\\": doc1_segment_ids,\\n\\t\\t\\t\\t\\t\\\"doc1_mask\\\": doc1_mask,\\n\\t\\t\\t\\t\\t\\\"effective_doc1_mask\\\": effective_doc1_mask,\\n\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif is_output:\\n\\t\\t\\t\\t\\tif doc_type==0:\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"query_id\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\t\\t\\t\\t\\t\\tinput_ids = tf.cast(sample[\\\"raw_query_ids\\\"][:max_seq_len[doc_type]], tf.int32)\\n\\t\\t\\t\\t\\t\\tsegment_ids = tf.cast(sample[\\\"raw_query_segment_ids\\\"][:max_seq_len[doc_type]], tf.int32)\\n\\t\\t\\t\\t\\t\\tinput_mask = tf.ones_like(input_ids)\\n\\t\\t\\t\\t\\t\\teffective_input_mask = tf.cast(sample[\\\"raw_query_mask\\\"][:max_seq_len[doc_type]], tf.int32)\\n\\t\\t\\t\\t\\t\\tdocid = tf.cast(sample[\\\"query_id\\\"], tf.int32)\\n\\t\\t\\t\\t\\t\\tlabel = tf.cast(0, tf.int32) #dummy\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": input_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": segment_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": effective_input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": docid,\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telif doc_type==1:\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\t\\t\\t\\t\\t\\tdoc_ids = sample[\\\"doc_ids\\\"][:max_seq_len[doc_type]]\\n\\n\\t\\t\\t\\t\\t\\tinput_ids = tf.cast(doc_ids, tf.int32)\\n\\t\\t\\t\\t\\t\\tsegment_ids = tf.zeros_like(input_ids)\\n\\t\\t\\t\\t\\t\\tinput_mask = tf.ones_like(input_ids)\\n\\t\\t\\t\\t\\t\\tdocid = tf.cast(sample[\\\"docid\\\"], tf.int32)\\n\\t\\t\\t\\t\\t\\tlabel = tf.cast(0, tf.int32) #dummy\\n\\t\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": input_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": segment_ids,\\n\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": input_mask,\\n\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": docid,\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\telif is_eval:\\n\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"doc_ids\\\": tf.FixedLenSequenceFeature(\\n\\t\\t\\t\\t\\t\\t\\t[], tf.int64, allow_missing=True),\\n\\t\\t\\t\\t\\t\\t\\\"label\\\": tf.FixedLenFeature([], tf.int64),\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tsample = tf.parse_single_example(data_record, features)\\n\\n\\t\\t\\t\\t\\tquery_ids = tf.cast(sample[\\\"query_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\t\\tquery_segment_ids = tf.cast(sample[\\\"query_segment_ids\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\t\\t# query_segment_ids = tf.zeros_like(query_ids)\\n\\t\\t\\t\\t\\tquery_mask = tf.ones_like(query_ids)\\n\\t\\t\\t\\t\\teffective_query_mask = tf.cast(sample[\\\"query_mask\\\"][:max_q_len], tf.int32)\\n\\t\\t\\t\\t\\t# effective_query_mask = tf.ones_like(query_ids)\\n\\n\\t\\t\\t\\t\\tdocx_ids = tf.cast(sample[\\\"doc_ids\\\"][:max_p_len], tf.int32)\\n\\t\\t\\t\\t\\tdocx_segment_ids = tf.zeros_like(docx_ids)\\n\\t\\t\\t\\t\\tdocx_mask = tf.ones_like(docx_ids)\\n\\t\\t\\t\\t\\teffective_docx_mask = tf.ones_like(docx_ids)\\n\\n\\n\\t\\t\\t\\t\\tlabel = tf.cast(sample[\\\"label\\\"], tf.int32)\\n\\n\\t\\t\\t\\t\\tfeatures = {\\n\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": query_ids,\\n\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": query_segment_ids,\\n\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": query_mask,\\n\\t\\t\\t\\t\\t\\t\\\"effective_query_mask\\\": effective_query_mask,\\n\\t\\t\\t\\t\\t\\t\\\"docx_ids\\\": docx_ids,\\n\\t\\t\\t\\t\\t\\t\\\"docx_segment_ids\\\": docx_segment_ids,\\n\\t\\t\\t\\t\\t\\t\\\"docx_mask\\\": docx_mask,\\n\\t\\t\\t\\t\\t\\t\\\"effective_docx_mask\\\": effective_docx_mask,\\n\\t\\t\\t\\t\\t\\t\\\"label\\\": label,\\n\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\treturn features\\n\\n\\t\\tdataset = tf.data.TFRecordDataset([dataset_path])\\n\\t\\tdataset = dataset.map(\\n\\t\\t\\textract_fn, num_parallel_calls=4).prefetch(output_buffer_size)\\n\\n\\t\\tif is_training:\\n\\t\\t\\tdataset = dataset.repeat()\\n\\t\\t\\tdataset = dataset.shuffle(buffer_size=1000)\\n\\t\\t\\tdataset = dataset.padded_batch(\\n\\t\\t\\t\\t\\t\\tbatch_size=batch_size,\\n\\t\\t\\t\\t\\t\\tpadded_shapes={\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_raw_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_rewrite_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_segment_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc0_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_segment_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc1_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": []\\n\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\tpadding_values={\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"raw_query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_raw_query_mask\\\":0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"rewrite_query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_rewrite_query_mask\\\":0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc0_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc0_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"doc1_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"effective_doc1_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": 0.0,\\n\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\tdrop_remainder=True)\\n\\t\\telse:\\n\\t\\t\\tif max_eval_examples:\\n\\t\\t\\t\\t# Use at most this number of examples (debugging only).\\n\\t\\t\\t\\tdataset = dataset.take(max_eval_examples)\\n\\t\\t\\tif is_output:\\n\\t\\t\\t\\tdataset = dataset.padded_batch(\\n\\t\\t\\t\\t\\t\\t\\tbatch_size=batch_size,\\n\\t\\t\\t\\t\\t\\t\\tpadded_shapes={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": [max_seq_len[doc_type]],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": [],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": [],\\n\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\tpadding_values={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"input_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_input_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"docid\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\tdrop_remainder=True)\\n\\n\\t\\t\\telif is_eval:\\n\\t\\t\\t\\tdataset = dataset.padded_batch(\\n\\t\\t\\t\\t\\t\\t\\t\\tbatch_size=batch_size,\\n\\t\\t\\t\\t\\t\\t\\t\\tpadded_shapes={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_query_mask\\\": [max_q_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_segment_ids\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_docx_mask\\\": [max_p_len],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": []\\n\\t\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\t\\tpadding_values={\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_query_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_segment_ids\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"docx_mask\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"effective_docx_mask\\\":0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"label\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\t\\t\\t\\tdrop_remainder=True)\\n\\t\\treturn dataset\",\n \"def input_fn_builder(features, seq_length, is_training, drop_remainder):\\n \\\"\\\"\\\"This is used to make the proper format of the prediction variable\\\"\\\"\\\"\\n\\n all_input_ids = []\\n all_input_mask = []\\n all_segment_ids = []\\n all_label_ids = []\\n\\n for feature in features:\\n all_input_ids.append(feature.input_ids)\\n all_input_mask.append(feature.input_mask)\\n all_segment_ids.append(feature.segment_ids)\\n all_label_ids.append(feature.label_id)\\n\\n def input_fn(params):\\n \\\"\\\"\\\"The actual input function.\\\"\\\"\\\"\\n print(params)\\n batch_size = 500\\n\\n num_examples = len(features)\\n\\n d = tf.data.Dataset.from_tensor_slices({\\n \\\"input_ids\\\":\\n tf.constant(\\n all_input_ids, shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"input_mask\\\":\\n tf.constant(\\n all_input_mask,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"segment_ids\\\":\\n tf.constant(\\n all_segment_ids,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"label_ids\\\":\\n tf.constant(all_label_ids, shape=[num_examples], dtype=tf.int32),\\n })\\n\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\\n return d\\n\\n return input_fn\",\n \"def outline_geoids(sf, df, geoids, include_labels=True):\\n# df = read_shapefile(sf)\\n# df['tract_geoid'] = df.GEOID.str[:11]\\n bg_id = []\\n for i in geoids:\\n bg_id.append(df[df.GEOID==i].index[0])\\n\\n itr = 0\\n for shape in sf.shapeRecords():\\n if itr in bg_id:\\n x = [i[0] for i in shape.shape.points[:]]\\n y = [i[1] for i in shape.shape.points[:]]\\n plt.plot(x, y, 'k')\\n \\n \\n if include_labels:\\n x0 = np.mean(x)\\n y0 = np.mean(y)\\n label = df.iloc[itr].density_label\\n\\n plt.text(x0, y0, label, fontsize=8)\\n \\n itr = itr+1\",\n \"def sample(self, x):\",\n \"def regenerate_art(filename=def_rep_name, x_size=def_x_size,\\n y_size=def_y_size, func_filename=def_func_name, index=def_index):\\n functions = read_func(func_filename, index)\\n make_art(functions, filename, False, x_size, y_size)\",\n \"def _draw_sample_diff_traj(self, idx):\\n # Get a good pair of samples\\n src_dataset_idx, src_traj_id, src_idx = self._locate_sample(idx)\\n\\n src_traj = self.fds[src_dataset_idx][src_traj_id]\\n map_name = src_traj.attrs[\\\"map\\\"].decode(\\\"ascii\\\")\\n\\n idx2 = self.rng.randint(self.samples_per_map[map_name])\\n dst_dataset_idx, dst_traj_id, dst_idx = self._locate_sample_single_map(\\n idx2, map_name\\n )\\n dst_traj = self.fds[dst_dataset_idx][dst_traj_id]\\n\\n src_sample = src_traj[src_idx]\\n dst_sample = dst_traj[dst_idx]\\n\\n return map_name, src_sample, dst_sample\",\n \"def input_fn(self,features, labels, batch_size, shuffle_num, mode):\\r\\n dataset = tf.data.Dataset.from_tensor_slices((features, labels))\\r\\n if mode == tf.estimator.ModeKeys.TRAIN:\\r\\n dataset = dataset.shuffle(shuffle_num).batch(batch_size).repeat(self.epochs)\\r\\n else:\\r\\n dataset = dataset.batch(batch_size)\\r\\n iterator = dataset.make_one_shot_iterator()\\r\\n data, labels = iterator.get_next()\\r\\n return data, labels\",\n \"def generate_data(func, points, seed=0):\\n np.random.seed(seed)\\n\\n data = []\\n for segment in points:\\n x = np.linspace(*segment[\\\"xlim\\\"], num=segment[\\\"n_points\\\"])\\n distribution = func(x)\\n # Generate observations\\n y = distribution.rvs()\\n df = pd.DataFrame({\\\"x\\\": x, \\\"y\\\": y})\\n data.append(df)\\n\\n return pd.concat(data, ignore_index=True)\",\n \"def cifar_100_iid(dataset, num_users):\\n print(\\\"Sampling dataset: CIFAR-100 IID\\\")\\n num_items = int(len(dataset) / num_users)\\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\\n for i in range(num_users):\\n dict_users[i] = set(np.random.choice(all_idxs, num_items, replace=False))\\n all_idxs = list(set(all_idxs) - dict_users[i])\\n return dict_users\",\n \"def dense_sample(data, indint, metric = np.linspace, **kwargs):\\r\\n \\r\\n datab = np.zeros((indint))\\r\\n n_interp = len(data) - 1\\r\\n excess = indint - len(data) # excess indices\\r\\n base_interpol = excess / n_interp # minimum number of middle values in each interpolation\\r\\n remainder = excess % n_interp # extra middle values. (< n_interp). distribute evenly throughout datab.\\r\\n \\r\\n if remainder == 1:\\r\\n left_edge_tack_ons = np.array([np.median(range(n_interp))])\\r\\n else:\\r\\n left_edge_tack_ons = np.linspace(0, n_interp-1, remainder) \\r\\n \\r\\n datab_ind_counter = 0# keep track of inds of output vector\\r\\n for i, item in enumerate(data[:-1]):\\r\\n if np.size(left_edge_tack_ons) > 0:\\r\\n if i >= left_edge_tack_ons[0]:\\r\\n tack_on = 1\\r\\n left_edge_tack_ons = left_edge_tack_ons[1:]\\r\\n else:\\r\\n tack_on = 0\\r\\n else:\\r\\n tack_on = 0\\r\\n \\r\\n datab[datab_ind_counter:(datab_ind_counter+base_interpol+tack_on+1)] = metric(data[i], data[i+1], base_interpol+tack_on+2)[:-1]\\r\\n datab_ind_counter += (base_interpol+tack_on+1)\\r\\n datab[-1] = data[-1]\\r\\n return datab\",\n \"def _draw_sample_diff_traj(self, idx):\\n # Get a good pair of samples\\n src_dataset_idx, src_traj_id, src_idx = self._locate_sample(idx)\\n\\n src_traj = self.fds[src_dataset_idx][src_traj_id]\\n map_name = src_traj.attrs[\\\"map\\\"].decode(\\\"ascii\\\")\\n\\n idx2 = self.rng.randint(self.samples_per_map[map_name])\\n dst_dataset_idx, dst_traj_id, dst_idx = self._locate_sample_single_map(\\n idx2, map_name\\n )\\n dst_traj = self.fds[dst_dataset_idx][dst_traj_id]\\n\\n src_sample = self._jitter(src_traj[src_idx], self.maps[map_name])\\n dst_samples = self._make_sample_seq(dst_traj, dst_idx)\\n return map_name, src_sample, dst_samples\",\n \"def lattice_sample_taken(self, ind, series):\",\n \"def input_fn(params):\\n batch_size = params[\\\"batch_size\\\"]\\n\\n num_examples = len(features)\\n\\n # This is for demo purposes and does NOT scale to large data sets. We do\\n # not use Dataset.from_generator() because that uses tf.py_func which is\\n # not TPU compatible. The right way to load data is with TFRecordReader.\\n d = tf.data.Dataset.from_tensor_slices({\\n \\\"input_ids\\\":\\n tf.constant(\\n all_input_ids, shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"input_mask\\\":\\n tf.constant(\\n all_input_mask,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"segment_ids\\\":\\n tf.constant(\\n all_segment_ids,\\n shape=[num_examples, seq_length],\\n dtype=tf.int32),\\n \\\"label_ids\\\":\\n tf.constant(all_label_ids, shape=[num_examples], dtype=tf.int32),\\n })\\n\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.batch(batch_size=batch_size, drop_remainder=drop_remainder)\\n return d\",\n \"def wrapped_f(*args):\\n input_docs = func(*args)\\n output_doc_cnt = 0\\n # split input_docs into chunks of size self.batch_size\\n for batchiter in iter_n(input_docs, int(self.batch_size / len(self.input_types))):\\n output_docs = self.key_lookup_batch(batchiter)\\n for odoc in output_docs:\\n # print debug information if the original id is the in the debug list\\n if \\\"dt_debug\\\" in odoc:\\n if isinstance(self.debug, list) and odoc[\\\"dt_debug\\\"][\\\"orig_id\\\"] in self.debug:\\n self.logger.debug(\\\"DataTransform Debug doc['dt_debug']: {}\\\".format(odoc[\\\"dt_debug\\\"]))\\n output_doc_cnt += 1\\n yield odoc\\n self.logger.info(\\\"wrapped_f Num. output_docs: {}\\\".format(output_doc_cnt))\\n self.logger.info(\\\"DataTransform.histogram: {}\\\".format(self.histogram))\",\n \"def get_cui_sample_it(self):\\n while True:\\n i = rd.sample(range(len(self.id2sense)), 1)[0]\\n cui = self.id2sense[i]\\n if cui in self.cui2def:\\n sdef = self.cui2def[cui]\\n else:\\n sdef = [self.voc.encode(PAD)] * self.model_config.max_def_len\\n\\n if cui in self.cui2stype:\\n stype = self.cui2stype[cui]\\n else:\\n stype = self.stype2id['unk']\\n\\n for abbr_id in self.cuiud2abbrid[i]:\\n obj = {\\n 'abbr_id': abbr_id,\\n 'cui_id': i,\\n 'def': sdef,\\n 'stype': stype}\\n yield obj\",\n \"def generate_lambda_art(filename, x_size=350, y_size=350):\\n # Functions for red, green, and blue channels - where the magic happens!\\n r_lb = random.randint(1, 2)\\n g_lb = random.randint(1, 2)\\n b_lb = random.randint(1, 2)\\n red_function = r_lambda_func(1)\\n green_function = r_lambda_func(1)\\n blue_function = r_lambda_func(1)\\n print(red_function)\\n print(red_function)\\n print(red_function(0.0, 1.0))\\n print(red_function(1.0, 0.05))\\n print(red_function(1.0, 0.0))\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(red_function(x, y)),\\n color_map(green_function(x, y)),\\n color_map(blue_function(x, y))\\n )\\n im.save(filename)\\n return 'saved'\",\n \"def train_input_fn():\\n # Initialize `iterator` with training data.\\n train_filenames = [os.path.join(FLAGS.out_dir, FLAGS.train_records)]\\n return _input_fn(train_filenames, FLAGS.epochs, FLAGS.batch_size, shuffle=True)\",\n \"def file_based_convert_examples_to_features(path, label2id, max_seq_length, tokenize_fn, output_file):\\n tf.logging.info(\\\"Create new tfrecord {}.\\\".format(output_file))\\n writer = tf.python_io.TFRecordWriter(output_file)\\n df = pd.read_csv(path, index_col=0)\\n df = shuffle(df)\\n count = 0\\n for index, row in df.iterrows():\\n # label = label2id[row[\\\"topic\\\"].strip()]\\n feature = convert_single_example(row[config[\\\"column_name_x1\\\"]],\\n row[config[\\\"column_name_x2\\\"]] if config[\\\"column_name_x2\\\"] != \\\"\\\" else None,\\n max_seq_length, tokenize_fn)\\n\\n def create_int_feature(values):\\n f = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))\\n return f\\n\\n def create_float_feature(values):\\n f = tf.train.Feature(float_list=tf.train.FloatList(value=list(values)))\\n return f\\n\\n label = label2id.get(str(row[config[\\\"column_name_y\\\"]]))\\n features = collections.OrderedDict()\\n features[\\\"input_ids\\\"] = create_int_feature(feature[0])\\n features[\\\"input_mask\\\"] = create_float_feature(feature[1])\\n features[\\\"segment_ids\\\"] = create_int_feature(feature[2])\\n features[\\\"label_ids\\\"] = create_int_feature([label])\\n count += 1\\n if count < 5:\\n print(\\\"*** Example ***\\\")\\n print(\\\"input_ids: %s\\\" % \\\" \\\".join([str(x) for x in feature[0]]))\\n print(\\\"input_mask: %s\\\" % \\\" \\\".join([str(x) for x in feature[1]]))\\n print(\\\"segment_ids: %s\\\" % \\\" \\\".join([str(x) for x in feature[2]]))\\n\\n print(\\\"label: %s (id = %s)\\\" % (row[config[\\\"column_name_y\\\"]], str(label)))\\n\\n tf_example = tf.train.Example(features=tf.train.Features(feature=features))\\n writer.write(tf_example.SerializeToString())\\n if count % 1000 == 0:\\n print(count)\\n writer.close()\\n print(\\\"example count:\\\", count)\",\n \"def make_returnn_audio_features_func():\\n return _extract\",\n \"def input_fn(params):\\n batch_size = self.batch_size\\n\\n num_examples = len(features)\\n\\n d = tf.data.Dataset.from_tensor_slices({\\n \\\"input_ids\\\":\\n tf.constant(\\n all_input_ids, shape=[num_examples, max_seq_len],\\n dtype=tf.int32),\\n \\\"input_mask\\\":\\n tf.constant(\\n all_input_mask,\\n shape=[num_examples, max_seq_len],\\n dtype=tf.int32),\\n \\\"label_ids\\\":\\n tf.constant(\\n all_input_ids, shape=[num_examples, max_seq_len],\\n dtype=tf.int32),\\n \\\"label_mask\\\":\\n tf.constant(\\n all_input_mask,\\n shape=[num_examples, max_seq_len],\\n dtype=tf.int32),\\n })\\n\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.batch(batch_size=batch_size)\\n return d\",\n \"def sample(self, features, states=None):\\r\\n sampled_ids = []\\r\\n inputs = features.unsqueeze(1)\\r\\n for i in range(105): #62\\r\\n hiddens, states = self.lstm(inputs, states)\\r\\n outputs = self.linear(hiddens.squeeze(1))\\r\\n a = outputs.max(1)\\r\\n predicted = outputs.max(1)[1]\\r\\n sampled_ids.append(predicted)\\r\\n inputs = self.embed(predicted)\\r\\n inputs = inputs.unsqueeze(1)\\r\\n return sampled_ids\",\n \"def _imageid_and_mids_generator(filepath):\\n with open(filepath, 'rb') as fp:\\n imageid2mids = pickle.load(fp)\\n \\n for imageid, mids in imageid2mids.items():\\n Np = MAX_N_MIDS - len(mids)\\n if Np < 0:\\n tf.logging.warn(f'Np = {Np}.')\\n # pad to MAX_N_MIDS\\n mids.extend([''.encode('utf-8')]*Np)\\n yield imageid.encode('utf-8'), mids, Np\",\n \"def run_trials(f, n):\\n\\tfor value in range(2, 3):\\n\\t\\tprint(\\\"{:>3}:{:>5}\\\".format(value, f(n, value)))\",\n \"def iid_sampling(dataset, num_users):\\n num_items = int(len(dataset) / num_users)\\n dict_users, all_idxs = {}, [i for i in range(len(dataset))]\\n for i in range(num_users):\\n dict_users[i] = set(np.random.choice(all_idxs, num_items,\\n replace=False))\\n all_idxs = list(set(all_idxs) - dict_users[i])\\n return dict_users\",\n \"def input_fn():\\n bos_id = tf.constant(BOS_ID, tf.int32)\\n eos_id = tf.constant(EOS_ID, tf.int32)\\n\\n # For training, we want a lot of parallel reading and shuffling.\\n # For eval, we want no shuffling and parallel reading doesn't matter.\\n d = tf.data.TFRecordDataset(input_files)\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.map(lambda record: _decode_record(record, name_to_features))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n tf.concat([[bos_id], src_ids, [eos_id]], 0),\\n tf.concat([tgt_ids, [eos_id]], 0),\\n label))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n src_ids[:FLAGS.max_sequence_length],\\n tgt_ids[:FLAGS.max_sequence_length],\\n label\\n ))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n tf.concat([src_ids, tgt_ids], 0),\\n tf.concat([tf.zeros_like(src_ids), tf.ones_like(tgt_ids)], 0),\\n label\\n ))\\n\\n d = d.map(lambda input_ids, segment_ids, label_ids: (\\n input_ids,\\n segment_ids,\\n tf.ones_like(input_ids),\\n label_ids\\n ))\\n\\n def batching_func(x):\\n return x.padded_batch(\\n batch_size,\\n # The entry is the source line rows;\\n # this has unknown-length vectors. The last entry is\\n # the source row size; this is a scalar.\\n padded_shapes=(\\n tf.TensorShape([None]), # src\\n tf.TensorShape([None]), # tgt\\n tf.TensorShape([None]),\\n tf.TensorShape([])), # src_len\\n # Pad the source sequences with eos tokens.\\n # (Though notice we don't generally need to do this since\\n # later on we will be masking out calculations past the true sequence.\\n padding_values=(\\n PAD_ID, # src\\n PAD_ID,\\n PAD_ID,\\n 0)) # src_len -- unused\\n\\n batched_dataset = batching_func(d)\\n features = batched_dataset.map(lambda input_ids, segment_ids, input_mask, label:\\n {\\n \\\"input_ids\\\": input_ids,\\n \\\"segment_ids\\\": segment_ids,\\n \\\"input_mask\\\": input_mask,\\n \\\"label_ids\\\": label\\n\\n })\\n\\n return features\",\n \"def get_itr_snapshot(self, itr, samples_data):\\n raise NotImplementedError\",\n \"def get_itr_snapshot(self, itr, samples_data):\\n raise NotImplementedError\",\n \"def get_itr_snapshot(self, itr, samples_data):\\n raise NotImplementedError\",\n \"def sample(self):\\n return self._sample_func\",\n \"def taxi_rides_sample(path, n, storage_options=None):\\n return next(taxi_rides_iterator(path, n, storage_options))\",\n \"def make_data_iter_fn(filename, batch_size, is_train):\\n def parse_fn(example_proto):\\n features = {\\n 'input': tf.FixedLenSequenceFeature([], tf.int64, allow_missing=True),\\n 'target': tf.VarLenFeature(tf.int64),\\n 'input_length': tf.FixedLenFeature([1], tf.int64),\\n 'target_length': tf.FixedLenFeature([1], tf.int64)\\n }\\n parsed_features = tf.parse_single_example(example_proto, features=features)\\n\\n parsed_features['input'] = tf.cast(parsed_features['input'], tf.int32)\\n t = parsed_features['target']\\n parsed_features['target'] = tf.SparseTensor(indices=t.indices, \\n values=tf.cast(t.values, tf.int32),\\n dense_shape=t.dense_shape)\\n \\n parsed_features['input_length'] = tf.cast(parsed_features['input_length'], tf.int32)\\n parsed_features['target_length'] = tf.cast(parsed_features['target_length'], tf.int32)\\n\\n return parsed_features\\n\\n def input_fn():\\n dataset = tf.data.TFRecordDataset(filename)\\n dataset = dataset.map(parse_fn)\\n \\n if is_train:\\n dataset = dataset.shuffle(500).repeat()\\n \\n dataset = dataset.batch(batch_size).prefetch(2)\\n features = dataset.make_one_shot_iterator().get_next()\\n return features, features['target']\\n\\n return input_fn\",\n \"def sample(draws, step_method, chain_state, sample_history ):\\n start = time.time()\\n for i in xrange(int(draws)):\\n chain_state = step_method.step(chain_state)\\n sample_history.record(chain_state, step_method)\\n \\n return (time.time() - start)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64719844","0.5108194","0.5058195","0.5022143","0.5005775","0.49909416","0.49430317","0.4896238","0.48929828","0.4841593","0.48388526","0.48310915","0.48164558","0.481505","0.48034382","0.47747755","0.4774165","0.47662959","0.47544459","0.474792","0.4742834","0.47264317","0.47058088","0.4698736","0.46977076","0.46977076","0.46960148","0.4692182","0.46884024","0.4686816","0.46771035","0.4671921","0.46558222","0.46518385","0.46517032","0.46453688","0.46440428","0.46418315","0.4641496","0.46298933","0.46297327","0.46288997","0.46280056","0.46171173","0.46136853","0.4612626","0.46048146","0.46037328","0.4598596","0.45902416","0.4579027","0.45726565","0.45679867","0.45667908","0.45537522","0.4551311","0.4551251","0.4550329","0.45501015","0.4540655","0.45293996","0.45290965","0.45233428","0.4518532","0.45182884","0.45087916","0.4508171","0.44977707","0.44938338","0.44897875","0.44886577","0.44744834","0.44686747","0.44625932","0.44608843","0.44503292","0.4444813","0.44445872","0.4442633","0.4442216","0.44413516","0.44404697","0.44403583","0.4438631","0.4438085","0.44375813","0.44352236","0.44352093","0.44344506","0.4433966","0.4419583","0.44178128","0.44174185","0.44169608","0.44169608","0.44169608","0.44162568","0.44099608","0.44068915","0.4406641"],"string":"[\n \"0.64719844\",\n \"0.5108194\",\n \"0.5058195\",\n \"0.5022143\",\n \"0.5005775\",\n \"0.49909416\",\n \"0.49430317\",\n \"0.4896238\",\n \"0.48929828\",\n \"0.4841593\",\n \"0.48388526\",\n \"0.48310915\",\n \"0.48164558\",\n \"0.481505\",\n \"0.48034382\",\n \"0.47747755\",\n \"0.4774165\",\n \"0.47662959\",\n \"0.47544459\",\n \"0.474792\",\n \"0.4742834\",\n \"0.47264317\",\n \"0.47058088\",\n \"0.4698736\",\n \"0.46977076\",\n \"0.46977076\",\n \"0.46960148\",\n \"0.4692182\",\n \"0.46884024\",\n \"0.4686816\",\n \"0.46771035\",\n \"0.4671921\",\n \"0.46558222\",\n \"0.46518385\",\n \"0.46517032\",\n \"0.46453688\",\n \"0.46440428\",\n \"0.46418315\",\n \"0.4641496\",\n \"0.46298933\",\n \"0.46297327\",\n \"0.46288997\",\n \"0.46280056\",\n \"0.46171173\",\n \"0.46136853\",\n \"0.4612626\",\n \"0.46048146\",\n \"0.46037328\",\n \"0.4598596\",\n \"0.45902416\",\n \"0.4579027\",\n \"0.45726565\",\n \"0.45679867\",\n \"0.45667908\",\n \"0.45537522\",\n \"0.4551311\",\n \"0.4551251\",\n \"0.4550329\",\n \"0.45501015\",\n \"0.4540655\",\n \"0.45293996\",\n \"0.45290965\",\n \"0.45233428\",\n \"0.4518532\",\n \"0.45182884\",\n \"0.45087916\",\n \"0.4508171\",\n \"0.44977707\",\n \"0.44938338\",\n \"0.44897875\",\n \"0.44886577\",\n \"0.44744834\",\n \"0.44686747\",\n \"0.44625932\",\n \"0.44608843\",\n \"0.44503292\",\n \"0.4444813\",\n \"0.44445872\",\n \"0.4442633\",\n \"0.4442216\",\n \"0.44413516\",\n \"0.44404697\",\n \"0.44403583\",\n \"0.4438631\",\n \"0.4438085\",\n \"0.44375813\",\n \"0.44352236\",\n \"0.44352093\",\n \"0.44344506\",\n \"0.4433966\",\n \"0.4419583\",\n \"0.44178128\",\n \"0.44174185\",\n \"0.44169608\",\n \"0.44169608\",\n \"0.44169608\",\n \"0.44162568\",\n \"0.44099608\",\n \"0.44068915\",\n \"0.4406641\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6562505"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90593,"cells":{"query":{"kind":"string","value":"Wraps `fn` to take only those args with non`None` core ndims."},"document":{"kind":"string","value":"def _lock_in_non_vectorized_args(fn, arg_structure, flat_core_ndims, flat_args):\n\n # Extract the indices and values of args where core_ndims is not `None`.\n (vectorized_arg_indices,\n vectorized_arg_core_ndims,\n vectorized_args) = [], [], []\n if any(nd is not None for nd in flat_core_ndims):\n vectorized_arg_indices, vectorized_arg_core_ndims, vectorized_args = zip(*[\n (i, nd, tf.convert_to_tensor(t))\n for i, (nd, t) in enumerate(zip(flat_core_ndims, flat_args))\n if nd is not None])\n\n vectorized_arg_index_set = set(vectorized_arg_indices)\n\n def fn_of_vectorized_args(vectorized_args):\n with tf.name_scope('fn_of_vectorized_args'):\n vectorized_args_by_index = dict(\n zip(vectorized_arg_indices, vectorized_args))\n # Substitute the vectorized args into the original argument\n # structure.\n new_args_with_original_structure = tf.nest.pack_sequence_as(\n arg_structure, [vectorized_args_by_index[i]\n if i in vectorized_arg_index_set\n else v for (i, v) in enumerate(flat_args)])\n return tf.nest.map_structure(\n # If `fn` returns any Distribution instances, ensure that their\n # parameter batch shapes are padded to align after vectorization.\n _maybe_rectify_parameter_shapes,\n fn(*new_args_with_original_structure))\n\n return (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _add_keepdims(func):\n @functools.wraps(func)\n def wrapped(a, axis, **kwargs):\n res = func(a, axis=axis, **kwargs)\n if axis is None:\n axis = 0 # res is now a scalar, so we can insert this anywhere\n return np.expand_dims(res, axis=axis)\n return wrapped","def arguments_not_none(func):\n def wrapper(*args, **kwargs):\n for arg in args:\n if arg is None:\n raise NullArgument()\n for arg, val in kwargs.iteritems():\n if val is None:\n raise NullArgument()\n try:\n return func(*args, **kwargs)\n except TypeError as ex:\n if 'takes exactly' in ex.args[0]:\n raise NullArgument('Wrong number of arguments provided: ' + str(ex.args[0]))\n else:\n raise\n\n return wrapper","def make_gufunc(f, core_dims_in, core_dims_out):\n\n def gufunc(args):\n args = generalized_broadcast(args)\n data_shape = args[0].shape[:-len(core_dims_in[0])]\n args = [A.reshape(-1, A.shape[-1]) for A in args]\n\n #if X_out is None:\n # X_out = np.empty_like(X)\n #X_out = X_out.reshape(-1, X.shape[-1])\n\n out = f(args)\n\n return out.reshape(data_shape + core_dims_out)\n\n return gufunc","def can_take_n_args(func, n=2):\n (pos, args, kwargs, defaults) = inspect.getargspec(func)\n if args is not None or len(pos) >= n:\n return True\n return False","def vectorized_fn(*args):\n with tf.name_scope(name or 'make_rank_polymorphic'):\n # If we got a single value for core_ndims, tile it across all args.\n core_ndims_structure = (\n core_ndims\n if tf.nest.is_nested(core_ndims)\n else tf.nest.map_structure(lambda _: core_ndims, args))\n\n # Build flat lists of all argument parts and their corresponding core\n # ndims.\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\n flat_args = nest.flatten_up_to(\n core_ndims_structure, args, check_types=False)\n\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\n # values for `core_ndims`). Other args will be passed through to `fn`\n # unmodified.\n (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\n fn,\n arg_structure=core_ndims_structure,\n flat_core_ndims=flat_core_ndims,\n flat_args=flat_args)\n\n # `vectorized_map` requires all inputs to have a single, common batch\n # dimension `[n]`. So we broadcast all input parts to a common\n # batch shape, then flatten it down to a single dimension.\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\n\n vectorized_arg_actual_core_ndims = []\n batch_shapes, core_shapes = [], []\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\n vectorized_arg_core_ndims):\n arg_nd = ps.rank_from_shape(arg_shape)\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\n # `batch_ndims` is always nonnegative.\n actual_core_nd = ps.minimum(arg_nd, core_nd)\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\n\n batch_ndims = arg_nd - actual_core_nd\n batch_ndims_ = tf.get_static_value(batch_ndims)\n if batch_ndims_ is not None:\n batch_shapes.append(arg_shape[:batch_ndims_])\n core_shapes.append(arg_shape[batch_ndims_:])\n else:\n arg_shape = tf.convert_to_tensor(arg_shape)\n batch_shapes.append(arg_shape[:batch_ndims])\n core_shapes.append(arg_shape[batch_ndims:])\n\n # Flatten all of the batch dimensions into one.\n broadcast_batch_shape = (\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\n\n static_n = tf.get_static_value(n)\n if static_n == 1:\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\n result_batch_dims = 0\n batched_result = fn_of_vectorized_args(\n tf.nest.map_structure(\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\n vectorized_args,\n vectorized_arg_actual_core_ndims,\n check_types=False))\n else:\n # Pad all input parts to the common shape, then flatten\n # into the single leading dimension `[n]`.\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\n # when batch rank is static so that we can exploit broadcasting.\n broadcast_vectorized_args = [\n tf.broadcast_to(part, ps.concat(\n [broadcast_batch_shape, core_shape], axis=0))\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\n vectorized_args_with_flattened_batch_dim = [\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\n for (part, core_shape) in zip(\n broadcast_vectorized_args, core_shapes)]\n result_batch_dims = 1\n batched_result = tf.vectorized_map(\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\n\n # Unflatten any `Tensor`s in the result.\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\n result = tf.nest.map_structure(\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\n expand_composites=True)\n return result","def n_ary(func):\n def wrapper(x, *args):\n return x if not args else func(x, wrapper(*args))\n return wrapper","def filter_args(fn, args_tuple):\n sig = inspect.signature(fn)\n flag_var_positional = any([\n inspect.Parameter.VAR_POSITIONAL == value.kind for\n value in sig.parameters.values()])\n if flag_var_positional:\n return args_tuple\n else:\n num_args = len(sig.parameters.items())\n return args_tuple[:num_args]","def right_shape(func, args, expected):\n \n if args is None:\n assert(np.shape(func())==expected)\n else:\n assert(np.shape(func(*args))==expected)","def wrapped_function(*args, **kwargs):\n nargs = len(args) - start\n torch_objects = torch.Tensor\n if any(isinstance(arg, torch_objects) for arg in args[start:]):\n # reduce number of function calls in graph\n if nargs == 1:\n return function(*args, **kwargs)\n # concatenate extra arguments\n args = args[:start] + (torch.cat(args[start:], dim=1),)\n return function(*args, **kwargs)\n else:\n to_concatenate = list(map(np.atleast_2d, args[start:]))\n if nargs == 1:\n concatenated = tuple(to_concatenate)\n else:\n concatenated = (np.hstack(to_concatenate),)\n \n args = args[:start] + concatenated\n return function(*args, **kwargs)","def check_inputs(function):\n def decorated(self, data, *args, **kwargs):\n if not (isinstance(data, np.ndarray) and len(data.shape) == 2 and data.shape[1] == 1):\n raise ValueError('The argument `data` must be a numpy.ndarray with shape (n, 1).')\n\n return function(self, data, *args, **kwargs)\n\n decorated.__doc__ = function.__doc__\n return decorated","def wrapperfunc_noargs(func):\n def wrap_noargs_wrapper(self, arg):\n return wrapperfunc(func)(self)(arg)\n return wrap_noargs_wrapper","def rank_zero_only(fn):\n\n def wrapped(*args, **kwargs):\n if rank() == 0:\n return fn(*args, **kwargs)\n\n return wrapped","def flatten_args(shapes):\n def flatten_args_dec(func):\n\n @wraps(func)\n def new_func(array1d, *args, **kwargs):\n args = tuple(unflatten(array1d, shapes)) + args\n return func(*args, **kwargs)\n\n return new_func\n\n return flatten_args_dec","def remove_unused_args(args, thnn_args):\n def clean_name(name):\n name = name[:name.index('[')] if '[' in name else name\n if name.endswith('_'):\n name = name[:-1]\n return name\n uses = set([clean_name(arg['name']) for arg in thnn_args])\n uses.add('output_mask')\n args = [arg for arg in args if arg['name'] in uses]\n for arg in args:\n if 'default' in arg:\n del arg['default']\n return args","def scalarDecorator(func):\n @wraps(func)\n def scalar_wrapper(*args,**kwargs):\n if numpy.array(args[0]).shape == ():\n scalarOut= True\n newargs= ()\n for ii in range(len(args)):\n if ii == 0:\n newargs= newargs+(numpy.array([args[ii]]),)\n else:\n newargs= newargs+(args[ii],)\n args= newargs\n else:\n scalarOut= False\n result= func(*args,**kwargs)\n if scalarOut:\n return result[0]\n else:\n return result\n return scalar_wrapper","def preserve_shape(func):\n @wraps(func)\n def wrapped_function(img, *args, **kwargs):\n shape = img.shape\n result = func(img, *args, **kwargs)\n result = result.reshape(shape)\n return result\n\n return wrapped_function","def n_ary(f):\n def n_ary_fn(x, *args):\n return x if not args else f(x, n_ary_fn(*args))\n return n_ary_fn","def n_ary(f):\n def n_ary_f(x,*args):\n return x if not args else f(x,n_ary_f(*args))\n return n_ary_f","def missingArgs(func, argdict):\n return set(getRequiredArgs(func)).difference(argdict)","def vectorize_inputs(f):\n return lambda args: f(*np.hsplit(args, args.shape[1]))","def test_clugen_optional(\n prng,\n ndims,\n vec_or_mat,\n clusep_fn,\n cluoff_fn,\n allow_empty,\n ptdist_fn,\n ptoff_fn,\n csz_fn,\n cctr_fn,\n llen_fn,\n lang_fn,\n):\n # Valid arguments\n nclu = 7\n tpts = 500\n astd = pi / 256\n len_mu = 9\n len_std = 1.2\n lat_std = 2\n\n # Get direction\n direc = vec_or_mat(ndims, nclu)\n\n with warnings.catch_warnings():\n # Check that the function runs without warnings\n warnings.simplefilter(\"error\")\n result = clugen(\n ndims,\n nclu,\n tpts,\n direc,\n astd,\n clusep_fn(ndims),\n len_mu,\n len_std,\n lat_std,\n allow_empty=allow_empty,\n cluster_offset=cluoff_fn(ndims),\n proj_dist_fn=ptdist_fn,\n point_dist_fn=ptoff_fn,\n clusizes_fn=csz_fn,\n clucenters_fn=cctr_fn,\n llengths_fn=llen_fn,\n angle_deltas_fn=lang_fn,\n rng=prng,\n )\n\n # Check dimensions of result variables\n assert result.points.shape == (tpts, ndims)\n assert result.clusters.shape == (tpts,)\n assert result.projections.shape == (tpts, ndims)\n assert result.sizes.shape == (nclu,)\n assert result.centers.shape == (nclu, ndims)\n assert result.directions.shape == (nclu, ndims)\n assert result.angles.shape == (nclu,)\n assert result.lengths.shape == (nclu,)\n\n # Check point cluster indexes\n if not allow_empty:\n assert all(unique(result.clusters) == arange(nclu))\n else:\n assert all(result.clusters < nclu)\n\n # Check total points\n assert sum(result.sizes) == tpts\n # This might not be the case if the specified clusize_fn does not obey\n # the total number of points\n\n # Check that cluster directions have the correct angles with the main direction\n if ndims > 1:\n if direc.ndim == 1:\n direc = repeat(direc.reshape((1, -1)), nclu, axis=0)\n for i in range(nclu):\n assert_allclose(\n angle_btw(direc[i, :], result.directions[i, :]),\n abs(result.angles[i]),\n atol=1e-11,\n )","def any(tensor, axis=None, keepdims=False, **kwargs):\n return tensor.any(axis=axis, keepdims=keepdims, **kwargs)","def _wrapper(func, args):\n return func(*args)","def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper","def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper","def make_rank_polymorphic(fn, core_ndims, name=None):\n\n def vectorized_fn(*args):\n \"\"\"Vectorized version of `fn` that accepts arguments of any rank.\"\"\"\n with tf.name_scope(name or 'make_rank_polymorphic'):\n # If we got a single value for core_ndims, tile it across all args.\n core_ndims_structure = (\n core_ndims\n if tf.nest.is_nested(core_ndims)\n else tf.nest.map_structure(lambda _: core_ndims, args))\n\n # Build flat lists of all argument parts and their corresponding core\n # ndims.\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\n flat_args = nest.flatten_up_to(\n core_ndims_structure, args, check_types=False)\n\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\n # values for `core_ndims`). Other args will be passed through to `fn`\n # unmodified.\n (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\n fn,\n arg_structure=core_ndims_structure,\n flat_core_ndims=flat_core_ndims,\n flat_args=flat_args)\n\n # `vectorized_map` requires all inputs to have a single, common batch\n # dimension `[n]`. So we broadcast all input parts to a common\n # batch shape, then flatten it down to a single dimension.\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\n\n vectorized_arg_actual_core_ndims = []\n batch_shapes, core_shapes = [], []\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\n vectorized_arg_core_ndims):\n arg_nd = ps.rank_from_shape(arg_shape)\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\n # `batch_ndims` is always nonnegative.\n actual_core_nd = ps.minimum(arg_nd, core_nd)\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\n\n batch_ndims = arg_nd - actual_core_nd\n batch_ndims_ = tf.get_static_value(batch_ndims)\n if batch_ndims_ is not None:\n batch_shapes.append(arg_shape[:batch_ndims_])\n core_shapes.append(arg_shape[batch_ndims_:])\n else:\n arg_shape = tf.convert_to_tensor(arg_shape)\n batch_shapes.append(arg_shape[:batch_ndims])\n core_shapes.append(arg_shape[batch_ndims:])\n\n # Flatten all of the batch dimensions into one.\n broadcast_batch_shape = (\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\n\n static_n = tf.get_static_value(n)\n if static_n == 1:\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\n result_batch_dims = 0\n batched_result = fn_of_vectorized_args(\n tf.nest.map_structure(\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\n vectorized_args,\n vectorized_arg_actual_core_ndims,\n check_types=False))\n else:\n # Pad all input parts to the common shape, then flatten\n # into the single leading dimension `[n]`.\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\n # when batch rank is static so that we can exploit broadcasting.\n broadcast_vectorized_args = [\n tf.broadcast_to(part, ps.concat(\n [broadcast_batch_shape, core_shape], axis=0))\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\n vectorized_args_with_flattened_batch_dim = [\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\n for (part, core_shape) in zip(\n broadcast_vectorized_args, core_shapes)]\n result_batch_dims = 1\n batched_result = tf.vectorized_map(\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\n\n # Unflatten any `Tensor`s in the result.\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\n result = tf.nest.map_structure(\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\n expand_composites=True)\n return result\n\n return vectorized_fn","def default_helper_c_code_args():\r\n\r\n return {\r\n \"c_prefix\": \"PyArray\",\r\n \"strides_mul\": 1,\r\n }","def one_dim_nogil_cfunc(a: cython.double[:]):\n with cython.nogil:\n result = _one_dim_nogil_cfunc(a)\n return result","def function(args):\n pass","def fn(*args, **kwargs):\n pass","def gnumpy_func_wrap(f):\n def inner(*args):\n args = garray_to_cudandarray_nested(args)\n res = f(*args)\n if isinstance(res, list):\n res = cudandarray_to_garray_nested(res)\n else:\n # TODO: check for CudaNdArray instance instead\n if not isinstance(res, (float, np.ndarray)):\n res = gput.cudandarray_to_garray(res)\n return res\n return inner","def slice_optional(m: typing.Optional[cython.double[:]]):\n return 1 if m is None else 2","def does_it_run(func, args):\n \n if args is None:\n func()\n else:\n func(*args)","def crop(dimension, start, end):\n def func(x):\n if dimension == 0:\n return x[start: end]\n if dimension == 1:\n return x[:, start: end]\n if dimension == 2:\n return x[:, :, start: end]\n if dimension == 3:\n return x[:, :, :, start: end]\n if dimension == 4:\n return x[:, :, :, :, start: end]\n return Lambda(func)","def dummy_fn(self, *args, **kwargs):","def tonal_args(func, instance, args, kwargs):\n\n def wrapper(*args, **kwargs):\n\n [err_if_not_tonal(arg) for arg in args]\n\n return func(*args, **kwargs)\n\n return wrapper","def atleast_nd(arr, n, front=False):\n arr_ = np.asanyarray(arr)\n ndims = len(arr_.shape)\n if n is not None and ndims < n:\n # append the required number of dimensions to the front or back\n if front:\n expander = (None,) * (n - ndims) + (Ellipsis,)\n else:\n expander = (Ellipsis,) + (None,) * (n - ndims)\n arr_ = arr_[expander]\n return arr_","def ndflip(a):\n ind = (slice(None,None,-1),)*a.ndim\n return a[ind]","def array_input(f):\n @wraps(f)\n def wrapped(self, t):\n t = np.atleast_1d(t)\n r = f(self, t)\n return r\n return wrapped","def no_arg():\n run_no_arg()","def noop(*argv):\n pass","def is_args_in_task(func):\n arg = inspect.getargs(func.func_code)\n return arg.varargs is not None","def test_no_args():\r\n # test module\r\n test_data = doc.MatObject.matlabify('test_data')\r\n test_submodule = test_data.getter('test_submodule')\r\n ok_(isinstance(test_submodule, doc.MatModule))\r\n eq_(test_submodule.__package__, 'test_data.test_submodule')\r\n f = test_submodule.getter('f_no_args')\r\n ok_(isinstance(f, doc.MatFunction))\r\n eq_(f.retv, ['output', 'with', 'ellipsis'])\r\n ok_(not f.args)\r\n return f","def any_(*args, **kwargs):\n ...","def apply_function(f, args):\n if len(signature(f).parameters) == len(args):\n func = curry(f)\n for arg_value in args:\n func = func(arg_value)\n return func()\n else:\n raise Exception(\"the number of function's parameter is not matched args, len(args): \", len(args))","def test_no_mutually_exclusive_args_provided(self):\n _func = mutually_exclusive_parameters('arg1', 'arg2')(undecorated_func)\n self.assertEqual(_func(), 'foo')\n self.assertEqual(_func(arg3='hello'), 'foo')","def _reductions(\n func: Callable,\n values: np.ndarray,\n mask: npt.NDArray[np.bool_],\n *,\n skipna: bool = True,\n min_count: int = 0,\n axis: AxisInt | None = None,\n **kwargs,\n):\n if not skipna:\n if mask.any() or check_below_min_count(values.shape, None, min_count):\n return libmissing.NA\n else:\n return func(values, axis=axis, **kwargs)\n else:\n if check_below_min_count(values.shape, mask, min_count) and (\n axis is None or values.ndim == 1\n ):\n return libmissing.NA\n\n return func(values, where=~mask, axis=axis, **kwargs)","def _wrap_2d_function(inputs, compute_op, dim=-1, name=None):\n\n def _swap_axis(input_tensor, dim_index, last_index, name=None):\n \"\"\"Swaps logits's dim_index and last_index.\"\"\"\n return array_ops.transpose(\n input_tensor,\n array_ops.concat([\n math_ops.range(dim_index), [last_index],\n math_ops.range(dim_index + 1, last_index), [dim_index]\n ], 0),\n name=name)\n\n inputs = ops.convert_to_tensor(inputs)\n\n # We need its original shape for shape inference.\n shape = inputs.get_shape()\n is_last_dim = (dim == -1) or (dim == shape.ndims - 1)\n\n if is_last_dim:\n return compute_op(inputs, name=name)\n\n dim_val = dim\n if isinstance(dim, tensor_lib.Tensor):\n dim_val = tensor_util.constant_value(dim)\n if dim_val is not None and not -shape.ndims <= dim_val < shape.ndims:\n raise errors_impl.InvalidArgumentError(\n None, None,\n f\"`dim` must be in the range [{-shape.ndims}, {shape.ndims}) where \"\n f\"{shape.ndims} is the number of dimensions in the input. \"\n f\"Received: dim={dim_val}\")\n\n # If dim is not the last dimension, we have to do a transpose so that we can\n # still perform the op on its last dimension.\n\n # In case dim is negative (and is not last dimension -1), add shape.ndims\n ndims = array_ops.rank(inputs)\n if not isinstance(dim, tensor_lib.Tensor):\n if dim < 0:\n dim += ndims\n else:\n dim = array_ops.where(math_ops.less(dim, 0), dim + ndims, dim)\n\n # Swap logits' dimension of dim and its last dimension.\n input_rank = array_ops.rank(inputs)\n dim_axis = dim % shape.ndims\n inputs = _swap_axis(inputs, dim_axis, math_ops.subtract(input_rank, 1))\n\n # Do the actual call on its last dimension.\n def fix_output(output):\n output = _swap_axis(\n output, dim_axis, math_ops.subtract(input_rank, 1), name=name)\n\n # Make shape inference work since transpose may erase its static shape.\n output.set_shape(shape)\n return output\n\n outputs = compute_op(inputs)\n if isinstance(outputs, tuple):\n return tuple(fix_output(output) for output in outputs)\n else:\n return fix_output(outputs)","def only_one_nondefault(args):\n defaults = 0 if args.defaults is None else len(args.defaults)\n if len(args.args) >= 1 and (len(args.args) - defaults <= 1):\n return True\n else:\n return False","def n_ary(f):\n #def n_ary_f(x, *args):\n #if len(args) == 0:\n #return x\n #return f(x,n_ary_f(args[0],*args[1:]))\n def n_ary_f(x, *args):\n return x if not args else f(x,n_ary_f(*args))\n return n_ary_f","def numpyfunc(*args, **kwargs):\n def _decorator(func):\n return numpy.frompyfunc(func, *args, **kwargs)\n return _decorator","def dummy_func(*args, **kwargs):\r\n pass","def output_dims(self) -> Optional[Tuple[int]]:\n return None","def check(\n ureg: UnitRegistry, *args: Optional[Union[str, UnitsContainer, Unit]]\n) -> Callable[[F], F]:\n dimensions = [\n ureg.get_dimensionality(dim) if dim is not None else None for dim in args\n ]\n\n def decorator(func):\n count_params = len(signature(func).parameters)\n if len(dimensions) != count_params:\n raise TypeError(\n \"%s takes %i parameters, but %i dimensions were passed\"\n % (func.__name__, count_params, len(dimensions))\n )\n\n assigned = tuple(\n attr for attr in functools.WRAPPER_ASSIGNMENTS if hasattr(func, attr)\n )\n updated = tuple(\n attr for attr in functools.WRAPPER_UPDATES if hasattr(func, attr)\n )\n\n @functools.wraps(func, assigned=assigned, updated=updated)\n def wrapper(*args, **kwargs):\n list_args, empty = _apply_defaults(func, args, kwargs)\n\n for dim, value in zip(dimensions, list_args):\n if dim is None:\n continue\n\n if not ureg.Quantity(value).check(dim):\n val_dim = ureg.get_dimensionality(value)\n raise DimensionalityError(value, \"a quantity of\", val_dim, dim)\n return func(*args, **kwargs)\n\n return wrapper\n\n return decorator","def validate_args(fn, *args, **kwargs):\n required_args = [\n p.name for p in inspect.signature(fn).parameters.values()\n if p.default == inspect.Parameter.empty\n and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD]\n missing_required_args = required_args[len(args):]\n\n missing = [arg for arg in missing_required_args if arg not in kwargs]\n if missing:\n raise MissingArgs(missing)","def any(self, axis=None, keepdims=False, out=None):\n return np.logical_or.reduce(self, out=out, axis=axis, keepdims=keepdims)","def debug_callback_batching_rule(args, dims, **params):\n axis_size = next(x.shape[i] for x, i in zip(args, dims)\n if i is not None)\n # TODO(sharadmv): implement in terms of rolled loop unstead of\n # unrolled.\n def get_arg_at_dim(i, dim, arg):\n if dim is batching.not_mapped:\n # Broadcast unmapped argument\n return arg\n return lax.index_in_dim(arg, i, axis=dim, keepdims=False)\n outs = []\n for i in range(axis_size):\n args_idx = map(functools.partial(get_arg_at_dim, i), dims, args)\n outs.append(debug_callback_p.bind(*args_idx, **params))\n outs = [jnp.stack(xs) for xs in zip(*outs)]\n return outs, (0,) * len(outs)","def abs_dev_knn_star(args):\n return abs_dev_knn(*args)","def test_clugen_optional_direct(\n prng,\n ndims,\n num_clusters,\n vec_or_mat,\n clusep_fn,\n allow_empty,\n):\n # Direct parameters (instead of functions)\n csz_direct = prng.integers(1, 100, num_clusters)\n cctr_direct = prng.normal(size=(num_clusters, ndims))\n llen_direct = 20 * prng.random(num_clusters)\n lang_direct = pi * prng.random(num_clusters) - pi / 2\n\n # Valid arguments\n tpts = sum(csz_direct)\n astd = pi / 333\n len_mu = 6\n len_std = 1.1\n lat_std = 1.6\n\n # Get direction\n direc = vec_or_mat(ndims, num_clusters)\n\n with warnings.catch_warnings():\n # Check that the function runs without warnings\n warnings.simplefilter(\"error\")\n result = clugen(\n ndims,\n num_clusters,\n tpts,\n direc,\n astd,\n clusep_fn(ndims),\n len_mu,\n len_std,\n lat_std,\n allow_empty=allow_empty,\n clusizes_fn=csz_direct,\n clucenters_fn=cctr_direct,\n llengths_fn=llen_direct,\n angle_deltas_fn=lang_direct,\n rng=prng,\n )\n\n # Check dimensions of result variables\n assert result.points.shape == (tpts, ndims)\n assert result.clusters.shape == (tpts,)\n assert result.projections.shape == (tpts, ndims)\n assert result.sizes.shape == (num_clusters,)\n assert result.centers.shape == (num_clusters, ndims)\n assert result.directions.shape == (num_clusters, ndims)\n assert result.angles.shape == (num_clusters,)\n assert result.lengths.shape == (num_clusters,)\n\n # Check point cluster indexes\n if not allow_empty:\n assert all(unique(result.clusters) == arange(num_clusters))\n else:\n assert all(result.clusters < num_clusters)\n\n # Check total points\n assert sum(result.sizes) == tpts\n # This might not be the case if the specified clusize_fn does not obey\n # the total number of points\n\n # Check that cluster directions have the correct angles with the main direction\n if ndims > 1:\n if direc.ndim == 1:\n direc = repeat(direc.reshape((1, -1)), num_clusters, axis=0)\n for i in range(num_clusters):\n assert_allclose(\n angle_btw(direc[i, :], result.directions[i, :]),\n abs(result.angles[i]),\n atol=1e-11,\n )","def test_map_args_all_none():\n pass","def run_func_decorator(\n *func_args: list[Any],\n **func_kwargs: dict[str, Any],\n ) -> Any:\n if isinstance(world_size, int):\n dist_launcher(world_size, *func_args, **func_kwargs)\n elif isinstance(world_size, list):\n for procs in world_size:\n dist_launcher(procs, *func_args, **func_kwargs)\n time.sleep(0.5)\n else:\n raise TypeError(\n 'world_size must be an integer or a list of integers.',\n )","def fn(x):\n if x.ndim == 1:\n return np.sum(x**2)\n else:\n return np.sum(x**2, axis=1)","def expand_apply(f, axis=0):\n if axis not in [0, -1]:\n raise ValueError(\"expand_apply currently only supports axis=0 or axis=-1.\")\n\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n expand = lambda t: jnp.expand_dims(t, axis=axis)\n args = jax.tree_map(expand, args)\n kwargs = jax.tree_map(expand, kwargs)\n outputs = f(*args, **kwargs)\n return jax.tree_map(lambda t: jnp.squeeze(t, axis=axis), outputs)\n\n return wrapper","def ndarray_copy(func):\n\n def wrapper(*args, **kw):\n args = list(args)\n\n # copy args\n for idx, arg in enumerate(args):\n if type(arg) == np.ndarray:\n args[idx] = arg.copy()\n\n # Copy key args\n for key, value in kw.items():\n if type(value) == np.ndarray:\n kw[key] = value.copy()\n\n return func(*args, **kw)\n\n return wrapper","def maybe_get_check_shapes(func: Callable[..., Any]) -> Optional[Callable[[C], C]]:\n return getattr(func, \"__check_shapes__\", None) # type: ignore[no-any-return]","def __call__(self, *args):\n return args[self.i_dim]","def array_map(fn, arrs, n):\n # we shouldn't need a special case for n == 0, but NumPy complains about indexing into a zero-dimensional\n # array a using a[(Ellipsis,)].\n if n == 0:\n return fn(*arrs)\n \n full_shape = tuple(np.array([a.shape[:n] for a in arrs]).max(0))\n result = None\n for full_idx in itertools.product(*map(range, full_shape)):\n inputs = [a[broadcast(full_idx, a.shape[:n]) + (Ellipsis,)] for a in arrs]\n curr = fn(*inputs)\n \n if result is None:\n if type(curr) == tuple:\n result = tuple(np.zeros(full_shape + np.asarray(c).shape) for c in curr)\n else:\n result = np.zeros(full_shape + np.asarray(curr).shape)\n\n if type(curr) == tuple:\n for i, c in enumerate(curr):\n result[i][full_idx + (Ellipsis,)] = c\n else:\n result[full_idx + (Ellipsis,)] = curr\n return result","def check_mass_function_are_not_empty(function):\n @functools.wraps(function)\n def wrapped_function(*args):\n for arg in args:\n if arg.is_empty():\n raise EmptyMassFunctionError()\n return function(*args)\n return wrapped_function","def derive_args(func):\n args = inspect.getfullargspec(func).args\n if args and is_selfish_name(args[0]):\n del args[0]\n return args","def filter_fn(example, max_n_objects=max_n_objects):\n return tf.less_equal(tf.shape(example[\"objects\"][\"3d_coords\"])[0],\n tf.constant(max_n_objects, dtype=tf.int32))","def ignore_numpy_warning(test_func):\n def do_test(self, *args, **kwargs):\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore',\n message='numpy.ufunc size changed')\n test_func(self, *args, **kwargs)\n return do_test","def cudify(fn):\n\n @functools.wraps(fn)\n def wrapper(*args, **kwargs):\n result = fn(*args, **kwargs)\n return cuda_if_gpu(result)\n\n return wrapper","def test_convolve_input_dim_check(self, case, fn, x_shape, y_shape):\n x = torch.rand(*x_shape, dtype=self.dtype, device=self.device)\n y = torch.rand(*y_shape, dtype=self.dtype, device=self.device)\n\n message = [\n \"The operands must be the same dimension\",\n \"Leading dimensions of x and y are not broadcastable\",\n ][case]\n with self.assertRaisesRegex(ValueError, message):\n fn(x, y)","def wrapImg(func):\n def wrapFunc(*args, **kwargs):\n return np.array(func(*args, **kwargs))\n return wrapFunc","def sliced_fun(f, n_slices):\n\n def sliced_f(sliced_inputs, non_sliced_inputs=None):\n if non_sliced_inputs is None:\n non_sliced_inputs = []\n if isinstance(non_sliced_inputs, tuple):\n non_sliced_inputs = list(non_sliced_inputs)\n n_paths = len(sliced_inputs[0])\n slice_size = max(1, n_paths // n_slices)\n ret_vals = None\n for start in range(0, n_paths, slice_size):\n inputs_slice = [v[start:start + slice_size] for v in sliced_inputs]\n slice_ret_vals = f(*(inputs_slice + non_sliced_inputs))\n if not isinstance(slice_ret_vals, (tuple, list)):\n slice_ret_vals_as_list = [slice_ret_vals]\n else:\n slice_ret_vals_as_list = slice_ret_vals\n scaled_ret_vals = [\n np.asarray(v) * len(inputs_slice[0])\n for v in slice_ret_vals_as_list\n ]\n if ret_vals is None:\n ret_vals = scaled_ret_vals\n else:\n ret_vals = [x + y for x, y in zip(ret_vals, scaled_ret_vals)]\n ret_vals = [v / n_paths for v in ret_vals]\n if not isinstance(slice_ret_vals, (tuple, list)):\n ret_vals = ret_vals[0]\n elif isinstance(slice_ret_vals, tuple):\n ret_vals = tuple(ret_vals)\n return ret_vals\n\n return sliced_f","def _ureduce(a, func, **kwargs):\n a = np.asanyarray(a)\n axis = kwargs.get('axis', None)\n if axis is not None:\n keepdim = list(a.shape)\n nd = a.ndim\n axis = _nx.normalize_axis_tuple(axis, nd)\n\n for ax in axis:\n keepdim[ax] = 1\n\n if len(axis) == 1:\n kwargs['axis'] = axis[0]\n else:\n keep = set(range(nd)) - set(axis)\n nkeep = len(keep)\n # swap axis that should not be reduced to front\n for i, s in enumerate(sorted(keep)):\n a = a.swapaxes(i, s)\n # merge reduced axis\n a = a.reshape(a.shape[:nkeep] + (-1,))\n kwargs['axis'] = -1\n keepdim = tuple(keepdim)\n else:\n keepdim = (1,) * a.ndim\n\n r = func(a, **kwargs)\n return r, keepdim","def with_numpy(func):\r\n return func","def apply_only(self, function, worker, *args, **kwargs):\n pass","def require_context(fn):\n @functools.wraps(fn)\n def _require_cuda_context(*args, **kws):\n with _runtime.ensure_context():\n return fn(*args, **kws)\n\n return _require_cuda_context","def f_noarg(self) :\n pass","def requires_numpy(f):\n @wraps(f)\n def wrapper(*args, **kwargs):\n if _NUMPY_AVAILABLE:\n return f(*args, **kwargs)\n else:\n raise Warning(\"Numpy not available. Cannot call %s\" % f.__name__)\n return f(*args, **kwargs)\n return wrapper","def hypercube_bounded(index, null_value=0, shape=lambda xs: xs.shape[0],\n self_has_ndim=False):\n def get_bounded(fn):\n def fn_bounded(*args, **kwargs):\n xs = args[index]\n xs = interpret_array(xs, args[0].ndim if self_has_ndim else None)\n\n in_bounds = np.all((0 < xs) * (xs < 1), axis=1)\n\n res = np.empty(xs.shape[0])\n res[in_bounds] = fn(*args[:index], xs[in_bounds],\n *args[index+1:], **kwargs)\n res[np.logical_not(in_bounds)] = null_value\n\n return res\n\n return fn_bounded\n return get_bounded","def _get_required_args(func):\n module_logger.debug(f\"_get_required_args: func={func}\")\n fas = inspect.getfullargspec(func)\n module_logger.debug(f\"_get_required_args: fas={fas}\")\n len_args = len(fas.args)\n len_args += len(fas.kwonlyargs)\n if fas.kwonlydefaults is not None:\n len_args -= len(fas.kwonlydefaults)\n if fas.defaults is not None:\n len_args -= len(fas.defaults)\n return len_args","def exceptNull(func): # -> (*args: Unknown, **kwargs: Unknown) -> Unknown:\n ...","def multichannel(fcn):\n return lambda args: (fcn(*args), )","def variadic_args(self, /, *args, **kwargs):\n return self._func(args, **kwargs)","def test_empty(self):\n a = np.ones((3, 4, 5))\n ai = np.ones((3, 0, 5), dtype=np.intp)\n\n actual = take_along_axis(a, ai, axis=1)\n assert_equal(actual.shape, ai.shape)","def required_input_dim(space: gym.Space, **kwargs) -> int:","def dimWhen(*args, clear: bool=True, false: bool=True, true: bool=True, **kwargs)->None:\n pass","def my_func(self, a, b, c, d=None):\n return True","def wrapper(*args, **kwargs):\n return fn(*args, **kwargs)","def rank_zero_only(fn):\n\n @wraps(fn)\n def wrapped_fn(self, *args, **kwargs):\n if self.rank == 0:\n fn(self, *args, **kwargs)\n\n return wrapped_fn","def test_check_X_too_many_dims():\n with pytest.raises(ValueError):\n check_X(np.ones((5,4,3)))","def container_scatter_kwargs(inputs, kwargs, target_gpus, dim=0):\n inputs = container_scatter(inputs, target_gpus, dim) if inputs else []\n kwargs = container_scatter(kwargs, target_gpus, dim) if kwargs else []\n\n if len(inputs) < len(kwargs):\n inputs.extend([() for _ in range(len(kwargs) - len(inputs))])\n elif len(kwargs) < len(inputs):\n kwargs.extend([{} for _ in range(len(inputs) - len(kwargs))])\n\n # patch for cases where #inputs < len(target_gpus) and len(kwargs) > 0\n PATCH = 1\n if PATCH:\n is_empty = [len(p) == 0 for p in inputs]\n num_empty = sum(is_empty)\n num_full = len(inputs) - num_empty\n if num_full > 0 and num_empty > 0:\n kwargs = kwargs[0:num_full]\n inputs = inputs[0:num_full]\n\n inputs = tuple(inputs)\n kwargs = tuple(kwargs)\n return inputs, kwargs","def zeros(*args):\n dims = list(args)\n assert type(dims[0]) == int\n return params_func(cmd, \"zeros\", params=dims, return_type='FloatTensor')","def optional_parameter_decorator(f):\n @functools.wraps(f)\n def wrapped_decorator(*args, **kwargs):\n if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):\n # Return the actual decorated function.\n return f(args[0])\n else:\n # Wrap the function in a decorator in the case that arguments are\n # applied.\n return lambda realf: f(realf, *args, **kwargs)\n return wrapped_decorator","def _memoizeArgsOnly (max_cache_size=1000):\n def wrapper (f):\n def fn (*args):\n try:\n return fn.cache[args]\n except KeyError:\n if fn.count >= max_cache_size:\n fn.cache = {}\n fn.count = 0\n fn.cache[args] = result = f(*args)\n fn.count += 1\n return result\n fn.cache = {}\n fn.count = 0\n return fn\n return wrapper","def getArgs(func):\n # exclude the defaults at the end (hence the [:-1])\n args = list(utils.flatten(inspect.getargspec(func)[:-1]))\n return set(args).difference(set([None]))","def test_default_args(self):\n cfunc = njit(g)\n self.assertEqual(cfunc(1, 2, 3), g(1, 2, 3))\n self.assertEqual(cfunc(1, y=2, z=3), g(1, 2, 3))","def wrap(func, *args, unsqueeze=False):\n\n # Convert input types where applicable\n args = list(args)\n for i, arg in enumerate(args):\n if type(arg) == np.ndarray:\n args[i] = torch.from_numpy(arg)\n if unsqueeze:\n args[i] = args[i].unsqueeze(0)\n\n result = func(*args)\n\n # Convert output types where applicable\n if isinstance(result, tuple):\n result = list(result)\n for i, res in enumerate(result):\n if type(res) == torch.Tensor:\n if unsqueeze:\n res = res.squeeze(0)\n result[i] = res.numpy()\n return tuple(result)\n elif type(result) == torch.Tensor:\n if unsqueeze:\n result = result.squeeze(0)\n return result.numpy()\n else:\n return result"],"string":"[\n \"def _add_keepdims(func):\\n @functools.wraps(func)\\n def wrapped(a, axis, **kwargs):\\n res = func(a, axis=axis, **kwargs)\\n if axis is None:\\n axis = 0 # res is now a scalar, so we can insert this anywhere\\n return np.expand_dims(res, axis=axis)\\n return wrapped\",\n \"def arguments_not_none(func):\\n def wrapper(*args, **kwargs):\\n for arg in args:\\n if arg is None:\\n raise NullArgument()\\n for arg, val in kwargs.iteritems():\\n if val is None:\\n raise NullArgument()\\n try:\\n return func(*args, **kwargs)\\n except TypeError as ex:\\n if 'takes exactly' in ex.args[0]:\\n raise NullArgument('Wrong number of arguments provided: ' + str(ex.args[0]))\\n else:\\n raise\\n\\n return wrapper\",\n \"def make_gufunc(f, core_dims_in, core_dims_out):\\n\\n def gufunc(args):\\n args = generalized_broadcast(args)\\n data_shape = args[0].shape[:-len(core_dims_in[0])]\\n args = [A.reshape(-1, A.shape[-1]) for A in args]\\n\\n #if X_out is None:\\n # X_out = np.empty_like(X)\\n #X_out = X_out.reshape(-1, X.shape[-1])\\n\\n out = f(args)\\n\\n return out.reshape(data_shape + core_dims_out)\\n\\n return gufunc\",\n \"def can_take_n_args(func, n=2):\\n (pos, args, kwargs, defaults) = inspect.getargspec(func)\\n if args is not None or len(pos) >= n:\\n return True\\n return False\",\n \"def vectorized_fn(*args):\\n with tf.name_scope(name or 'make_rank_polymorphic'):\\n # If we got a single value for core_ndims, tile it across all args.\\n core_ndims_structure = (\\n core_ndims\\n if tf.nest.is_nested(core_ndims)\\n else tf.nest.map_structure(lambda _: core_ndims, args))\\n\\n # Build flat lists of all argument parts and their corresponding core\\n # ndims.\\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\\n flat_args = nest.flatten_up_to(\\n core_ndims_structure, args, check_types=False)\\n\\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\\n # values for `core_ndims`). Other args will be passed through to `fn`\\n # unmodified.\\n (vectorized_arg_core_ndims,\\n vectorized_args,\\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\\n fn,\\n arg_structure=core_ndims_structure,\\n flat_core_ndims=flat_core_ndims,\\n flat_args=flat_args)\\n\\n # `vectorized_map` requires all inputs to have a single, common batch\\n # dimension `[n]`. So we broadcast all input parts to a common\\n # batch shape, then flatten it down to a single dimension.\\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\\n\\n vectorized_arg_actual_core_ndims = []\\n batch_shapes, core_shapes = [], []\\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\\n vectorized_arg_core_ndims):\\n arg_nd = ps.rank_from_shape(arg_shape)\\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\\n # `batch_ndims` is always nonnegative.\\n actual_core_nd = ps.minimum(arg_nd, core_nd)\\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\\n\\n batch_ndims = arg_nd - actual_core_nd\\n batch_ndims_ = tf.get_static_value(batch_ndims)\\n if batch_ndims_ is not None:\\n batch_shapes.append(arg_shape[:batch_ndims_])\\n core_shapes.append(arg_shape[batch_ndims_:])\\n else:\\n arg_shape = tf.convert_to_tensor(arg_shape)\\n batch_shapes.append(arg_shape[:batch_ndims])\\n core_shapes.append(arg_shape[batch_ndims:])\\n\\n # Flatten all of the batch dimensions into one.\\n broadcast_batch_shape = (\\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\\n\\n static_n = tf.get_static_value(n)\\n if static_n == 1:\\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\\n result_batch_dims = 0\\n batched_result = fn_of_vectorized_args(\\n tf.nest.map_structure(\\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\\n vectorized_args,\\n vectorized_arg_actual_core_ndims,\\n check_types=False))\\n else:\\n # Pad all input parts to the common shape, then flatten\\n # into the single leading dimension `[n]`.\\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\\n # when batch rank is static so that we can exploit broadcasting.\\n broadcast_vectorized_args = [\\n tf.broadcast_to(part, ps.concat(\\n [broadcast_batch_shape, core_shape], axis=0))\\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\\n vectorized_args_with_flattened_batch_dim = [\\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\\n for (part, core_shape) in zip(\\n broadcast_vectorized_args, core_shapes)]\\n result_batch_dims = 1\\n batched_result = tf.vectorized_map(\\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\\n\\n # Unflatten any `Tensor`s in the result.\\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\\n result = tf.nest.map_structure(\\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\\n expand_composites=True)\\n return result\",\n \"def n_ary(func):\\n def wrapper(x, *args):\\n return x if not args else func(x, wrapper(*args))\\n return wrapper\",\n \"def filter_args(fn, args_tuple):\\n sig = inspect.signature(fn)\\n flag_var_positional = any([\\n inspect.Parameter.VAR_POSITIONAL == value.kind for\\n value in sig.parameters.values()])\\n if flag_var_positional:\\n return args_tuple\\n else:\\n num_args = len(sig.parameters.items())\\n return args_tuple[:num_args]\",\n \"def right_shape(func, args, expected):\\n \\n if args is None:\\n assert(np.shape(func())==expected)\\n else:\\n assert(np.shape(func(*args))==expected)\",\n \"def wrapped_function(*args, **kwargs):\\n nargs = len(args) - start\\n torch_objects = torch.Tensor\\n if any(isinstance(arg, torch_objects) for arg in args[start:]):\\n # reduce number of function calls in graph\\n if nargs == 1:\\n return function(*args, **kwargs)\\n # concatenate extra arguments\\n args = args[:start] + (torch.cat(args[start:], dim=1),)\\n return function(*args, **kwargs)\\n else:\\n to_concatenate = list(map(np.atleast_2d, args[start:]))\\n if nargs == 1:\\n concatenated = tuple(to_concatenate)\\n else:\\n concatenated = (np.hstack(to_concatenate),)\\n \\n args = args[:start] + concatenated\\n return function(*args, **kwargs)\",\n \"def check_inputs(function):\\n def decorated(self, data, *args, **kwargs):\\n if not (isinstance(data, np.ndarray) and len(data.shape) == 2 and data.shape[1] == 1):\\n raise ValueError('The argument `data` must be a numpy.ndarray with shape (n, 1).')\\n\\n return function(self, data, *args, **kwargs)\\n\\n decorated.__doc__ = function.__doc__\\n return decorated\",\n \"def wrapperfunc_noargs(func):\\n def wrap_noargs_wrapper(self, arg):\\n return wrapperfunc(func)(self)(arg)\\n return wrap_noargs_wrapper\",\n \"def rank_zero_only(fn):\\n\\n def wrapped(*args, **kwargs):\\n if rank() == 0:\\n return fn(*args, **kwargs)\\n\\n return wrapped\",\n \"def flatten_args(shapes):\\n def flatten_args_dec(func):\\n\\n @wraps(func)\\n def new_func(array1d, *args, **kwargs):\\n args = tuple(unflatten(array1d, shapes)) + args\\n return func(*args, **kwargs)\\n\\n return new_func\\n\\n return flatten_args_dec\",\n \"def remove_unused_args(args, thnn_args):\\n def clean_name(name):\\n name = name[:name.index('[')] if '[' in name else name\\n if name.endswith('_'):\\n name = name[:-1]\\n return name\\n uses = set([clean_name(arg['name']) for arg in thnn_args])\\n uses.add('output_mask')\\n args = [arg for arg in args if arg['name'] in uses]\\n for arg in args:\\n if 'default' in arg:\\n del arg['default']\\n return args\",\n \"def scalarDecorator(func):\\n @wraps(func)\\n def scalar_wrapper(*args,**kwargs):\\n if numpy.array(args[0]).shape == ():\\n scalarOut= True\\n newargs= ()\\n for ii in range(len(args)):\\n if ii == 0:\\n newargs= newargs+(numpy.array([args[ii]]),)\\n else:\\n newargs= newargs+(args[ii],)\\n args= newargs\\n else:\\n scalarOut= False\\n result= func(*args,**kwargs)\\n if scalarOut:\\n return result[0]\\n else:\\n return result\\n return scalar_wrapper\",\n \"def preserve_shape(func):\\n @wraps(func)\\n def wrapped_function(img, *args, **kwargs):\\n shape = img.shape\\n result = func(img, *args, **kwargs)\\n result = result.reshape(shape)\\n return result\\n\\n return wrapped_function\",\n \"def n_ary(f):\\n def n_ary_fn(x, *args):\\n return x if not args else f(x, n_ary_fn(*args))\\n return n_ary_fn\",\n \"def n_ary(f):\\n def n_ary_f(x,*args):\\n return x if not args else f(x,n_ary_f(*args))\\n return n_ary_f\",\n \"def missingArgs(func, argdict):\\n return set(getRequiredArgs(func)).difference(argdict)\",\n \"def vectorize_inputs(f):\\n return lambda args: f(*np.hsplit(args, args.shape[1]))\",\n \"def test_clugen_optional(\\n prng,\\n ndims,\\n vec_or_mat,\\n clusep_fn,\\n cluoff_fn,\\n allow_empty,\\n ptdist_fn,\\n ptoff_fn,\\n csz_fn,\\n cctr_fn,\\n llen_fn,\\n lang_fn,\\n):\\n # Valid arguments\\n nclu = 7\\n tpts = 500\\n astd = pi / 256\\n len_mu = 9\\n len_std = 1.2\\n lat_std = 2\\n\\n # Get direction\\n direc = vec_or_mat(ndims, nclu)\\n\\n with warnings.catch_warnings():\\n # Check that the function runs without warnings\\n warnings.simplefilter(\\\"error\\\")\\n result = clugen(\\n ndims,\\n nclu,\\n tpts,\\n direc,\\n astd,\\n clusep_fn(ndims),\\n len_mu,\\n len_std,\\n lat_std,\\n allow_empty=allow_empty,\\n cluster_offset=cluoff_fn(ndims),\\n proj_dist_fn=ptdist_fn,\\n point_dist_fn=ptoff_fn,\\n clusizes_fn=csz_fn,\\n clucenters_fn=cctr_fn,\\n llengths_fn=llen_fn,\\n angle_deltas_fn=lang_fn,\\n rng=prng,\\n )\\n\\n # Check dimensions of result variables\\n assert result.points.shape == (tpts, ndims)\\n assert result.clusters.shape == (tpts,)\\n assert result.projections.shape == (tpts, ndims)\\n assert result.sizes.shape == (nclu,)\\n assert result.centers.shape == (nclu, ndims)\\n assert result.directions.shape == (nclu, ndims)\\n assert result.angles.shape == (nclu,)\\n assert result.lengths.shape == (nclu,)\\n\\n # Check point cluster indexes\\n if not allow_empty:\\n assert all(unique(result.clusters) == arange(nclu))\\n else:\\n assert all(result.clusters < nclu)\\n\\n # Check total points\\n assert sum(result.sizes) == tpts\\n # This might not be the case if the specified clusize_fn does not obey\\n # the total number of points\\n\\n # Check that cluster directions have the correct angles with the main direction\\n if ndims > 1:\\n if direc.ndim == 1:\\n direc = repeat(direc.reshape((1, -1)), nclu, axis=0)\\n for i in range(nclu):\\n assert_allclose(\\n angle_btw(direc[i, :], result.directions[i, :]),\\n abs(result.angles[i]),\\n atol=1e-11,\\n )\",\n \"def any(tensor, axis=None, keepdims=False, **kwargs):\\n return tensor.any(axis=axis, keepdims=keepdims, **kwargs)\",\n \"def _wrapper(func, args):\\n return func(*args)\",\n \"def autovectorized(f):\\r\\n def wrapper(input):\\r\\n if N.isscalar(input)==False:\\r\\n return N.vectorize(f)(input)\\r\\n return f(input)\\r\\n return wrapper\",\n \"def autovectorized(f):\\r\\n def wrapper(input):\\r\\n if N.isscalar(input)==False:\\r\\n return N.vectorize(f)(input)\\r\\n return f(input)\\r\\n return wrapper\",\n \"def make_rank_polymorphic(fn, core_ndims, name=None):\\n\\n def vectorized_fn(*args):\\n \\\"\\\"\\\"Vectorized version of `fn` that accepts arguments of any rank.\\\"\\\"\\\"\\n with tf.name_scope(name or 'make_rank_polymorphic'):\\n # If we got a single value for core_ndims, tile it across all args.\\n core_ndims_structure = (\\n core_ndims\\n if tf.nest.is_nested(core_ndims)\\n else tf.nest.map_structure(lambda _: core_ndims, args))\\n\\n # Build flat lists of all argument parts and their corresponding core\\n # ndims.\\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\\n flat_args = nest.flatten_up_to(\\n core_ndims_structure, args, check_types=False)\\n\\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\\n # values for `core_ndims`). Other args will be passed through to `fn`\\n # unmodified.\\n (vectorized_arg_core_ndims,\\n vectorized_args,\\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\\n fn,\\n arg_structure=core_ndims_structure,\\n flat_core_ndims=flat_core_ndims,\\n flat_args=flat_args)\\n\\n # `vectorized_map` requires all inputs to have a single, common batch\\n # dimension `[n]`. So we broadcast all input parts to a common\\n # batch shape, then flatten it down to a single dimension.\\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\\n\\n vectorized_arg_actual_core_ndims = []\\n batch_shapes, core_shapes = [], []\\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\\n vectorized_arg_core_ndims):\\n arg_nd = ps.rank_from_shape(arg_shape)\\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\\n # `batch_ndims` is always nonnegative.\\n actual_core_nd = ps.minimum(arg_nd, core_nd)\\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\\n\\n batch_ndims = arg_nd - actual_core_nd\\n batch_ndims_ = tf.get_static_value(batch_ndims)\\n if batch_ndims_ is not None:\\n batch_shapes.append(arg_shape[:batch_ndims_])\\n core_shapes.append(arg_shape[batch_ndims_:])\\n else:\\n arg_shape = tf.convert_to_tensor(arg_shape)\\n batch_shapes.append(arg_shape[:batch_ndims])\\n core_shapes.append(arg_shape[batch_ndims:])\\n\\n # Flatten all of the batch dimensions into one.\\n broadcast_batch_shape = (\\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\\n\\n static_n = tf.get_static_value(n)\\n if static_n == 1:\\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\\n result_batch_dims = 0\\n batched_result = fn_of_vectorized_args(\\n tf.nest.map_structure(\\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\\n vectorized_args,\\n vectorized_arg_actual_core_ndims,\\n check_types=False))\\n else:\\n # Pad all input parts to the common shape, then flatten\\n # into the single leading dimension `[n]`.\\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\\n # when batch rank is static so that we can exploit broadcasting.\\n broadcast_vectorized_args = [\\n tf.broadcast_to(part, ps.concat(\\n [broadcast_batch_shape, core_shape], axis=0))\\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\\n vectorized_args_with_flattened_batch_dim = [\\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\\n for (part, core_shape) in zip(\\n broadcast_vectorized_args, core_shapes)]\\n result_batch_dims = 1\\n batched_result = tf.vectorized_map(\\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\\n\\n # Unflatten any `Tensor`s in the result.\\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\\n result = tf.nest.map_structure(\\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\\n expand_composites=True)\\n return result\\n\\n return vectorized_fn\",\n \"def default_helper_c_code_args():\\r\\n\\r\\n return {\\r\\n \\\"c_prefix\\\": \\\"PyArray\\\",\\r\\n \\\"strides_mul\\\": 1,\\r\\n }\",\n \"def one_dim_nogil_cfunc(a: cython.double[:]):\\n with cython.nogil:\\n result = _one_dim_nogil_cfunc(a)\\n return result\",\n \"def function(args):\\n pass\",\n \"def fn(*args, **kwargs):\\n pass\",\n \"def gnumpy_func_wrap(f):\\n def inner(*args):\\n args = garray_to_cudandarray_nested(args)\\n res = f(*args)\\n if isinstance(res, list):\\n res = cudandarray_to_garray_nested(res)\\n else:\\n # TODO: check for CudaNdArray instance instead\\n if not isinstance(res, (float, np.ndarray)):\\n res = gput.cudandarray_to_garray(res)\\n return res\\n return inner\",\n \"def slice_optional(m: typing.Optional[cython.double[:]]):\\n return 1 if m is None else 2\",\n \"def does_it_run(func, args):\\n \\n if args is None:\\n func()\\n else:\\n func(*args)\",\n \"def crop(dimension, start, end):\\n def func(x):\\n if dimension == 0:\\n return x[start: end]\\n if dimension == 1:\\n return x[:, start: end]\\n if dimension == 2:\\n return x[:, :, start: end]\\n if dimension == 3:\\n return x[:, :, :, start: end]\\n if dimension == 4:\\n return x[:, :, :, :, start: end]\\n return Lambda(func)\",\n \"def dummy_fn(self, *args, **kwargs):\",\n \"def tonal_args(func, instance, args, kwargs):\\n\\n def wrapper(*args, **kwargs):\\n\\n [err_if_not_tonal(arg) for arg in args]\\n\\n return func(*args, **kwargs)\\n\\n return wrapper\",\n \"def atleast_nd(arr, n, front=False):\\n arr_ = np.asanyarray(arr)\\n ndims = len(arr_.shape)\\n if n is not None and ndims < n:\\n # append the required number of dimensions to the front or back\\n if front:\\n expander = (None,) * (n - ndims) + (Ellipsis,)\\n else:\\n expander = (Ellipsis,) + (None,) * (n - ndims)\\n arr_ = arr_[expander]\\n return arr_\",\n \"def ndflip(a):\\n ind = (slice(None,None,-1),)*a.ndim\\n return a[ind]\",\n \"def array_input(f):\\n @wraps(f)\\n def wrapped(self, t):\\n t = np.atleast_1d(t)\\n r = f(self, t)\\n return r\\n return wrapped\",\n \"def no_arg():\\n run_no_arg()\",\n \"def noop(*argv):\\n pass\",\n \"def is_args_in_task(func):\\n arg = inspect.getargs(func.func_code)\\n return arg.varargs is not None\",\n \"def test_no_args():\\r\\n # test module\\r\\n test_data = doc.MatObject.matlabify('test_data')\\r\\n test_submodule = test_data.getter('test_submodule')\\r\\n ok_(isinstance(test_submodule, doc.MatModule))\\r\\n eq_(test_submodule.__package__, 'test_data.test_submodule')\\r\\n f = test_submodule.getter('f_no_args')\\r\\n ok_(isinstance(f, doc.MatFunction))\\r\\n eq_(f.retv, ['output', 'with', 'ellipsis'])\\r\\n ok_(not f.args)\\r\\n return f\",\n \"def any_(*args, **kwargs):\\n ...\",\n \"def apply_function(f, args):\\n if len(signature(f).parameters) == len(args):\\n func = curry(f)\\n for arg_value in args:\\n func = func(arg_value)\\n return func()\\n else:\\n raise Exception(\\\"the number of function's parameter is not matched args, len(args): \\\", len(args))\",\n \"def test_no_mutually_exclusive_args_provided(self):\\n _func = mutually_exclusive_parameters('arg1', 'arg2')(undecorated_func)\\n self.assertEqual(_func(), 'foo')\\n self.assertEqual(_func(arg3='hello'), 'foo')\",\n \"def _reductions(\\n func: Callable,\\n values: np.ndarray,\\n mask: npt.NDArray[np.bool_],\\n *,\\n skipna: bool = True,\\n min_count: int = 0,\\n axis: AxisInt | None = None,\\n **kwargs,\\n):\\n if not skipna:\\n if mask.any() or check_below_min_count(values.shape, None, min_count):\\n return libmissing.NA\\n else:\\n return func(values, axis=axis, **kwargs)\\n else:\\n if check_below_min_count(values.shape, mask, min_count) and (\\n axis is None or values.ndim == 1\\n ):\\n return libmissing.NA\\n\\n return func(values, where=~mask, axis=axis, **kwargs)\",\n \"def _wrap_2d_function(inputs, compute_op, dim=-1, name=None):\\n\\n def _swap_axis(input_tensor, dim_index, last_index, name=None):\\n \\\"\\\"\\\"Swaps logits's dim_index and last_index.\\\"\\\"\\\"\\n return array_ops.transpose(\\n input_tensor,\\n array_ops.concat([\\n math_ops.range(dim_index), [last_index],\\n math_ops.range(dim_index + 1, last_index), [dim_index]\\n ], 0),\\n name=name)\\n\\n inputs = ops.convert_to_tensor(inputs)\\n\\n # We need its original shape for shape inference.\\n shape = inputs.get_shape()\\n is_last_dim = (dim == -1) or (dim == shape.ndims - 1)\\n\\n if is_last_dim:\\n return compute_op(inputs, name=name)\\n\\n dim_val = dim\\n if isinstance(dim, tensor_lib.Tensor):\\n dim_val = tensor_util.constant_value(dim)\\n if dim_val is not None and not -shape.ndims <= dim_val < shape.ndims:\\n raise errors_impl.InvalidArgumentError(\\n None, None,\\n f\\\"`dim` must be in the range [{-shape.ndims}, {shape.ndims}) where \\\"\\n f\\\"{shape.ndims} is the number of dimensions in the input. \\\"\\n f\\\"Received: dim={dim_val}\\\")\\n\\n # If dim is not the last dimension, we have to do a transpose so that we can\\n # still perform the op on its last dimension.\\n\\n # In case dim is negative (and is not last dimension -1), add shape.ndims\\n ndims = array_ops.rank(inputs)\\n if not isinstance(dim, tensor_lib.Tensor):\\n if dim < 0:\\n dim += ndims\\n else:\\n dim = array_ops.where(math_ops.less(dim, 0), dim + ndims, dim)\\n\\n # Swap logits' dimension of dim and its last dimension.\\n input_rank = array_ops.rank(inputs)\\n dim_axis = dim % shape.ndims\\n inputs = _swap_axis(inputs, dim_axis, math_ops.subtract(input_rank, 1))\\n\\n # Do the actual call on its last dimension.\\n def fix_output(output):\\n output = _swap_axis(\\n output, dim_axis, math_ops.subtract(input_rank, 1), name=name)\\n\\n # Make shape inference work since transpose may erase its static shape.\\n output.set_shape(shape)\\n return output\\n\\n outputs = compute_op(inputs)\\n if isinstance(outputs, tuple):\\n return tuple(fix_output(output) for output in outputs)\\n else:\\n return fix_output(outputs)\",\n \"def only_one_nondefault(args):\\n defaults = 0 if args.defaults is None else len(args.defaults)\\n if len(args.args) >= 1 and (len(args.args) - defaults <= 1):\\n return True\\n else:\\n return False\",\n \"def n_ary(f):\\n #def n_ary_f(x, *args):\\n #if len(args) == 0:\\n #return x\\n #return f(x,n_ary_f(args[0],*args[1:]))\\n def n_ary_f(x, *args):\\n return x if not args else f(x,n_ary_f(*args))\\n return n_ary_f\",\n \"def numpyfunc(*args, **kwargs):\\n def _decorator(func):\\n return numpy.frompyfunc(func, *args, **kwargs)\\n return _decorator\",\n \"def dummy_func(*args, **kwargs):\\r\\n pass\",\n \"def output_dims(self) -> Optional[Tuple[int]]:\\n return None\",\n \"def check(\\n ureg: UnitRegistry, *args: Optional[Union[str, UnitsContainer, Unit]]\\n) -> Callable[[F], F]:\\n dimensions = [\\n ureg.get_dimensionality(dim) if dim is not None else None for dim in args\\n ]\\n\\n def decorator(func):\\n count_params = len(signature(func).parameters)\\n if len(dimensions) != count_params:\\n raise TypeError(\\n \\\"%s takes %i parameters, but %i dimensions were passed\\\"\\n % (func.__name__, count_params, len(dimensions))\\n )\\n\\n assigned = tuple(\\n attr for attr in functools.WRAPPER_ASSIGNMENTS if hasattr(func, attr)\\n )\\n updated = tuple(\\n attr for attr in functools.WRAPPER_UPDATES if hasattr(func, attr)\\n )\\n\\n @functools.wraps(func, assigned=assigned, updated=updated)\\n def wrapper(*args, **kwargs):\\n list_args, empty = _apply_defaults(func, args, kwargs)\\n\\n for dim, value in zip(dimensions, list_args):\\n if dim is None:\\n continue\\n\\n if not ureg.Quantity(value).check(dim):\\n val_dim = ureg.get_dimensionality(value)\\n raise DimensionalityError(value, \\\"a quantity of\\\", val_dim, dim)\\n return func(*args, **kwargs)\\n\\n return wrapper\\n\\n return decorator\",\n \"def validate_args(fn, *args, **kwargs):\\n required_args = [\\n p.name for p in inspect.signature(fn).parameters.values()\\n if p.default == inspect.Parameter.empty\\n and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD]\\n missing_required_args = required_args[len(args):]\\n\\n missing = [arg for arg in missing_required_args if arg not in kwargs]\\n if missing:\\n raise MissingArgs(missing)\",\n \"def any(self, axis=None, keepdims=False, out=None):\\n return np.logical_or.reduce(self, out=out, axis=axis, keepdims=keepdims)\",\n \"def debug_callback_batching_rule(args, dims, **params):\\n axis_size = next(x.shape[i] for x, i in zip(args, dims)\\n if i is not None)\\n # TODO(sharadmv): implement in terms of rolled loop unstead of\\n # unrolled.\\n def get_arg_at_dim(i, dim, arg):\\n if dim is batching.not_mapped:\\n # Broadcast unmapped argument\\n return arg\\n return lax.index_in_dim(arg, i, axis=dim, keepdims=False)\\n outs = []\\n for i in range(axis_size):\\n args_idx = map(functools.partial(get_arg_at_dim, i), dims, args)\\n outs.append(debug_callback_p.bind(*args_idx, **params))\\n outs = [jnp.stack(xs) for xs in zip(*outs)]\\n return outs, (0,) * len(outs)\",\n \"def abs_dev_knn_star(args):\\n return abs_dev_knn(*args)\",\n \"def test_clugen_optional_direct(\\n prng,\\n ndims,\\n num_clusters,\\n vec_or_mat,\\n clusep_fn,\\n allow_empty,\\n):\\n # Direct parameters (instead of functions)\\n csz_direct = prng.integers(1, 100, num_clusters)\\n cctr_direct = prng.normal(size=(num_clusters, ndims))\\n llen_direct = 20 * prng.random(num_clusters)\\n lang_direct = pi * prng.random(num_clusters) - pi / 2\\n\\n # Valid arguments\\n tpts = sum(csz_direct)\\n astd = pi / 333\\n len_mu = 6\\n len_std = 1.1\\n lat_std = 1.6\\n\\n # Get direction\\n direc = vec_or_mat(ndims, num_clusters)\\n\\n with warnings.catch_warnings():\\n # Check that the function runs without warnings\\n warnings.simplefilter(\\\"error\\\")\\n result = clugen(\\n ndims,\\n num_clusters,\\n tpts,\\n direc,\\n astd,\\n clusep_fn(ndims),\\n len_mu,\\n len_std,\\n lat_std,\\n allow_empty=allow_empty,\\n clusizes_fn=csz_direct,\\n clucenters_fn=cctr_direct,\\n llengths_fn=llen_direct,\\n angle_deltas_fn=lang_direct,\\n rng=prng,\\n )\\n\\n # Check dimensions of result variables\\n assert result.points.shape == (tpts, ndims)\\n assert result.clusters.shape == (tpts,)\\n assert result.projections.shape == (tpts, ndims)\\n assert result.sizes.shape == (num_clusters,)\\n assert result.centers.shape == (num_clusters, ndims)\\n assert result.directions.shape == (num_clusters, ndims)\\n assert result.angles.shape == (num_clusters,)\\n assert result.lengths.shape == (num_clusters,)\\n\\n # Check point cluster indexes\\n if not allow_empty:\\n assert all(unique(result.clusters) == arange(num_clusters))\\n else:\\n assert all(result.clusters < num_clusters)\\n\\n # Check total points\\n assert sum(result.sizes) == tpts\\n # This might not be the case if the specified clusize_fn does not obey\\n # the total number of points\\n\\n # Check that cluster directions have the correct angles with the main direction\\n if ndims > 1:\\n if direc.ndim == 1:\\n direc = repeat(direc.reshape((1, -1)), num_clusters, axis=0)\\n for i in range(num_clusters):\\n assert_allclose(\\n angle_btw(direc[i, :], result.directions[i, :]),\\n abs(result.angles[i]),\\n atol=1e-11,\\n )\",\n \"def test_map_args_all_none():\\n pass\",\n \"def run_func_decorator(\\n *func_args: list[Any],\\n **func_kwargs: dict[str, Any],\\n ) -> Any:\\n if isinstance(world_size, int):\\n dist_launcher(world_size, *func_args, **func_kwargs)\\n elif isinstance(world_size, list):\\n for procs in world_size:\\n dist_launcher(procs, *func_args, **func_kwargs)\\n time.sleep(0.5)\\n else:\\n raise TypeError(\\n 'world_size must be an integer or a list of integers.',\\n )\",\n \"def fn(x):\\n if x.ndim == 1:\\n return np.sum(x**2)\\n else:\\n return np.sum(x**2, axis=1)\",\n \"def expand_apply(f, axis=0):\\n if axis not in [0, -1]:\\n raise ValueError(\\\"expand_apply currently only supports axis=0 or axis=-1.\\\")\\n\\n @functools.wraps(f)\\n def wrapper(*args, **kwargs):\\n expand = lambda t: jnp.expand_dims(t, axis=axis)\\n args = jax.tree_map(expand, args)\\n kwargs = jax.tree_map(expand, kwargs)\\n outputs = f(*args, **kwargs)\\n return jax.tree_map(lambda t: jnp.squeeze(t, axis=axis), outputs)\\n\\n return wrapper\",\n \"def ndarray_copy(func):\\n\\n def wrapper(*args, **kw):\\n args = list(args)\\n\\n # copy args\\n for idx, arg in enumerate(args):\\n if type(arg) == np.ndarray:\\n args[idx] = arg.copy()\\n\\n # Copy key args\\n for key, value in kw.items():\\n if type(value) == np.ndarray:\\n kw[key] = value.copy()\\n\\n return func(*args, **kw)\\n\\n return wrapper\",\n \"def maybe_get_check_shapes(func: Callable[..., Any]) -> Optional[Callable[[C], C]]:\\n return getattr(func, \\\"__check_shapes__\\\", None) # type: ignore[no-any-return]\",\n \"def __call__(self, *args):\\n return args[self.i_dim]\",\n \"def array_map(fn, arrs, n):\\n # we shouldn't need a special case for n == 0, but NumPy complains about indexing into a zero-dimensional\\n # array a using a[(Ellipsis,)].\\n if n == 0:\\n return fn(*arrs)\\n \\n full_shape = tuple(np.array([a.shape[:n] for a in arrs]).max(0))\\n result = None\\n for full_idx in itertools.product(*map(range, full_shape)):\\n inputs = [a[broadcast(full_idx, a.shape[:n]) + (Ellipsis,)] for a in arrs]\\n curr = fn(*inputs)\\n \\n if result is None:\\n if type(curr) == tuple:\\n result = tuple(np.zeros(full_shape + np.asarray(c).shape) for c in curr)\\n else:\\n result = np.zeros(full_shape + np.asarray(curr).shape)\\n\\n if type(curr) == tuple:\\n for i, c in enumerate(curr):\\n result[i][full_idx + (Ellipsis,)] = c\\n else:\\n result[full_idx + (Ellipsis,)] = curr\\n return result\",\n \"def check_mass_function_are_not_empty(function):\\n @functools.wraps(function)\\n def wrapped_function(*args):\\n for arg in args:\\n if arg.is_empty():\\n raise EmptyMassFunctionError()\\n return function(*args)\\n return wrapped_function\",\n \"def derive_args(func):\\n args = inspect.getfullargspec(func).args\\n if args and is_selfish_name(args[0]):\\n del args[0]\\n return args\",\n \"def filter_fn(example, max_n_objects=max_n_objects):\\n return tf.less_equal(tf.shape(example[\\\"objects\\\"][\\\"3d_coords\\\"])[0],\\n tf.constant(max_n_objects, dtype=tf.int32))\",\n \"def ignore_numpy_warning(test_func):\\n def do_test(self, *args, **kwargs):\\n with warnings.catch_warnings():\\n warnings.filterwarnings('ignore',\\n message='numpy.ufunc size changed')\\n test_func(self, *args, **kwargs)\\n return do_test\",\n \"def cudify(fn):\\n\\n @functools.wraps(fn)\\n def wrapper(*args, **kwargs):\\n result = fn(*args, **kwargs)\\n return cuda_if_gpu(result)\\n\\n return wrapper\",\n \"def test_convolve_input_dim_check(self, case, fn, x_shape, y_shape):\\n x = torch.rand(*x_shape, dtype=self.dtype, device=self.device)\\n y = torch.rand(*y_shape, dtype=self.dtype, device=self.device)\\n\\n message = [\\n \\\"The operands must be the same dimension\\\",\\n \\\"Leading dimensions of x and y are not broadcastable\\\",\\n ][case]\\n with self.assertRaisesRegex(ValueError, message):\\n fn(x, y)\",\n \"def wrapImg(func):\\n def wrapFunc(*args, **kwargs):\\n return np.array(func(*args, **kwargs))\\n return wrapFunc\",\n \"def sliced_fun(f, n_slices):\\n\\n def sliced_f(sliced_inputs, non_sliced_inputs=None):\\n if non_sliced_inputs is None:\\n non_sliced_inputs = []\\n if isinstance(non_sliced_inputs, tuple):\\n non_sliced_inputs = list(non_sliced_inputs)\\n n_paths = len(sliced_inputs[0])\\n slice_size = max(1, n_paths // n_slices)\\n ret_vals = None\\n for start in range(0, n_paths, slice_size):\\n inputs_slice = [v[start:start + slice_size] for v in sliced_inputs]\\n slice_ret_vals = f(*(inputs_slice + non_sliced_inputs))\\n if not isinstance(slice_ret_vals, (tuple, list)):\\n slice_ret_vals_as_list = [slice_ret_vals]\\n else:\\n slice_ret_vals_as_list = slice_ret_vals\\n scaled_ret_vals = [\\n np.asarray(v) * len(inputs_slice[0])\\n for v in slice_ret_vals_as_list\\n ]\\n if ret_vals is None:\\n ret_vals = scaled_ret_vals\\n else:\\n ret_vals = [x + y for x, y in zip(ret_vals, scaled_ret_vals)]\\n ret_vals = [v / n_paths for v in ret_vals]\\n if not isinstance(slice_ret_vals, (tuple, list)):\\n ret_vals = ret_vals[0]\\n elif isinstance(slice_ret_vals, tuple):\\n ret_vals = tuple(ret_vals)\\n return ret_vals\\n\\n return sliced_f\",\n \"def _ureduce(a, func, **kwargs):\\n a = np.asanyarray(a)\\n axis = kwargs.get('axis', None)\\n if axis is not None:\\n keepdim = list(a.shape)\\n nd = a.ndim\\n axis = _nx.normalize_axis_tuple(axis, nd)\\n\\n for ax in axis:\\n keepdim[ax] = 1\\n\\n if len(axis) == 1:\\n kwargs['axis'] = axis[0]\\n else:\\n keep = set(range(nd)) - set(axis)\\n nkeep = len(keep)\\n # swap axis that should not be reduced to front\\n for i, s in enumerate(sorted(keep)):\\n a = a.swapaxes(i, s)\\n # merge reduced axis\\n a = a.reshape(a.shape[:nkeep] + (-1,))\\n kwargs['axis'] = -1\\n keepdim = tuple(keepdim)\\n else:\\n keepdim = (1,) * a.ndim\\n\\n r = func(a, **kwargs)\\n return r, keepdim\",\n \"def with_numpy(func):\\r\\n return func\",\n \"def apply_only(self, function, worker, *args, **kwargs):\\n pass\",\n \"def require_context(fn):\\n @functools.wraps(fn)\\n def _require_cuda_context(*args, **kws):\\n with _runtime.ensure_context():\\n return fn(*args, **kws)\\n\\n return _require_cuda_context\",\n \"def f_noarg(self) :\\n pass\",\n \"def requires_numpy(f):\\n @wraps(f)\\n def wrapper(*args, **kwargs):\\n if _NUMPY_AVAILABLE:\\n return f(*args, **kwargs)\\n else:\\n raise Warning(\\\"Numpy not available. Cannot call %s\\\" % f.__name__)\\n return f(*args, **kwargs)\\n return wrapper\",\n \"def hypercube_bounded(index, null_value=0, shape=lambda xs: xs.shape[0],\\n self_has_ndim=False):\\n def get_bounded(fn):\\n def fn_bounded(*args, **kwargs):\\n xs = args[index]\\n xs = interpret_array(xs, args[0].ndim if self_has_ndim else None)\\n\\n in_bounds = np.all((0 < xs) * (xs < 1), axis=1)\\n\\n res = np.empty(xs.shape[0])\\n res[in_bounds] = fn(*args[:index], xs[in_bounds],\\n *args[index+1:], **kwargs)\\n res[np.logical_not(in_bounds)] = null_value\\n\\n return res\\n\\n return fn_bounded\\n return get_bounded\",\n \"def _get_required_args(func):\\n module_logger.debug(f\\\"_get_required_args: func={func}\\\")\\n fas = inspect.getfullargspec(func)\\n module_logger.debug(f\\\"_get_required_args: fas={fas}\\\")\\n len_args = len(fas.args)\\n len_args += len(fas.kwonlyargs)\\n if fas.kwonlydefaults is not None:\\n len_args -= len(fas.kwonlydefaults)\\n if fas.defaults is not None:\\n len_args -= len(fas.defaults)\\n return len_args\",\n \"def exceptNull(func): # -> (*args: Unknown, **kwargs: Unknown) -> Unknown:\\n ...\",\n \"def multichannel(fcn):\\n return lambda args: (fcn(*args), )\",\n \"def variadic_args(self, /, *args, **kwargs):\\n return self._func(args, **kwargs)\",\n \"def test_empty(self):\\n a = np.ones((3, 4, 5))\\n ai = np.ones((3, 0, 5), dtype=np.intp)\\n\\n actual = take_along_axis(a, ai, axis=1)\\n assert_equal(actual.shape, ai.shape)\",\n \"def required_input_dim(space: gym.Space, **kwargs) -> int:\",\n \"def dimWhen(*args, clear: bool=True, false: bool=True, true: bool=True, **kwargs)->None:\\n pass\",\n \"def my_func(self, a, b, c, d=None):\\n return True\",\n \"def wrapper(*args, **kwargs):\\n return fn(*args, **kwargs)\",\n \"def rank_zero_only(fn):\\n\\n @wraps(fn)\\n def wrapped_fn(self, *args, **kwargs):\\n if self.rank == 0:\\n fn(self, *args, **kwargs)\\n\\n return wrapped_fn\",\n \"def test_check_X_too_many_dims():\\n with pytest.raises(ValueError):\\n check_X(np.ones((5,4,3)))\",\n \"def container_scatter_kwargs(inputs, kwargs, target_gpus, dim=0):\\n inputs = container_scatter(inputs, target_gpus, dim) if inputs else []\\n kwargs = container_scatter(kwargs, target_gpus, dim) if kwargs else []\\n\\n if len(inputs) < len(kwargs):\\n inputs.extend([() for _ in range(len(kwargs) - len(inputs))])\\n elif len(kwargs) < len(inputs):\\n kwargs.extend([{} for _ in range(len(inputs) - len(kwargs))])\\n\\n # patch for cases where #inputs < len(target_gpus) and len(kwargs) > 0\\n PATCH = 1\\n if PATCH:\\n is_empty = [len(p) == 0 for p in inputs]\\n num_empty = sum(is_empty)\\n num_full = len(inputs) - num_empty\\n if num_full > 0 and num_empty > 0:\\n kwargs = kwargs[0:num_full]\\n inputs = inputs[0:num_full]\\n\\n inputs = tuple(inputs)\\n kwargs = tuple(kwargs)\\n return inputs, kwargs\",\n \"def zeros(*args):\\n dims = list(args)\\n assert type(dims[0]) == int\\n return params_func(cmd, \\\"zeros\\\", params=dims, return_type='FloatTensor')\",\n \"def optional_parameter_decorator(f):\\n @functools.wraps(f)\\n def wrapped_decorator(*args, **kwargs):\\n if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):\\n # Return the actual decorated function.\\n return f(args[0])\\n else:\\n # Wrap the function in a decorator in the case that arguments are\\n # applied.\\n return lambda realf: f(realf, *args, **kwargs)\\n return wrapped_decorator\",\n \"def _memoizeArgsOnly (max_cache_size=1000):\\n def wrapper (f):\\n def fn (*args):\\n try:\\n return fn.cache[args]\\n except KeyError:\\n if fn.count >= max_cache_size:\\n fn.cache = {}\\n fn.count = 0\\n fn.cache[args] = result = f(*args)\\n fn.count += 1\\n return result\\n fn.cache = {}\\n fn.count = 0\\n return fn\\n return wrapper\",\n \"def getArgs(func):\\n # exclude the defaults at the end (hence the [:-1])\\n args = list(utils.flatten(inspect.getargspec(func)[:-1]))\\n return set(args).difference(set([None]))\",\n \"def test_default_args(self):\\n cfunc = njit(g)\\n self.assertEqual(cfunc(1, 2, 3), g(1, 2, 3))\\n self.assertEqual(cfunc(1, y=2, z=3), g(1, 2, 3))\",\n \"def wrap(func, *args, unsqueeze=False):\\n\\n # Convert input types where applicable\\n args = list(args)\\n for i, arg in enumerate(args):\\n if type(arg) == np.ndarray:\\n args[i] = torch.from_numpy(arg)\\n if unsqueeze:\\n args[i] = args[i].unsqueeze(0)\\n\\n result = func(*args)\\n\\n # Convert output types where applicable\\n if isinstance(result, tuple):\\n result = list(result)\\n for i, res in enumerate(result):\\n if type(res) == torch.Tensor:\\n if unsqueeze:\\n res = res.squeeze(0)\\n result[i] = res.numpy()\\n return tuple(result)\\n elif type(result) == torch.Tensor:\\n if unsqueeze:\\n result = result.squeeze(0)\\n return result.numpy()\\n else:\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60580367","0.5733432","0.5674461","0.5585218","0.55187184","0.537419","0.5331399","0.5270151","0.5239943","0.52073294","0.50932014","0.5054553","0.50446254","0.50378776","0.5035789","0.50340813","0.4959851","0.49438873","0.4940812","0.49344712","0.492547","0.49241844","0.48875204","0.4879312","0.4879312","0.48457262","0.48438746","0.4836573","0.48300302","0.48245925","0.48229948","0.4814264","0.48123768","0.4809598","0.47958687","0.47925115","0.47906","0.47862235","0.47795364","0.4755301","0.4742999","0.47392553","0.47358847","0.47273543","0.4711926","0.4700353","0.46984136","0.46901962","0.46890736","0.46771088","0.46695152","0.46680322","0.46584544","0.46569657","0.46495217","0.46469936","0.46452323","0.4644686","0.46402687","0.4639849","0.4639631","0.4635097","0.4634581","0.46295828","0.4626007","0.46184298","0.4613585","0.46118182","0.46111155","0.4600789","0.45928583","0.45844266","0.4575824","0.45690787","0.4565775","0.4565631","0.4565352","0.45637387","0.45622453","0.45619097","0.45609882","0.45591313","0.45582592","0.45567495","0.4555028","0.45426553","0.45356083","0.4532341","0.45321313","0.45286295","0.45281142","0.45224494","0.45212376","0.45180517","0.45173708","0.45118663","0.45081332","0.45046157","0.45003292","0.44957507"],"string":"[\n \"0.60580367\",\n \"0.5733432\",\n \"0.5674461\",\n \"0.5585218\",\n \"0.55187184\",\n \"0.537419\",\n \"0.5331399\",\n \"0.5270151\",\n \"0.5239943\",\n \"0.52073294\",\n \"0.50932014\",\n \"0.5054553\",\n \"0.50446254\",\n \"0.50378776\",\n \"0.5035789\",\n \"0.50340813\",\n \"0.4959851\",\n \"0.49438873\",\n \"0.4940812\",\n \"0.49344712\",\n \"0.492547\",\n \"0.49241844\",\n \"0.48875204\",\n \"0.4879312\",\n \"0.4879312\",\n \"0.48457262\",\n \"0.48438746\",\n \"0.4836573\",\n \"0.48300302\",\n \"0.48245925\",\n \"0.48229948\",\n \"0.4814264\",\n \"0.48123768\",\n \"0.4809598\",\n \"0.47958687\",\n \"0.47925115\",\n \"0.47906\",\n \"0.47862235\",\n \"0.47795364\",\n \"0.4755301\",\n \"0.4742999\",\n \"0.47392553\",\n \"0.47358847\",\n \"0.47273543\",\n \"0.4711926\",\n \"0.4700353\",\n \"0.46984136\",\n \"0.46901962\",\n \"0.46890736\",\n \"0.46771088\",\n \"0.46695152\",\n \"0.46680322\",\n \"0.46584544\",\n \"0.46569657\",\n \"0.46495217\",\n \"0.46469936\",\n \"0.46452323\",\n \"0.4644686\",\n \"0.46402687\",\n \"0.4639849\",\n \"0.4639631\",\n \"0.4635097\",\n \"0.4634581\",\n \"0.46295828\",\n \"0.4626007\",\n \"0.46184298\",\n \"0.4613585\",\n \"0.46118182\",\n \"0.46111155\",\n \"0.4600789\",\n \"0.45928583\",\n \"0.45844266\",\n \"0.4575824\",\n \"0.45690787\",\n \"0.4565775\",\n \"0.4565631\",\n \"0.4565352\",\n \"0.45637387\",\n \"0.45622453\",\n \"0.45619097\",\n \"0.45609882\",\n \"0.45591313\",\n \"0.45582592\",\n \"0.45567495\",\n \"0.4555028\",\n \"0.45426553\",\n \"0.45356083\",\n \"0.4532341\",\n \"0.45321313\",\n \"0.45286295\",\n \"0.45281142\",\n \"0.45224494\",\n \"0.45212376\",\n \"0.45180517\",\n \"0.45173708\",\n \"0.45118663\",\n \"0.45081332\",\n \"0.45046157\",\n \"0.45003292\",\n \"0.44957507\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.50251055"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":90594,"cells":{"query":{"kind":"string","value":"Lift a function to one that vectorizes across arbitraryrank inputs."},"document":{"kind":"string","value":"def make_rank_polymorphic(fn, core_ndims, name=None):\n\n def vectorized_fn(*args):\n \"\"\"Vectorized version of `fn` that accepts arguments of any rank.\"\"\"\n with tf.name_scope(name or 'make_rank_polymorphic'):\n # If we got a single value for core_ndims, tile it across all args.\n core_ndims_structure = (\n core_ndims\n if tf.nest.is_nested(core_ndims)\n else tf.nest.map_structure(lambda _: core_ndims, args))\n\n # Build flat lists of all argument parts and their corresponding core\n # ndims.\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\n flat_args = nest.flatten_up_to(\n core_ndims_structure, args, check_types=False)\n\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\n # values for `core_ndims`). Other args will be passed through to `fn`\n # unmodified.\n (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\n fn,\n arg_structure=core_ndims_structure,\n flat_core_ndims=flat_core_ndims,\n flat_args=flat_args)\n\n # `vectorized_map` requires all inputs to have a single, common batch\n # dimension `[n]`. So we broadcast all input parts to a common\n # batch shape, then flatten it down to a single dimension.\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\n\n vectorized_arg_actual_core_ndims = []\n batch_shapes, core_shapes = [], []\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\n vectorized_arg_core_ndims):\n arg_nd = ps.rank_from_shape(arg_shape)\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\n # `batch_ndims` is always nonnegative.\n actual_core_nd = ps.minimum(arg_nd, core_nd)\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\n\n batch_ndims = arg_nd - actual_core_nd\n batch_ndims_ = tf.get_static_value(batch_ndims)\n if batch_ndims_ is not None:\n batch_shapes.append(arg_shape[:batch_ndims_])\n core_shapes.append(arg_shape[batch_ndims_:])\n else:\n arg_shape = tf.convert_to_tensor(arg_shape)\n batch_shapes.append(arg_shape[:batch_ndims])\n core_shapes.append(arg_shape[batch_ndims:])\n\n # Flatten all of the batch dimensions into one.\n broadcast_batch_shape = (\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\n\n static_n = tf.get_static_value(n)\n if static_n == 1:\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\n result_batch_dims = 0\n batched_result = fn_of_vectorized_args(\n tf.nest.map_structure(\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\n vectorized_args,\n vectorized_arg_actual_core_ndims,\n check_types=False))\n else:\n # Pad all input parts to the common shape, then flatten\n # into the single leading dimension `[n]`.\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\n # when batch rank is static so that we can exploit broadcasting.\n broadcast_vectorized_args = [\n tf.broadcast_to(part, ps.concat(\n [broadcast_batch_shape, core_shape], axis=0))\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\n vectorized_args_with_flattened_batch_dim = [\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\n for (part, core_shape) in zip(\n broadcast_vectorized_args, core_shapes)]\n result_batch_dims = 1\n batched_result = tf.vectorized_map(\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\n\n # Unflatten any `Tensor`s in the result.\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\n result = tf.nest.map_structure(\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\n expand_composites=True)\n return result\n\n return vectorized_fn"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper","def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper","def vectorized_fn(*args):\n with tf.name_scope(name or 'make_rank_polymorphic'):\n # If we got a single value for core_ndims, tile it across all args.\n core_ndims_structure = (\n core_ndims\n if tf.nest.is_nested(core_ndims)\n else tf.nest.map_structure(lambda _: core_ndims, args))\n\n # Build flat lists of all argument parts and their corresponding core\n # ndims.\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\n flat_args = nest.flatten_up_to(\n core_ndims_structure, args, check_types=False)\n\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\n # values for `core_ndims`). Other args will be passed through to `fn`\n # unmodified.\n (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\n fn,\n arg_structure=core_ndims_structure,\n flat_core_ndims=flat_core_ndims,\n flat_args=flat_args)\n\n # `vectorized_map` requires all inputs to have a single, common batch\n # dimension `[n]`. So we broadcast all input parts to a common\n # batch shape, then flatten it down to a single dimension.\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\n\n vectorized_arg_actual_core_ndims = []\n batch_shapes, core_shapes = [], []\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\n vectorized_arg_core_ndims):\n arg_nd = ps.rank_from_shape(arg_shape)\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\n # `batch_ndims` is always nonnegative.\n actual_core_nd = ps.minimum(arg_nd, core_nd)\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\n\n batch_ndims = arg_nd - actual_core_nd\n batch_ndims_ = tf.get_static_value(batch_ndims)\n if batch_ndims_ is not None:\n batch_shapes.append(arg_shape[:batch_ndims_])\n core_shapes.append(arg_shape[batch_ndims_:])\n else:\n arg_shape = tf.convert_to_tensor(arg_shape)\n batch_shapes.append(arg_shape[:batch_ndims])\n core_shapes.append(arg_shape[batch_ndims:])\n\n # Flatten all of the batch dimensions into one.\n broadcast_batch_shape = (\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\n\n static_n = tf.get_static_value(n)\n if static_n == 1:\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\n result_batch_dims = 0\n batched_result = fn_of_vectorized_args(\n tf.nest.map_structure(\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\n vectorized_args,\n vectorized_arg_actual_core_ndims,\n check_types=False))\n else:\n # Pad all input parts to the common shape, then flatten\n # into the single leading dimension `[n]`.\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\n # when batch rank is static so that we can exploit broadcasting.\n broadcast_vectorized_args = [\n tf.broadcast_to(part, ps.concat(\n [broadcast_batch_shape, core_shape], axis=0))\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\n vectorized_args_with_flattened_batch_dim = [\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\n for (part, core_shape) in zip(\n broadcast_vectorized_args, core_shapes)]\n result_batch_dims = 1\n batched_result = tf.vectorized_map(\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\n\n # Unflatten any `Tensor`s in the result.\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\n result = tf.nest.map_structure(\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\n expand_composites=True)\n return result","def vectorize_inputs(f):\n return lambda args: f(*np.hsplit(args, args.shape[1]))","def mlift(func):\n return compose(unit, func)","def vecToFunc(vector):\n def f(x):\n f = 0\n for i in range(len(vector)):\n f += vector[i]*x**i\n return f\n return f","def vectorize_method(func):\n @wraps(func)\n def inner(obj, *iargs, **ikwargs):\n\n def functionalized_method(*args, **kwargs):\n return func(obj, *args, **kwargs)\n\n return np.vectorize(functionalized_method, otypes=[np.dtype('c16')])(*iargs, **ikwargs)\n #return np.vectorize(functionalized_method)(*iargs, **ikwargs)\n return inner","def apply(self: T, target: types.Vector) -> types.Vector:","def vectorize(self, *args, **kwargs):\n kwargs['add_start'] = False\n kwargs['add_end'] = False\n return TorchRankerAgent.vectorize(self, *args, **kwargs)","def vectorize(func, processes=1, on_complete=None):\n if processes > 1:\n return __multiprocess_wrapper(func, processes, on_complete)\n else:\n return single_process_wrapper(func, on_complete)","def vectorize(self):\n return vectorize(self)","def vectorize(sch, tensor, vectorize_limit):\n inner_axis = s[tensor].op.axis[len(s[tensor].op.axis) - 1]\n inner_length = tensor.shape[len(tensor.shape) - 1].value\n if inner_length <= vectorize_limit:\n sch[tensor].vectorize(inner_axis)\n else:\n split_factor = 1\n for i in range(vectorize_limit, 1, -1):\n if inner_length % i == 0:\n split_factor = i\n break\n if split_factor > 1:\n _, inner_i = sch[tensor].split(inner_axis, split_factor)\n sch[tensor].vectorize(inner_i)","def transform(fn):\n def _(vec, dt):\n return np.einsum(\n 'ji,i,ki,k...->j...',\n evecs, fn(evals, dt), evecs, vec, optimize=True)\n\n return _","def vectorize_unpack(args):\n return vectorize(*args)","def vectorize_unpack(args):\n return vectorize(*args)","def csr_mulvec_wrap(fn):\n\n @functools.wraps(fn)\n def csr_mul_vector(A, x):\n if A.nnz > 50000 and _NUM_THREAD_WORKERS > 1:\n return par_dot_csr_matvec(A, x)\n else:\n y = fn(A, x)\n if isinstance(x, qarray):\n y = qarray(y)\n return y\n\n return csr_mul_vector","def sp_mulvec_wrap(fn):\n\n @functools.wraps(fn)\n def qarrayed_fn(self, other):\n out = fn(self, other)\n if isinstance(other, qarray):\n out = qarray(out)\n return out\n\n return qarrayed_fn","def liftn(cls, func):\n raise NotImplementedError","def apply_scalar(vector, scalar):\n new_coordinates = []\n index = 0\n while index < vector.dimension:\n new_value = vector.coordinates[index] * scalar\n new_coordinates.append(new_value)\n index += 1\n new_vector = Vector(new_coordinates)\n return new_vector","def lift(f: Callable[..., Data]) -> LiftedFunc:\n def inner(*args: Result) -> Result:\n out = []\n for args1 in itertools.product(*args):\n val = f(*args1)\n out.append(val)\n return out\n return inner","def lift(cls, func):\n raise NotImplementedError","def weyl_vector(rank):\n return np.ones(rank, dtype=utils.itype)","def custom_np_function(vector):\n summation = 0\n for item in vector:\n summation += item ** 2\n return summation","def apply(self, vec):\n raise NotImplementedError","def wrap(fun):\n class tmp:\n def __init__(self, *args, **kwargs):\n self.args = args\n self.kwargs = kwargs\n def __call__(self, x):\n args, kwargs = list(self.args), self.kwargs\n args.insert(i, x)\n return fun(*args, **kwargs)\n def __rmatmul__(self, others):\n return [self.__call__(x) for x in others]\n def __rfloordiv__(self, x):\n return self.__call__(x)\n return tmp","def rank_zero_only(fn):\n\n def wrapped(*args, **kwargs):\n if rank() == 0:\n return fn(*args, **kwargs)\n\n return wrapped","def _scalar_vectorized(scalar, M):\n return scalar[:, np.newaxis, np.newaxis]*M","def fn(x):\n if x.ndim == 1:\n return np.sum(x**2)\n else:\n return np.sum(x**2, axis=1)","def lambda_fun(funk, x):\n # input must be 1d numpy.ndarray\n assert isinstance(x, np.ndarray) and x.ndim == 1\n\n # result from the lambdified function with array input\n abo = funk(x)\n\n if isinstance(abo, float):\n abo = np.array([[abo]])\n\n if abo.ndim < 3:\n # reshaping from (n,1) to (n,)\n abo = abo.reshape(abo.shape[0])\n\n # fix the term not properly broadcasted in the lambdified funtion\n abo_fix = np.array(np.broadcast_arrays(x, *abo)[1:])\n\n elif abo.ndim == 3:\n abo_fix = abo.reshape(abo.shape[0], -1)\n\n # roll the axis to obtain an array of matrix, and not a matrix of arrays\n abo_fix = np.moveaxis(abo_fix, -1, 0)\n\n return abo_fix","def func(self, name, vecs):\n arity = len(vecs)\n funcobj = self.get_ground_vector('!Func:{}:{}'.format(arity, name))\n\n argobjs = [\n associate(\n self.get_ground_vector('!Arg:{}:{}:{}'.format(arity, name, i)),\n vec)\n for i, vec in enumerate(vecs) ]\n\n result = normalize(\n self.func_weights @\n torch.cat([\n funcobj,\n merge(argobjs),\n merge(vecs),\n ]).reshape(-1, self.hrr_size))\n\n return result","def rank_transform(X):\n return np.apply_along_axis(scipy.stats.rankdata, 0, X)","def function(fnc, *args, **kwargs):\n return Function(fnc, args=args, kwargs=kwargs).tunable()","def lambdify_fun(funk, x):\n\n abo = funk(x)\n\n if isinstance(abo, float):\n abo *= np.ones(x.shape)\n\n return abo","def make_pbroadcast_function(fn, in_axes, out_axes, out_dtype):\n\n if not isinstance(in_axes, tuple):\n in_axes = (in_axes,)\n\n def pbroadcast_fn(*args):\n nest.assert_shallow_structure(args, in_axes)\n nest.assert_shallow_structure(out_dtype, out_axes)\n map_in_axes = nest.map_structure_up_to(args, canonicalize_axis_name,\n in_axes)\n map_out_axes = nest.map_structure_up_to(out_dtype, canonicalize_axis_name,\n out_axes)\n\n def _pbroadcast_input(out_axes, x, in_axes):\n psum_axes = [\n axis_name for axis_name in out_axes if axis_name not in in_axes\n ]\n return pbroadcast(x, psum_axes)\n\n def _flat_fn_index(i, *args):\n out = fn(*args)\n return tf.nest.flatten(out)[i]\n\n def _flat_fn(*args):\n outputs = []\n for i, out_axis in enumerate(nest.flatten_up_to(out_dtype, map_out_axes)):\n local_args = nest.map_structure_up_to(\n args, functools.partial(_pbroadcast_input, out_axis), args,\n map_in_axes)\n outputs.append(_flat_fn_index(i, *local_args))\n return tf.nest.pack_sequence_as(out_dtype, outputs)\n\n return _flat_fn(*args)\n\n return pbroadcast_fn","def apply(self, vec):\n return self._disp_over_m * vec - self._gp * ( # pylint: disable = E1130\n self._gp @ vec / self.L ** self.ndim\n )","def vectorMultiply(v, f):\n return [x * f for x in v]","def Generate_Custom(f, n, m):\n return np.fromfunction(np.vectorize(f, otypes=[float]), (n,m))","def apply_function_vector(function_vector, x_vector):\n function_index = 0\n element_index = 1\n \n def d():\n for e in zip(function_vector, x_vector):\n print(e[1])\n d()\n \n return list(map(lambda fx_set: fx_set[function_index](fx_set[element_index]), zip(function_vector, x_vector)))","def apply(self,v):\n return np.tensordot(self._transform, v, axes=([1],[0])) \\\n + self._translation","def _rankf(x):\n shift = int32(31)\n mask = int32((1 << 31) - 1)\n i32 = x.view(int32)\n value = i32 >> shift\n value &= mask\n value ^= i32\n return value","def n_ary(func):\n def wrapper(x, *args):\n return x if not args else func(x, wrapper(*args))\n return wrapper","def transform(self, *args, **kwargs):\n r = Vector2(np.dot(args[0], self))\n if kwargs.get(\"norm\", False):\n r = r.normalized()\n return type(self)(r)","def func(self, name, vecs):\n arity = len(vecs)\n funcobj = self.get_ground_vector('!Func:{}:{}'.format(arity, name))\n\n argobjs = [\n associate_comp(\n self.get_ground_vector('!Arg:{}:{}:{}'.format(arity, name, i)),\n vec)\n for i, vec in enumerate(vecs) ]\n\n result = normalize_comp(\n self.func_weights @\n torch.cat([\n funcobj,\n merge(argobjs),\n merge(vecs),\n ]).reshape(-1, 2 * self.hrr_size)).reshape(2, self.hrr_size)\n\n return result","def func(self, name, vecs):\n arity = len(vecs)\n funcobj = self.get_ground_vector('!Func:{}:{}'.format(arity, name))\n\n argobjs = [\n associate_comp(\n self.get_ground_vector('!Arg:{}:{}:{}'.format(arity, name, i)),\n vec)\n for i, vec in enumerate(vecs) ]\n\n result = normalize_comp(\n self.func_weights @\n torch.cat([\n funcobj,\n merge(argobjs),\n merge(vecs),\n ]).reshape(-1, 2 * self.hrr_size)).reshape(2, self.hrr_size)\n\n return result","def _lock_in_non_vectorized_args(fn, arg_structure, flat_core_ndims, flat_args):\n\n # Extract the indices and values of args where core_ndims is not `None`.\n (vectorized_arg_indices,\n vectorized_arg_core_ndims,\n vectorized_args) = [], [], []\n if any(nd is not None for nd in flat_core_ndims):\n vectorized_arg_indices, vectorized_arg_core_ndims, vectorized_args = zip(*[\n (i, nd, tf.convert_to_tensor(t))\n for i, (nd, t) in enumerate(zip(flat_core_ndims, flat_args))\n if nd is not None])\n\n vectorized_arg_index_set = set(vectorized_arg_indices)\n\n def fn_of_vectorized_args(vectorized_args):\n with tf.name_scope('fn_of_vectorized_args'):\n vectorized_args_by_index = dict(\n zip(vectorized_arg_indices, vectorized_args))\n # Substitute the vectorized args into the original argument\n # structure.\n new_args_with_original_structure = tf.nest.pack_sequence_as(\n arg_structure, [vectorized_args_by_index[i]\n if i in vectorized_arg_index_set\n else v for (i, v) in enumerate(flat_args)])\n return tf.nest.map_structure(\n # If `fn` returns any Distribution instances, ensure that their\n # parameter batch shapes are padded to align after vectorization.\n _maybe_rectify_parameter_shapes,\n fn(*new_args_with_original_structure))\n\n return (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args)","def local_subtensor_lift(node):\r\n if isinstance(node.op, Subtensor):\r\n u = node.inputs[0]\r\n if not u.owner or len(u.clients) > 1:\r\n return False\r\n\r\n if isinstance(u.owner.op, T.Elemwise) and len(u.owner.inputs) == 1:\r\n idx = node.inputs[1:]\r\n x_idx = node.op(u.owner.inputs[0], *idx)\r\n return [u.owner.op(x_idx)]\r\n\r\n if isinstance(u.owner.op, T.Elemwise):\r\n new_inputs = []\r\n if all([sum(i.type.broadcastable) == 0 for i in u.owner.inputs]):\r\n # There is no broadcastable in the inputs\r\n idx = node.inputs[1:]\r\n new_inputs = [node.op(i, *idx) for i in u.owner.inputs]\r\n return [u.owner.op(*new_inputs)]\r\n elif all([sum(i.type.broadcastable) in [i.ndim, 0]\r\n for i in u.owner.inputs]):\r\n # There is no broadcastable in the inputs or it is scalar\r\n idx = node.inputs[1:]\r\n new_inputs = []\r\n for i in u.owner.inputs:\r\n if sum(i.type.broadcastable) == 0:\r\n new_inputs.append(node.op(i, *idx))\r\n else:\r\n # If the subtensor remove some dims, we must\r\n # lower the number of dimensions of this scalar.\r\n if node.outputs[0].ndim == i.ndim:\r\n new_inputs.append(i)\r\n else:\r\n new_inputs.append(\r\n i.dimshuffle(['x'] * node.outputs[0].ndim))\r\n return [u.owner.op(*new_inputs)]\r\n\r\n if isinstance(u.owner.op, T.Rebroadcast):\r\n # make sure that Rebroadcast has only 1 input\r\n assert len(u.owner.inputs) == 1\r\n\r\n # Subtensor might reduce dim., adapt broadcast pattern accordingly\r\n new_axis = []\r\n\r\n # loop through indices being subtensor-ed\r\n # i indexes broadcastable pattern before subtensor\r\n # j indexes broadcastable pattern after subtensor\r\n j = 0\r\n for (i, x) in enumerate(node.op.idx_list):\r\n # if its not a slice, it will reduce the dimension, should\r\n # not appear in the broascastable dimensions\r\n if isinstance(x, slice):\r\n new_axis += [(j, u.broadcastable[i])]\r\n j += 1\r\n # now keep the broadcastable pattern of all\r\n # items not appearing in subtensor list\r\n for i in xrange(len(node.op.idx_list), len(u.broadcastable)):\r\n new_axis += [(j, u.broadcastable[i])]\r\n j += 1\r\n\r\n subt_x = node.op(u.owner.inputs[0], *node.inputs[1:])\r\n rbcast_subt_x = T.Rebroadcast(*new_axis)(subt_x)\r\n\r\n return [rbcast_subt_x]","def basis_fns(n=0):\n return lambda x: np.sum(x ** (n+1), axis=1)","def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\n axis = check_axes(axis)\n if len(axis) == x.ndim:\n return func(x)\n\n other_axes = negate_indices(axis, x.ndim)\n begin = np.arange(len(other_axes))\n\n y = np.moveaxis(x, other_axes, begin)\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)","def n_ary(f):\n def n_ary_fn(x, *args):\n return x if not args else f(x, n_ary_fn(*args))\n return n_ary_fn","def _scal_elemwise_with_nfunc(nfunc, nin, nout):\r\n def construct(symbol):\r\n symbolname = symbol.__name__\r\n inplace = symbolname.endswith('_inplace')\r\n if inplace:\r\n msg = \"inplace\"\r\n else:\r\n msg = \"no_inplace\"\r\n\r\n n = \"Elemwise{%s,%s}\" % (symbolname, msg)\r\n\r\n if inplace:\r\n scalar_op = getattr(scal, symbolname[:-len('_inplace')])\r\n inplace_scalar_op = scalar_op.__class__(scal.transfer_type(0))\r\n rval = elemwise.Elemwise(inplace_scalar_op, {0: 0}, name=n,\r\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\r\n else:\r\n scalar_op = getattr(scal, symbolname)\r\n rval = elemwise.Elemwise(scalar_op, name=n,\r\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\r\n\r\n if getattr(symbol, '__doc__', False):\r\n rval.__doc__ = symbol.__doc__ + '\\n' + rval.__doc__\r\n\r\n # for the meaning of this see the ./epydoc script\r\n # it makes epydoc display rval as if it were a function, not an object\r\n rval.__epydoc_asRoutine = symbol\r\n rval.__module__ = 'tensor'\r\n\r\n pprint.assign(rval, printing.FunctionPrinter(symbolname))\r\n\r\n return rval\r\n return construct","def position_op(x, wfunc):\n return x*wfunc","def transform(self, F, **kwargs):\n r = Vector3(np.dot(F, self))\n if kwargs.get(\"norm\", False):\n r = r.normalized()\n return type(self)(r)","def apply_along_1_nb(a, apply_func_nb, *args):\n out = np.empty_like(a, dtype=np.float_)\n for i in range(a.shape[0]):\n out[i, :] = apply_func_nb(i, a[i, :], *args)\n return out","def reconstruction(B, N):\n\n def _(f):\n return lambda *x: sum(f[i] * B(i)(*x) for i in range(N))\n\n return _","def _fn(dtype, shape, name, trainable, add_variable_fn):\n loc, scale = loc_scale_fn_(dtype, shape, name, trainable, add_variable_fn)\n if scale is None:\n dist = deterministic_lib.Deterministic(loc=loc)\n else:\n dist = normal_lib.Normal(loc=loc, scale=scale)\n reinterpreted_batch_ndims = array_ops.shape(dist.batch_shape_tensor())[0]\n return independent_lib.Independent(\n dist, reinterpreted_batch_ndims=reinterpreted_batch_ndims)","def vectorize(features, vocab):\n vec = lil_matrix((1, len(vocab)))\n for feat in features:\n try:\n fidx = vocab[feat]\n vec[0, fidx] += 1.0\n except KeyError:\n pass\n return vec","def vectorized_rounder():\n\n def f(num):\n if np.isnan(num):\n return np.nan\n else:\n return num // 10 ** (int(math.log(num, 10)))\n\n vf = np.vectorize(f)\n\n return(vf)","def unary_wrap(run):\n\n def run_unary(transitions, input, steps):\n return run(transitions, '1' * input, steps)\n\n return run_unary","def feed(self, vector):\n return vector","def multiply_fisher(self, vector: jnp.ndarray) -> jnp.ndarray:\n return utils.scalar_mul(\n self.multiply_fisher_unweighted(vector), self.weight)","def _compute_R1_from_vector(n, ind_mat, vec):\r\n\r\n R1 = 0\r\n for l in range(n):\r\n R1 += np.sum((2*ind_mat[:, l]+1) * vec**2)\r\n\r\n return R1","def apply(cls, func):\n raise NotImplementedError","def lift(func: Callable) -> Callable:\n return lambda f: compose2(func, f)","def vectorOperator(method):\n\top = method.__name__\n\tsetattr(VectorDistribution, op, makeVectorOperatorHandler(op))\n\n\t@functools.wraps(method)\n\tdef handler2(self, *args):\n\t\tif needsSampling(self):\n\t\t\treturn VectorOperatorDistribution(op, self, args)\n\t\telif any(needsSampling(arg) for arg in args):\n\t\t\treturn VectorMethodDistribution(method, self, args, {})\n\t\telif any(needsLazyEvaluation(arg) for arg in args):\n\t\t\t# see analogous comment in distributionFunction\n\t\t\treturn makeDelayedFunctionCall(handler2, args, {})\n\t\telse:\n\t\t\treturn method(self, *args)\n\treturn handler2","def rank_zero_only(fn):\n\n @wraps(fn)\n def wrapped_fn(self, *args, **kwargs):\n if self.rank == 0:\n fn(self, *args, **kwargs)\n\n return wrapped_fn","def applyToEach(L,f):\n for i in range(len(L)):\n L[i] = f(L[i])","def _np_apply_along_axis(func1d, axis: int, arr: np.ndarray) -> np.ndarray:\n\n assert arr.ndim == 2\n assert axis in [0, 1]\n\n if axis == 0:\n result = np.empty(arr.shape[1])\n for i in range(len(result)):\n result[i] = func1d(arr[:, i])\n return result\n\n result = np.empty(arr.shape[0])\n for i in range(len(result)):\n result[i] = func1d(arr[i, :])\n\n return result","def _chunk_vmapped_function(vmapped_fun, chunk_size, argnums=0):\n\n if chunk_size is None:\n return vmapped_fun\n\n if isinstance(argnums, int):\n argnums = (argnums,)\n\n def _fun(*args):\n\n n_elements = jax.tree_leaves(args[argnums[0]])[0].shape[0]\n n_chunks, n_rest = divmod(n_elements, chunk_size)\n\n if n_chunks == 0 or chunk_size >= n_elements:\n y = vmapped_fun(*args)\n else:\n # split inputs\n def _get_chunks(x):\n x_chunks = jax.tree_map(lambda x_: x_[: n_elements - n_rest, ...], x)\n x_chunks = _chunk(x_chunks, chunk_size)\n return x_chunks\n\n def _get_rest(x):\n x_rest = jax.tree_map(lambda x_: x_[n_elements - n_rest :, ...], x)\n return x_rest\n\n args_chunks = [\n _get_chunks(a) if i in argnums else a for i, a in enumerate(args)\n ]\n args_rest = [\n _get_rest(a) if i in argnums else a for i, a in enumerate(args)\n ]\n\n y_chunks = _unchunk(\n scanmap(vmapped_fun, scan_append, argnums)(*args_chunks)\n )\n\n if n_rest == 0:\n y = y_chunks\n else:\n y_rest = vmapped_fun(*args_rest)\n y = jax.tree_map(\n lambda y1, y2: jnp.concatenate((y1, y2)), y_chunks, y_rest\n )\n return y\n\n return _fun","def power_transform(X, method=..., *, standardize=..., copy=...):\n ...","def n_ary(f):\n def n_ary_f(x,*args):\n return x if not args else f(x,n_ary_f(*args))\n return n_ary_f","def apply_new_basis(new_base, vector_array):\n return np.dot(new_base, vector_array).T","def forward(self, x, mask):\n for layer in self.layers:\n x = layer(x, mask)\n return self.norm(x)","def test_broadcast(self):\n a = np.ones((3, 4, 1))\n ai = np.arange(10, dtype=np.intp).reshape((1, 2, 5)) % 4\n put_along_axis(a, ai, 20, axis=1)\n assert_equal(take_along_axis(a, ai, axis=1), 20)","def scale_vectors(vectors, f):\n return [scale_vector(vector, f) for vector in vectors]","def _newton_update(func):\n return lambda x: x - func[0](x) / func[1](x)","def call(self, x):\n return tf.tile(x, self._mult)","def __imul__(self, scalar):\n m, n = self.shape\n scalar = mpfr(scalar)\n for i in range(m):\n for j in range(n):\n self[i, j] *= scalar\n return self","def shift_f(f, tau):\n n, T = f.shape\n fn = zeros((n, T))\n fn[:, 0:(T - 1)] = roll(f[:, 0:(T - 1)], tau, axis=1)\n fn[:, T - 1] = fn[:, 0]\n\n return (fn)","def Avv_func(f):\n\n def Avv(x, v):\n def F(s):\n return f(x + v * s)\n\n return jacfwd(jacfwd(F))(0.0)\n\n return Avv","def array_map(fn, arrs, n):\n # we shouldn't need a special case for n == 0, but NumPy complains about indexing into a zero-dimensional\n # array a using a[(Ellipsis,)].\n if n == 0:\n return fn(*arrs)\n \n full_shape = tuple(np.array([a.shape[:n] for a in arrs]).max(0))\n result = None\n for full_idx in itertools.product(*map(range, full_shape)):\n inputs = [a[broadcast(full_idx, a.shape[:n]) + (Ellipsis,)] for a in arrs]\n curr = fn(*inputs)\n \n if result is None:\n if type(curr) == tuple:\n result = tuple(np.zeros(full_shape + np.asarray(c).shape) for c in curr)\n else:\n result = np.zeros(full_shape + np.asarray(curr).shape)\n\n if type(curr) == tuple:\n for i, c in enumerate(curr):\n result[i][full_idx + (Ellipsis,)] = c\n else:\n result[full_idx + (Ellipsis,)] = curr\n return result","def minimum_eigen_vector(x, num_steps, learning_rate, vector_prod_fn):\n x = tf.nn.l2_normalize(x)\n for _ in range(num_steps):\n x = eig_one_step(x, learning_rate, vector_prod_fn)\n return x","def __imul__(self, tensor):\n return self.mul_(tensor)","def __call__(self, x):\n return self._pre_scale * tf.matmul(x, self._weight) + self._bias","def get_random_bvfunction(width, num_inputs, num_outputs, num_assignments, seed,\n external_variable_prefix=None, operation_set_index=0, num_rounds=None,\n extra_operations=None):\n assert num_inputs + num_assignments >= num_outputs\n\n import random\n import functools\n from cascada.bitvector.operation import (\n BvAnd, BvOr, BvXor, BvShl, BvLshr, RotateLeft, RotateRight, BvAdd,\n BvSub, BvNeg, BvNot, Concat, BvIdentity, make_partial_operation\n )\n from cascada.bitvector.secondaryop import BvIf, BvMaj\n\n PRNG = random.Random()\n PRNG.seed(seed)\n\n # SimpleReverse contains Concat and Extract\n # implemented as a class to later use issubclass()\n class SimpleReverse(object):\n def __new__(cls, bv):\n return functools.reduce(Concat, [bv[i] for i in range(bv.width)])\n\n if operation_set_index == 0:\n list_ops = (\n BvNot, BvXor, BvAnd, BvOr,\n BvAdd, BvSub, BvNeg,\n BvIdentity,\n BvIf, BvMaj,\n RotateLeft, RotateRight,\n BvShl, BvLshr,\n SimpleReverse\n # Concat, Extract, Ite,\n # BvComp, BvUlt, BvUle, BvUgt, BvUge,\n # BvMul, BvUdiv, BvUrem,\n # PopCount, Reverse, PopCountSum2, PopCountSum3, PopCountDiff, LeadingZeros,\n )\n elif operation_set_index == 1:\n list_ops = (\n BvNot, BvXor, BvAnd, BvOr,\n BvAdd, BvSub, BvNeg,\n BvIdentity,\n BvIf, BvMaj,\n RotateLeft, RotateRight,\n make_partial_operation(BvShl, (None, core.Constant(PRNG.randint(1, width - 1), width))),\n make_partial_operation(BvLshr, (None, core.Constant(PRNG.randint(1, width - 1), width))),\n )\n elif operation_set_index == 2:\n list_ops = (\n BvNot, BvXor, BvAnd, BvOr,\n BvAdd, BvSub,\n BvIdentity,\n RotateLeft, RotateRight,\n BvShl, BvLshr,\n SimpleReverse\n )\n elif operation_set_index == 3:\n list_ops = (\n BvNot, BvXor, BvAnd, BvOr,\n BvAdd, BvSub, BvNeg,\n BvIdentity,\n BvIf, BvMaj,\n RotateLeft, RotateRight,\n BvShl, BvLshr,\n SimpleReverse\n )\n else:\n raise ValueError(\"operation_set_index must be 0, 1, 2, or 3\")\n\n extra_operations_vrepr = None\n if extra_operations is not None:\n list_ops += tuple(extra_operations)\n extra_operations_vrepr = f\"({','.join(op.__name__ for op in extra_operations)},)\"\n\n while True: # outer loop to check RandomBvFunction does not return Constant\n list_of_lambda_assignments = []\n\n class RandomBvFunction(BvFunction):\n input_widths = [width] * num_inputs\n output_widths = [width] * num_outputs\n \n @classmethod\n def vrepr(cls):\n evp = external_variable_prefix.__repr__()\n return f\"get_random_bvfunction({width}, {num_inputs}, {num_outputs}, \" \\\n f\"{num_assignments}, {seed}, {evp}, {operation_set_index}, {num_rounds}, \" \\\n f\"{extra_operations_vrepr})\"\n\n if external_variable_prefix is not None:\n RandomBvFunction.round_keys = []\n\n def get_random_var_index():\n if len(list_of_lambda_assignments) >= num_inputs + 2:\n min_index = num_inputs\n else:\n min_index = 0\n return PRNG.randint(min_index, len(list_of_lambda_assignments) + num_inputs - 1)\n\n def get_random_var_indices(num_indices, my_unique_indices):\n indices = []\n while True:\n new_index = get_random_var_index()\n if not my_unique_indices or new_index not in indices:\n indices.append(new_index)\n if len(indices) == num_indices:\n break\n return indices\n\n while True:\n _op = list_ops[PRNG.randint(0, len(list_ops) - 1)]\n\n if _op in [RotateLeft, RotateRight]: # only operations with scalar inputs\n class Op(object): # need a class to store the randomness\n op = _op\n my_index = get_random_var_index()\n offset = PRNG.randint(1, width - 1) # != 0\n # kwargs required for external vars (see below)\n def __new__(cls, args, **kwargs): return cls.op(args[cls.my_index], cls.offset)\n\n elif _op == SimpleReverse:\n class Op(object):\n op = _op\n my_index = get_random_var_index()\n def __new__(cls, args, **kwargs): return cls.op(args[cls.my_index])\n\n elif _op in [BvShl, BvLshr]: # ensure 2nd operand ct\n class Op(object):\n op = _op\n my_index = get_random_var_index()\n offset = core.Constant(PRNG.randint(1, width - 1), width)\n def __new__(cls, args, **kwargs): return cls.op(args[cls.my_index], cls.offset)\n\n else:\n assert issubclass(_op, operation.Operation)\n assert _op.arity[1] == 0\n\n if _op.arity[0] >= 2 and PRNG.randint(0, 3) == 0:\n # 1 in 4 to have a ct or external var (each 50%)\n if external_variable_prefix is None or PRNG.randint(0, 1) == 0:\n extra_arg = core.Constant(PRNG.randint(1, 2**width - 2), width) # != 0, allones\n\n class Op(object):\n op = _op\n indices = get_random_var_indices(_op.arity[0] - 1, False)\n ct = extra_arg\n def __new__(cls, args, **kwargs): return cls.op(*([args[i] for i in cls.indices] + [cls.ct]))\n else:\n evi = PRNG.randint(0, len(RandomBvFunction.round_keys))\n if evi == len(RandomBvFunction.round_keys):\n RandomBvFunction.round_keys.append(core.Variable(f\"{external_variable_prefix}{evi}\", width))\n\n class Op(object):\n op = _op\n indices = get_random_var_indices(_op.arity[0] - 1, False)\n ev_index = evi\n # kwargs[\"round_keys\"] instead of RandomBvFunction.round_keys\n # to provide round_keys from cls in running time (in an argument of Op(\n # (otherwise round_keys cannot be changed)\n def __new__(cls, args, **kwargs): return cls.op(*([args[i] for i in cls.indices] +\n [kwargs[\"round_keys\"][cls.ev_index]]))\n else:\n unique_indices = _op in [BvAnd, BvOr, BvXor, BvSub]\n if unique_indices and len(list_of_lambda_assignments) + num_inputs == 1:\n # avoid using duplicated inputs for these operations\n continue\n\n class Op(object):\n op = _op\n indices = get_random_var_indices(_op.arity[0], unique_indices)\n def __new__(cls, args, **kwargs): return cls.op(*[args[i] for i in cls.indices])\n\n if external_variable_prefix is not None and len(RandomBvFunction.round_keys) == 0:\n # ensure at least 1 external variable\n _op = BvXor\n evi = 0\n RandomBvFunction.round_keys.append(core.Variable(f\"{external_variable_prefix}{evi}\", width))\n\n class Op(object):\n op = _op\n indices = get_random_var_indices(_op.arity[0] - 1, False)\n ev_index = evi\n def __new__(cls, args, **kwargs): return cls.op(*([args[i] for i in cls.indices] +\n [kwargs[\"round_keys\"][cls.ev_index]]))\n\n ## debugging\n # print(f\"{len(list_of_lambda_assignments)+1}/{num_assignments} | op: {Op.op}\")\n # if hasattr(Op, \"my_index\"): print(\"\\tmy_index:\", Op.my_index)\n # if hasattr(Op, \"indices\"): print(\"\\tindices:\", Op.indices)\n # if hasattr(Op, \"ct\"): print(\"\\tct:\", Op.ct)\n # if hasattr(Op, \"offset\"): print(\"\\toffset:\", Op.offset)\n # if hasattr(Op, \"ev_index\"): print(\"\\tev_index:\", Op.ev_index)\n\n list_of_lambda_assignments.append(Op)\n if len(list_of_lambda_assignments) == num_assignments:\n break\n\n list_of_lambda_assignments = tuple(list_of_lambda_assignments)\n\n @classmethod\n def eval_method(cls, *args):\n assert isinstance(args, collections.abc.Sequence)\n all_vars = list(args)\n round_keys = getattr(cls, \"round_keys\", None)\n ## debugging\n # print(f\"eval_method({args}):\")\n for index_assign, lambda_assign in enumerate(list_of_lambda_assignments):\n result = lambda_assign(all_vars, round_keys=round_keys)\n\n Op = lambda_assign\n ffo_arg0, ffo_arg1, ffo_arg2 = \"\", \"\", \"\"\n if hasattr(Op, \"my_index\"):\n ffo_arg0 = all_vars[Op.my_index]\n else:\n assert hasattr(Op, \"indices\")\n ffo_arg0 = all_vars[Op.indices[0]]\n if len(Op.indices) >= 2:\n ffo_arg1 = all_vars[Op.indices[1]]\n if len(Op.indices) >= 3:\n ffo_arg2 = all_vars[Op.indices[2]]\n ffo_extra_args = \"\"\n if hasattr(Op, \"ct\"):\n ffo_extra_args = Op.ct\n elif hasattr(Op, \"offset\"):\n ffo_extra_args = Op.offset\n elif hasattr(Op, \"ev_index\"):\n ffo_extra_args = round_keys[Op.ev_index]\n format_string = \"assignment {}/{}: {}({}, {}, {}, extra={}) = {}\"\n ffo = [index_assign, len(list_of_lambda_assignments) - 1,\n Op.op.__name__, ffo_arg0, ffo_arg1, ffo_arg2,\n ffo_extra_args, result]\n cls.log_msg(format_string, ffo)\n\n ## debugging\n # print(f\"\\t{result.width}-width op: {Op.op.__name__}\")\n # if hasattr(Op, \"my_index\"): print(\"\\t\\targ:\", all_vars[Op.my_index])\n # if hasattr(Op, \"indices\"): print(\"\\t\\targs:\", [all_vars[i] for i in Op.indices])\n # if hasattr(Op, \"ct\"): print(\"\\t\\tct:\", Op.ct)\n # if hasattr(Op, \"offset\"): print(\"\\t\\toffset:\", Op.offset)\n # if hasattr(Op, \"ev_index\"): print(\"\\t\\text_arg:\", round_keys[Op.ev_index])\n # print(f\"\\t\\tresult:\", result)\n all_vars.append(result)\n return all_vars[-num_outputs:]\n\n RandomBvFunction.eval = eval_method\n\n # check RandomBvFunction does not return Constant\n try:\n RandomBvFunction(*[core.Variable(f\"x{i}\", width) for i in range(num_inputs)],\n symbolic_inputs=True, simplify=False)\n except ValueError as e:\n if not str(e).startswith(\"if symbolic_inputs, expected no Constant values\"):\n raise e\n else:\n continue\n\n if num_rounds is None:\n return RandomBvFunction\n else:\n _num_rounds = num_rounds\n\n class RandomRBF(RandomBvFunction, RoundBasedFunction):\n num_rounds = _num_rounds\n\n @classmethod\n def eval(cls, *args):\n for index_round in range(cls.num_rounds):\n args = super().eval(*args)\n\n if index_round < cls.num_rounds - 1:\n if len(args) < len(cls.input_widths):\n args = args * ((len(cls.input_widths) // len(args)) + 1)\n args = args[:len(cls.input_widths)]\n\n cls.add_round_outputs(*args)\n\n format_string = \"round {}/{}: outputs = (\" + \"{}, \"*len(args) + \")\"\n ffo = [index_round, cls.num_rounds - 1] + list(args)\n cls.log_msg(format_string, ffo)\n return args\n\n @classmethod\n def set_num_rounds(cls, new_num_rounds):\n cls.num_rounds = new_num_rounds\n\n # check RandomRBF does not return Constant\n try:\n RandomRBF(*[core.Variable(f\"x{i}\", width) for i in range(num_inputs)],\n symbolic_inputs=True, simplify=False)\n except ValueError as e:\n if not str(e).startswith(\"if symbolic_inputs, expected no Constant values\"):\n raise e\n else:\n continue\n else:\n return RandomRBF","def test_broadcast(self):\n a = np.ones((3, 4, 1))\n ai = np.ones((1, 2, 5), dtype=np.intp)\n actual = take_along_axis(a, ai, axis=1)\n assert_equal(actual.shape, (3, 2, 5))","def multichannel(fcn):\n return lambda args: (fcn(*args), )","def evaluate_as_vector(self, chain_state): \n def vector_representation(n, ordering, it):\n return self.mapping.subspace(zip(ordering,it))\n return self._evaluate(vector_representation, chain_state)","def __rshift__(self, fn):\n if self is Nothing:\n return Nothing\n else:\n v = self.right if self.is_right() else self.left\n fn = liftF(fn, self.__class__)\n return unlift(fn(v))","def apply(self, func, *args, **kwargs):\n pass","def normalize(X, norm=..., *, axis=..., copy=..., return_norm=...):\n ...","def apply(self, func, *args):\n pass","def ptwise(self, f):\n m, n = self.shape\n for i in range(m):\n for j in range(n):\n self[(i, j)] = f(self[(i, j)])\n return self","def apply_along_0_nb(a, apply_func_nb, *args):\n out = np.empty_like(a, dtype=np.float_)\n for col in range(a.shape[1]):\n out[:, col] = apply_func_nb(col, a[:, col], *args)\n return out","def transform(tvec1, rvec1, tvec2, rvec2):\n op = localToGlobal(np.squeeze(tvec2), np.squeeze(rvec2))\n tvec3 = []\n for tvec in tvec1:\n #tvec = tvec.squeeze()\n tvec3.append(np.matmul(op, tvec))\n tvec3 = np.array(tvec3)\n return tvec3","def patternbroadcast(x, broadcastable):\r\n rval = Rebroadcast(*[(i, broadcastable[i])\r\n for i in xrange(len(broadcastable))])(x)\r\n return theano.tensor.opt.apply_rebroadcast_opt(rval)","def power_unary(x, n, f):\n return reduce(lambda g, h: lambda x: g(h(x)), itertools.repeat(f, n))(x)","def v(x):\n return x*x","def array_input(f):\n @wraps(f)\n def wrapped(self, t):\n t = np.atleast_1d(t)\n r = f(self, t)\n return r\n return wrapped","def tan_inplace(a):","def get_vector_b(args):\n\treturn [f(arg) for arg in args]"],"string":"[\n \"def autovectorized(f):\\r\\n def wrapper(input):\\r\\n if N.isscalar(input)==False:\\r\\n return N.vectorize(f)(input)\\r\\n return f(input)\\r\\n return wrapper\",\n \"def autovectorized(f):\\r\\n def wrapper(input):\\r\\n if N.isscalar(input)==False:\\r\\n return N.vectorize(f)(input)\\r\\n return f(input)\\r\\n return wrapper\",\n \"def vectorized_fn(*args):\\n with tf.name_scope(name or 'make_rank_polymorphic'):\\n # If we got a single value for core_ndims, tile it across all args.\\n core_ndims_structure = (\\n core_ndims\\n if tf.nest.is_nested(core_ndims)\\n else tf.nest.map_structure(lambda _: core_ndims, args))\\n\\n # Build flat lists of all argument parts and their corresponding core\\n # ndims.\\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\\n flat_args = nest.flatten_up_to(\\n core_ndims_structure, args, check_types=False)\\n\\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\\n # values for `core_ndims`). Other args will be passed through to `fn`\\n # unmodified.\\n (vectorized_arg_core_ndims,\\n vectorized_args,\\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\\n fn,\\n arg_structure=core_ndims_structure,\\n flat_core_ndims=flat_core_ndims,\\n flat_args=flat_args)\\n\\n # `vectorized_map` requires all inputs to have a single, common batch\\n # dimension `[n]`. So we broadcast all input parts to a common\\n # batch shape, then flatten it down to a single dimension.\\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\\n\\n vectorized_arg_actual_core_ndims = []\\n batch_shapes, core_shapes = [], []\\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\\n vectorized_arg_core_ndims):\\n arg_nd = ps.rank_from_shape(arg_shape)\\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\\n # `batch_ndims` is always nonnegative.\\n actual_core_nd = ps.minimum(arg_nd, core_nd)\\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\\n\\n batch_ndims = arg_nd - actual_core_nd\\n batch_ndims_ = tf.get_static_value(batch_ndims)\\n if batch_ndims_ is not None:\\n batch_shapes.append(arg_shape[:batch_ndims_])\\n core_shapes.append(arg_shape[batch_ndims_:])\\n else:\\n arg_shape = tf.convert_to_tensor(arg_shape)\\n batch_shapes.append(arg_shape[:batch_ndims])\\n core_shapes.append(arg_shape[batch_ndims:])\\n\\n # Flatten all of the batch dimensions into one.\\n broadcast_batch_shape = (\\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\\n\\n static_n = tf.get_static_value(n)\\n if static_n == 1:\\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\\n result_batch_dims = 0\\n batched_result = fn_of_vectorized_args(\\n tf.nest.map_structure(\\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\\n vectorized_args,\\n vectorized_arg_actual_core_ndims,\\n check_types=False))\\n else:\\n # Pad all input parts to the common shape, then flatten\\n # into the single leading dimension `[n]`.\\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\\n # when batch rank is static so that we can exploit broadcasting.\\n broadcast_vectorized_args = [\\n tf.broadcast_to(part, ps.concat(\\n [broadcast_batch_shape, core_shape], axis=0))\\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\\n vectorized_args_with_flattened_batch_dim = [\\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\\n for (part, core_shape) in zip(\\n broadcast_vectorized_args, core_shapes)]\\n result_batch_dims = 1\\n batched_result = tf.vectorized_map(\\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\\n\\n # Unflatten any `Tensor`s in the result.\\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\\n result = tf.nest.map_structure(\\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\\n expand_composites=True)\\n return result\",\n \"def vectorize_inputs(f):\\n return lambda args: f(*np.hsplit(args, args.shape[1]))\",\n \"def mlift(func):\\n return compose(unit, func)\",\n \"def vecToFunc(vector):\\n def f(x):\\n f = 0\\n for i in range(len(vector)):\\n f += vector[i]*x**i\\n return f\\n return f\",\n \"def vectorize_method(func):\\n @wraps(func)\\n def inner(obj, *iargs, **ikwargs):\\n\\n def functionalized_method(*args, **kwargs):\\n return func(obj, *args, **kwargs)\\n\\n return np.vectorize(functionalized_method, otypes=[np.dtype('c16')])(*iargs, **ikwargs)\\n #return np.vectorize(functionalized_method)(*iargs, **ikwargs)\\n return inner\",\n \"def apply(self: T, target: types.Vector) -> types.Vector:\",\n \"def vectorize(self, *args, **kwargs):\\n kwargs['add_start'] = False\\n kwargs['add_end'] = False\\n return TorchRankerAgent.vectorize(self, *args, **kwargs)\",\n \"def vectorize(func, processes=1, on_complete=None):\\n if processes > 1:\\n return __multiprocess_wrapper(func, processes, on_complete)\\n else:\\n return single_process_wrapper(func, on_complete)\",\n \"def vectorize(self):\\n return vectorize(self)\",\n \"def vectorize(sch, tensor, vectorize_limit):\\n inner_axis = s[tensor].op.axis[len(s[tensor].op.axis) - 1]\\n inner_length = tensor.shape[len(tensor.shape) - 1].value\\n if inner_length <= vectorize_limit:\\n sch[tensor].vectorize(inner_axis)\\n else:\\n split_factor = 1\\n for i in range(vectorize_limit, 1, -1):\\n if inner_length % i == 0:\\n split_factor = i\\n break\\n if split_factor > 1:\\n _, inner_i = sch[tensor].split(inner_axis, split_factor)\\n sch[tensor].vectorize(inner_i)\",\n \"def transform(fn):\\n def _(vec, dt):\\n return np.einsum(\\n 'ji,i,ki,k...->j...',\\n evecs, fn(evals, dt), evecs, vec, optimize=True)\\n\\n return _\",\n \"def vectorize_unpack(args):\\n return vectorize(*args)\",\n \"def vectorize_unpack(args):\\n return vectorize(*args)\",\n \"def csr_mulvec_wrap(fn):\\n\\n @functools.wraps(fn)\\n def csr_mul_vector(A, x):\\n if A.nnz > 50000 and _NUM_THREAD_WORKERS > 1:\\n return par_dot_csr_matvec(A, x)\\n else:\\n y = fn(A, x)\\n if isinstance(x, qarray):\\n y = qarray(y)\\n return y\\n\\n return csr_mul_vector\",\n \"def sp_mulvec_wrap(fn):\\n\\n @functools.wraps(fn)\\n def qarrayed_fn(self, other):\\n out = fn(self, other)\\n if isinstance(other, qarray):\\n out = qarray(out)\\n return out\\n\\n return qarrayed_fn\",\n \"def liftn(cls, func):\\n raise NotImplementedError\",\n \"def apply_scalar(vector, scalar):\\n new_coordinates = []\\n index = 0\\n while index < vector.dimension:\\n new_value = vector.coordinates[index] * scalar\\n new_coordinates.append(new_value)\\n index += 1\\n new_vector = Vector(new_coordinates)\\n return new_vector\",\n \"def lift(f: Callable[..., Data]) -> LiftedFunc:\\n def inner(*args: Result) -> Result:\\n out = []\\n for args1 in itertools.product(*args):\\n val = f(*args1)\\n out.append(val)\\n return out\\n return inner\",\n \"def lift(cls, func):\\n raise NotImplementedError\",\n \"def weyl_vector(rank):\\n return np.ones(rank, dtype=utils.itype)\",\n \"def custom_np_function(vector):\\n summation = 0\\n for item in vector:\\n summation += item ** 2\\n return summation\",\n \"def apply(self, vec):\\n raise NotImplementedError\",\n \"def wrap(fun):\\n class tmp:\\n def __init__(self, *args, **kwargs):\\n self.args = args\\n self.kwargs = kwargs\\n def __call__(self, x):\\n args, kwargs = list(self.args), self.kwargs\\n args.insert(i, x)\\n return fun(*args, **kwargs)\\n def __rmatmul__(self, others):\\n return [self.__call__(x) for x in others]\\n def __rfloordiv__(self, x):\\n return self.__call__(x)\\n return tmp\",\n \"def rank_zero_only(fn):\\n\\n def wrapped(*args, **kwargs):\\n if rank() == 0:\\n return fn(*args, **kwargs)\\n\\n return wrapped\",\n \"def _scalar_vectorized(scalar, M):\\n return scalar[:, np.newaxis, np.newaxis]*M\",\n \"def fn(x):\\n if x.ndim == 1:\\n return np.sum(x**2)\\n else:\\n return np.sum(x**2, axis=1)\",\n \"def lambda_fun(funk, x):\\n # input must be 1d numpy.ndarray\\n assert isinstance(x, np.ndarray) and x.ndim == 1\\n\\n # result from the lambdified function with array input\\n abo = funk(x)\\n\\n if isinstance(abo, float):\\n abo = np.array([[abo]])\\n\\n if abo.ndim < 3:\\n # reshaping from (n,1) to (n,)\\n abo = abo.reshape(abo.shape[0])\\n\\n # fix the term not properly broadcasted in the lambdified funtion\\n abo_fix = np.array(np.broadcast_arrays(x, *abo)[1:])\\n\\n elif abo.ndim == 3:\\n abo_fix = abo.reshape(abo.shape[0], -1)\\n\\n # roll the axis to obtain an array of matrix, and not a matrix of arrays\\n abo_fix = np.moveaxis(abo_fix, -1, 0)\\n\\n return abo_fix\",\n \"def func(self, name, vecs):\\n arity = len(vecs)\\n funcobj = self.get_ground_vector('!Func:{}:{}'.format(arity, name))\\n\\n argobjs = [\\n associate(\\n self.get_ground_vector('!Arg:{}:{}:{}'.format(arity, name, i)),\\n vec)\\n for i, vec in enumerate(vecs) ]\\n\\n result = normalize(\\n self.func_weights @\\n torch.cat([\\n funcobj,\\n merge(argobjs),\\n merge(vecs),\\n ]).reshape(-1, self.hrr_size))\\n\\n return result\",\n \"def rank_transform(X):\\n return np.apply_along_axis(scipy.stats.rankdata, 0, X)\",\n \"def function(fnc, *args, **kwargs):\\n return Function(fnc, args=args, kwargs=kwargs).tunable()\",\n \"def lambdify_fun(funk, x):\\n\\n abo = funk(x)\\n\\n if isinstance(abo, float):\\n abo *= np.ones(x.shape)\\n\\n return abo\",\n \"def make_pbroadcast_function(fn, in_axes, out_axes, out_dtype):\\n\\n if not isinstance(in_axes, tuple):\\n in_axes = (in_axes,)\\n\\n def pbroadcast_fn(*args):\\n nest.assert_shallow_structure(args, in_axes)\\n nest.assert_shallow_structure(out_dtype, out_axes)\\n map_in_axes = nest.map_structure_up_to(args, canonicalize_axis_name,\\n in_axes)\\n map_out_axes = nest.map_structure_up_to(out_dtype, canonicalize_axis_name,\\n out_axes)\\n\\n def _pbroadcast_input(out_axes, x, in_axes):\\n psum_axes = [\\n axis_name for axis_name in out_axes if axis_name not in in_axes\\n ]\\n return pbroadcast(x, psum_axes)\\n\\n def _flat_fn_index(i, *args):\\n out = fn(*args)\\n return tf.nest.flatten(out)[i]\\n\\n def _flat_fn(*args):\\n outputs = []\\n for i, out_axis in enumerate(nest.flatten_up_to(out_dtype, map_out_axes)):\\n local_args = nest.map_structure_up_to(\\n args, functools.partial(_pbroadcast_input, out_axis), args,\\n map_in_axes)\\n outputs.append(_flat_fn_index(i, *local_args))\\n return tf.nest.pack_sequence_as(out_dtype, outputs)\\n\\n return _flat_fn(*args)\\n\\n return pbroadcast_fn\",\n \"def apply(self, vec):\\n return self._disp_over_m * vec - self._gp * ( # pylint: disable = E1130\\n self._gp @ vec / self.L ** self.ndim\\n )\",\n \"def vectorMultiply(v, f):\\n return [x * f for x in v]\",\n \"def Generate_Custom(f, n, m):\\n return np.fromfunction(np.vectorize(f, otypes=[float]), (n,m))\",\n \"def apply_function_vector(function_vector, x_vector):\\n function_index = 0\\n element_index = 1\\n \\n def d():\\n for e in zip(function_vector, x_vector):\\n print(e[1])\\n d()\\n \\n return list(map(lambda fx_set: fx_set[function_index](fx_set[element_index]), zip(function_vector, x_vector)))\",\n \"def apply(self,v):\\n return np.tensordot(self._transform, v, axes=([1],[0])) \\\\\\n + self._translation\",\n \"def _rankf(x):\\n shift = int32(31)\\n mask = int32((1 << 31) - 1)\\n i32 = x.view(int32)\\n value = i32 >> shift\\n value &= mask\\n value ^= i32\\n return value\",\n \"def n_ary(func):\\n def wrapper(x, *args):\\n return x if not args else func(x, wrapper(*args))\\n return wrapper\",\n \"def transform(self, *args, **kwargs):\\n r = Vector2(np.dot(args[0], self))\\n if kwargs.get(\\\"norm\\\", False):\\n r = r.normalized()\\n return type(self)(r)\",\n \"def func(self, name, vecs):\\n arity = len(vecs)\\n funcobj = self.get_ground_vector('!Func:{}:{}'.format(arity, name))\\n\\n argobjs = [\\n associate_comp(\\n self.get_ground_vector('!Arg:{}:{}:{}'.format(arity, name, i)),\\n vec)\\n for i, vec in enumerate(vecs) ]\\n\\n result = normalize_comp(\\n self.func_weights @\\n torch.cat([\\n funcobj,\\n merge(argobjs),\\n merge(vecs),\\n ]).reshape(-1, 2 * self.hrr_size)).reshape(2, self.hrr_size)\\n\\n return result\",\n \"def func(self, name, vecs):\\n arity = len(vecs)\\n funcobj = self.get_ground_vector('!Func:{}:{}'.format(arity, name))\\n\\n argobjs = [\\n associate_comp(\\n self.get_ground_vector('!Arg:{}:{}:{}'.format(arity, name, i)),\\n vec)\\n for i, vec in enumerate(vecs) ]\\n\\n result = normalize_comp(\\n self.func_weights @\\n torch.cat([\\n funcobj,\\n merge(argobjs),\\n merge(vecs),\\n ]).reshape(-1, 2 * self.hrr_size)).reshape(2, self.hrr_size)\\n\\n return result\",\n \"def _lock_in_non_vectorized_args(fn, arg_structure, flat_core_ndims, flat_args):\\n\\n # Extract the indices and values of args where core_ndims is not `None`.\\n (vectorized_arg_indices,\\n vectorized_arg_core_ndims,\\n vectorized_args) = [], [], []\\n if any(nd is not None for nd in flat_core_ndims):\\n vectorized_arg_indices, vectorized_arg_core_ndims, vectorized_args = zip(*[\\n (i, nd, tf.convert_to_tensor(t))\\n for i, (nd, t) in enumerate(zip(flat_core_ndims, flat_args))\\n if nd is not None])\\n\\n vectorized_arg_index_set = set(vectorized_arg_indices)\\n\\n def fn_of_vectorized_args(vectorized_args):\\n with tf.name_scope('fn_of_vectorized_args'):\\n vectorized_args_by_index = dict(\\n zip(vectorized_arg_indices, vectorized_args))\\n # Substitute the vectorized args into the original argument\\n # structure.\\n new_args_with_original_structure = tf.nest.pack_sequence_as(\\n arg_structure, [vectorized_args_by_index[i]\\n if i in vectorized_arg_index_set\\n else v for (i, v) in enumerate(flat_args)])\\n return tf.nest.map_structure(\\n # If `fn` returns any Distribution instances, ensure that their\\n # parameter batch shapes are padded to align after vectorization.\\n _maybe_rectify_parameter_shapes,\\n fn(*new_args_with_original_structure))\\n\\n return (vectorized_arg_core_ndims,\\n vectorized_args,\\n fn_of_vectorized_args)\",\n \"def local_subtensor_lift(node):\\r\\n if isinstance(node.op, Subtensor):\\r\\n u = node.inputs[0]\\r\\n if not u.owner or len(u.clients) > 1:\\r\\n return False\\r\\n\\r\\n if isinstance(u.owner.op, T.Elemwise) and len(u.owner.inputs) == 1:\\r\\n idx = node.inputs[1:]\\r\\n x_idx = node.op(u.owner.inputs[0], *idx)\\r\\n return [u.owner.op(x_idx)]\\r\\n\\r\\n if isinstance(u.owner.op, T.Elemwise):\\r\\n new_inputs = []\\r\\n if all([sum(i.type.broadcastable) == 0 for i in u.owner.inputs]):\\r\\n # There is no broadcastable in the inputs\\r\\n idx = node.inputs[1:]\\r\\n new_inputs = [node.op(i, *idx) for i in u.owner.inputs]\\r\\n return [u.owner.op(*new_inputs)]\\r\\n elif all([sum(i.type.broadcastable) in [i.ndim, 0]\\r\\n for i in u.owner.inputs]):\\r\\n # There is no broadcastable in the inputs or it is scalar\\r\\n idx = node.inputs[1:]\\r\\n new_inputs = []\\r\\n for i in u.owner.inputs:\\r\\n if sum(i.type.broadcastable) == 0:\\r\\n new_inputs.append(node.op(i, *idx))\\r\\n else:\\r\\n # If the subtensor remove some dims, we must\\r\\n # lower the number of dimensions of this scalar.\\r\\n if node.outputs[0].ndim == i.ndim:\\r\\n new_inputs.append(i)\\r\\n else:\\r\\n new_inputs.append(\\r\\n i.dimshuffle(['x'] * node.outputs[0].ndim))\\r\\n return [u.owner.op(*new_inputs)]\\r\\n\\r\\n if isinstance(u.owner.op, T.Rebroadcast):\\r\\n # make sure that Rebroadcast has only 1 input\\r\\n assert len(u.owner.inputs) == 1\\r\\n\\r\\n # Subtensor might reduce dim., adapt broadcast pattern accordingly\\r\\n new_axis = []\\r\\n\\r\\n # loop through indices being subtensor-ed\\r\\n # i indexes broadcastable pattern before subtensor\\r\\n # j indexes broadcastable pattern after subtensor\\r\\n j = 0\\r\\n for (i, x) in enumerate(node.op.idx_list):\\r\\n # if its not a slice, it will reduce the dimension, should\\r\\n # not appear in the broascastable dimensions\\r\\n if isinstance(x, slice):\\r\\n new_axis += [(j, u.broadcastable[i])]\\r\\n j += 1\\r\\n # now keep the broadcastable pattern of all\\r\\n # items not appearing in subtensor list\\r\\n for i in xrange(len(node.op.idx_list), len(u.broadcastable)):\\r\\n new_axis += [(j, u.broadcastable[i])]\\r\\n j += 1\\r\\n\\r\\n subt_x = node.op(u.owner.inputs[0], *node.inputs[1:])\\r\\n rbcast_subt_x = T.Rebroadcast(*new_axis)(subt_x)\\r\\n\\r\\n return [rbcast_subt_x]\",\n \"def basis_fns(n=0):\\n return lambda x: np.sum(x ** (n+1), axis=1)\",\n \"def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\\n axis = check_axes(axis)\\n if len(axis) == x.ndim:\\n return func(x)\\n\\n other_axes = negate_indices(axis, x.ndim)\\n begin = np.arange(len(other_axes))\\n\\n y = np.moveaxis(x, other_axes, begin)\\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)\",\n \"def n_ary(f):\\n def n_ary_fn(x, *args):\\n return x if not args else f(x, n_ary_fn(*args))\\n return n_ary_fn\",\n \"def _scal_elemwise_with_nfunc(nfunc, nin, nout):\\r\\n def construct(symbol):\\r\\n symbolname = symbol.__name__\\r\\n inplace = symbolname.endswith('_inplace')\\r\\n if inplace:\\r\\n msg = \\\"inplace\\\"\\r\\n else:\\r\\n msg = \\\"no_inplace\\\"\\r\\n\\r\\n n = \\\"Elemwise{%s,%s}\\\" % (symbolname, msg)\\r\\n\\r\\n if inplace:\\r\\n scalar_op = getattr(scal, symbolname[:-len('_inplace')])\\r\\n inplace_scalar_op = scalar_op.__class__(scal.transfer_type(0))\\r\\n rval = elemwise.Elemwise(inplace_scalar_op, {0: 0}, name=n,\\r\\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\\r\\n else:\\r\\n scalar_op = getattr(scal, symbolname)\\r\\n rval = elemwise.Elemwise(scalar_op, name=n,\\r\\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\\r\\n\\r\\n if getattr(symbol, '__doc__', False):\\r\\n rval.__doc__ = symbol.__doc__ + '\\\\n' + rval.__doc__\\r\\n\\r\\n # for the meaning of this see the ./epydoc script\\r\\n # it makes epydoc display rval as if it were a function, not an object\\r\\n rval.__epydoc_asRoutine = symbol\\r\\n rval.__module__ = 'tensor'\\r\\n\\r\\n pprint.assign(rval, printing.FunctionPrinter(symbolname))\\r\\n\\r\\n return rval\\r\\n return construct\",\n \"def position_op(x, wfunc):\\n return x*wfunc\",\n \"def transform(self, F, **kwargs):\\n r = Vector3(np.dot(F, self))\\n if kwargs.get(\\\"norm\\\", False):\\n r = r.normalized()\\n return type(self)(r)\",\n \"def apply_along_1_nb(a, apply_func_nb, *args):\\n out = np.empty_like(a, dtype=np.float_)\\n for i in range(a.shape[0]):\\n out[i, :] = apply_func_nb(i, a[i, :], *args)\\n return out\",\n \"def reconstruction(B, N):\\n\\n def _(f):\\n return lambda *x: sum(f[i] * B(i)(*x) for i in range(N))\\n\\n return _\",\n \"def _fn(dtype, shape, name, trainable, add_variable_fn):\\n loc, scale = loc_scale_fn_(dtype, shape, name, trainable, add_variable_fn)\\n if scale is None:\\n dist = deterministic_lib.Deterministic(loc=loc)\\n else:\\n dist = normal_lib.Normal(loc=loc, scale=scale)\\n reinterpreted_batch_ndims = array_ops.shape(dist.batch_shape_tensor())[0]\\n return independent_lib.Independent(\\n dist, reinterpreted_batch_ndims=reinterpreted_batch_ndims)\",\n \"def vectorize(features, vocab):\\n vec = lil_matrix((1, len(vocab)))\\n for feat in features:\\n try:\\n fidx = vocab[feat]\\n vec[0, fidx] += 1.0\\n except KeyError:\\n pass\\n return vec\",\n \"def vectorized_rounder():\\n\\n def f(num):\\n if np.isnan(num):\\n return np.nan\\n else:\\n return num // 10 ** (int(math.log(num, 10)))\\n\\n vf = np.vectorize(f)\\n\\n return(vf)\",\n \"def unary_wrap(run):\\n\\n def run_unary(transitions, input, steps):\\n return run(transitions, '1' * input, steps)\\n\\n return run_unary\",\n \"def feed(self, vector):\\n return vector\",\n \"def multiply_fisher(self, vector: jnp.ndarray) -> jnp.ndarray:\\n return utils.scalar_mul(\\n self.multiply_fisher_unweighted(vector), self.weight)\",\n \"def _compute_R1_from_vector(n, ind_mat, vec):\\r\\n\\r\\n R1 = 0\\r\\n for l in range(n):\\r\\n R1 += np.sum((2*ind_mat[:, l]+1) * vec**2)\\r\\n\\r\\n return R1\",\n \"def apply(cls, func):\\n raise NotImplementedError\",\n \"def lift(func: Callable) -> Callable:\\n return lambda f: compose2(func, f)\",\n \"def vectorOperator(method):\\n\\top = method.__name__\\n\\tsetattr(VectorDistribution, op, makeVectorOperatorHandler(op))\\n\\n\\t@functools.wraps(method)\\n\\tdef handler2(self, *args):\\n\\t\\tif needsSampling(self):\\n\\t\\t\\treturn VectorOperatorDistribution(op, self, args)\\n\\t\\telif any(needsSampling(arg) for arg in args):\\n\\t\\t\\treturn VectorMethodDistribution(method, self, args, {})\\n\\t\\telif any(needsLazyEvaluation(arg) for arg in args):\\n\\t\\t\\t# see analogous comment in distributionFunction\\n\\t\\t\\treturn makeDelayedFunctionCall(handler2, args, {})\\n\\t\\telse:\\n\\t\\t\\treturn method(self, *args)\\n\\treturn handler2\",\n \"def rank_zero_only(fn):\\n\\n @wraps(fn)\\n def wrapped_fn(self, *args, **kwargs):\\n if self.rank == 0:\\n fn(self, *args, **kwargs)\\n\\n return wrapped_fn\",\n \"def applyToEach(L,f):\\n for i in range(len(L)):\\n L[i] = f(L[i])\",\n \"def _np_apply_along_axis(func1d, axis: int, arr: np.ndarray) -> np.ndarray:\\n\\n assert arr.ndim == 2\\n assert axis in [0, 1]\\n\\n if axis == 0:\\n result = np.empty(arr.shape[1])\\n for i in range(len(result)):\\n result[i] = func1d(arr[:, i])\\n return result\\n\\n result = np.empty(arr.shape[0])\\n for i in range(len(result)):\\n result[i] = func1d(arr[i, :])\\n\\n return result\",\n \"def _chunk_vmapped_function(vmapped_fun, chunk_size, argnums=0):\\n\\n if chunk_size is None:\\n return vmapped_fun\\n\\n if isinstance(argnums, int):\\n argnums = (argnums,)\\n\\n def _fun(*args):\\n\\n n_elements = jax.tree_leaves(args[argnums[0]])[0].shape[0]\\n n_chunks, n_rest = divmod(n_elements, chunk_size)\\n\\n if n_chunks == 0 or chunk_size >= n_elements:\\n y = vmapped_fun(*args)\\n else:\\n # split inputs\\n def _get_chunks(x):\\n x_chunks = jax.tree_map(lambda x_: x_[: n_elements - n_rest, ...], x)\\n x_chunks = _chunk(x_chunks, chunk_size)\\n return x_chunks\\n\\n def _get_rest(x):\\n x_rest = jax.tree_map(lambda x_: x_[n_elements - n_rest :, ...], x)\\n return x_rest\\n\\n args_chunks = [\\n _get_chunks(a) if i in argnums else a for i, a in enumerate(args)\\n ]\\n args_rest = [\\n _get_rest(a) if i in argnums else a for i, a in enumerate(args)\\n ]\\n\\n y_chunks = _unchunk(\\n scanmap(vmapped_fun, scan_append, argnums)(*args_chunks)\\n )\\n\\n if n_rest == 0:\\n y = y_chunks\\n else:\\n y_rest = vmapped_fun(*args_rest)\\n y = jax.tree_map(\\n lambda y1, y2: jnp.concatenate((y1, y2)), y_chunks, y_rest\\n )\\n return y\\n\\n return _fun\",\n \"def power_transform(X, method=..., *, standardize=..., copy=...):\\n ...\",\n \"def n_ary(f):\\n def n_ary_f(x,*args):\\n return x if not args else f(x,n_ary_f(*args))\\n return n_ary_f\",\n \"def apply_new_basis(new_base, vector_array):\\n return np.dot(new_base, vector_array).T\",\n \"def forward(self, x, mask):\\n for layer in self.layers:\\n x = layer(x, mask)\\n return self.norm(x)\",\n \"def test_broadcast(self):\\n a = np.ones((3, 4, 1))\\n ai = np.arange(10, dtype=np.intp).reshape((1, 2, 5)) % 4\\n put_along_axis(a, ai, 20, axis=1)\\n assert_equal(take_along_axis(a, ai, axis=1), 20)\",\n \"def scale_vectors(vectors, f):\\n return [scale_vector(vector, f) for vector in vectors]\",\n \"def _newton_update(func):\\n return lambda x: x - func[0](x) / func[1](x)\",\n \"def call(self, x):\\n return tf.tile(x, self._mult)\",\n \"def __imul__(self, scalar):\\n m, n = self.shape\\n scalar = mpfr(scalar)\\n for i in range(m):\\n for j in range(n):\\n self[i, j] *= scalar\\n return self\",\n \"def shift_f(f, tau):\\n n, T = f.shape\\n fn = zeros((n, T))\\n fn[:, 0:(T - 1)] = roll(f[:, 0:(T - 1)], tau, axis=1)\\n fn[:, T - 1] = fn[:, 0]\\n\\n return (fn)\",\n \"def Avv_func(f):\\n\\n def Avv(x, v):\\n def F(s):\\n return f(x + v * s)\\n\\n return jacfwd(jacfwd(F))(0.0)\\n\\n return Avv\",\n \"def array_map(fn, arrs, n):\\n # we shouldn't need a special case for n == 0, but NumPy complains about indexing into a zero-dimensional\\n # array a using a[(Ellipsis,)].\\n if n == 0:\\n return fn(*arrs)\\n \\n full_shape = tuple(np.array([a.shape[:n] for a in arrs]).max(0))\\n result = None\\n for full_idx in itertools.product(*map(range, full_shape)):\\n inputs = [a[broadcast(full_idx, a.shape[:n]) + (Ellipsis,)] for a in arrs]\\n curr = fn(*inputs)\\n \\n if result is None:\\n if type(curr) == tuple:\\n result = tuple(np.zeros(full_shape + np.asarray(c).shape) for c in curr)\\n else:\\n result = np.zeros(full_shape + np.asarray(curr).shape)\\n\\n if type(curr) == tuple:\\n for i, c in enumerate(curr):\\n result[i][full_idx + (Ellipsis,)] = c\\n else:\\n result[full_idx + (Ellipsis,)] = curr\\n return result\",\n \"def minimum_eigen_vector(x, num_steps, learning_rate, vector_prod_fn):\\n x = tf.nn.l2_normalize(x)\\n for _ in range(num_steps):\\n x = eig_one_step(x, learning_rate, vector_prod_fn)\\n return x\",\n \"def __imul__(self, tensor):\\n return self.mul_(tensor)\",\n \"def __call__(self, x):\\n return self._pre_scale * tf.matmul(x, self._weight) + self._bias\",\n \"def get_random_bvfunction(width, num_inputs, num_outputs, num_assignments, seed,\\n external_variable_prefix=None, operation_set_index=0, num_rounds=None,\\n extra_operations=None):\\n assert num_inputs + num_assignments >= num_outputs\\n\\n import random\\n import functools\\n from cascada.bitvector.operation import (\\n BvAnd, BvOr, BvXor, BvShl, BvLshr, RotateLeft, RotateRight, BvAdd,\\n BvSub, BvNeg, BvNot, Concat, BvIdentity, make_partial_operation\\n )\\n from cascada.bitvector.secondaryop import BvIf, BvMaj\\n\\n PRNG = random.Random()\\n PRNG.seed(seed)\\n\\n # SimpleReverse contains Concat and Extract\\n # implemented as a class to later use issubclass()\\n class SimpleReverse(object):\\n def __new__(cls, bv):\\n return functools.reduce(Concat, [bv[i] for i in range(bv.width)])\\n\\n if operation_set_index == 0:\\n list_ops = (\\n BvNot, BvXor, BvAnd, BvOr,\\n BvAdd, BvSub, BvNeg,\\n BvIdentity,\\n BvIf, BvMaj,\\n RotateLeft, RotateRight,\\n BvShl, BvLshr,\\n SimpleReverse\\n # Concat, Extract, Ite,\\n # BvComp, BvUlt, BvUle, BvUgt, BvUge,\\n # BvMul, BvUdiv, BvUrem,\\n # PopCount, Reverse, PopCountSum2, PopCountSum3, PopCountDiff, LeadingZeros,\\n )\\n elif operation_set_index == 1:\\n list_ops = (\\n BvNot, BvXor, BvAnd, BvOr,\\n BvAdd, BvSub, BvNeg,\\n BvIdentity,\\n BvIf, BvMaj,\\n RotateLeft, RotateRight,\\n make_partial_operation(BvShl, (None, core.Constant(PRNG.randint(1, width - 1), width))),\\n make_partial_operation(BvLshr, (None, core.Constant(PRNG.randint(1, width - 1), width))),\\n )\\n elif operation_set_index == 2:\\n list_ops = (\\n BvNot, BvXor, BvAnd, BvOr,\\n BvAdd, BvSub,\\n BvIdentity,\\n RotateLeft, RotateRight,\\n BvShl, BvLshr,\\n SimpleReverse\\n )\\n elif operation_set_index == 3:\\n list_ops = (\\n BvNot, BvXor, BvAnd, BvOr,\\n BvAdd, BvSub, BvNeg,\\n BvIdentity,\\n BvIf, BvMaj,\\n RotateLeft, RotateRight,\\n BvShl, BvLshr,\\n SimpleReverse\\n )\\n else:\\n raise ValueError(\\\"operation_set_index must be 0, 1, 2, or 3\\\")\\n\\n extra_operations_vrepr = None\\n if extra_operations is not None:\\n list_ops += tuple(extra_operations)\\n extra_operations_vrepr = f\\\"({','.join(op.__name__ for op in extra_operations)},)\\\"\\n\\n while True: # outer loop to check RandomBvFunction does not return Constant\\n list_of_lambda_assignments = []\\n\\n class RandomBvFunction(BvFunction):\\n input_widths = [width] * num_inputs\\n output_widths = [width] * num_outputs\\n \\n @classmethod\\n def vrepr(cls):\\n evp = external_variable_prefix.__repr__()\\n return f\\\"get_random_bvfunction({width}, {num_inputs}, {num_outputs}, \\\" \\\\\\n f\\\"{num_assignments}, {seed}, {evp}, {operation_set_index}, {num_rounds}, \\\" \\\\\\n f\\\"{extra_operations_vrepr})\\\"\\n\\n if external_variable_prefix is not None:\\n RandomBvFunction.round_keys = []\\n\\n def get_random_var_index():\\n if len(list_of_lambda_assignments) >= num_inputs + 2:\\n min_index = num_inputs\\n else:\\n min_index = 0\\n return PRNG.randint(min_index, len(list_of_lambda_assignments) + num_inputs - 1)\\n\\n def get_random_var_indices(num_indices, my_unique_indices):\\n indices = []\\n while True:\\n new_index = get_random_var_index()\\n if not my_unique_indices or new_index not in indices:\\n indices.append(new_index)\\n if len(indices) == num_indices:\\n break\\n return indices\\n\\n while True:\\n _op = list_ops[PRNG.randint(0, len(list_ops) - 1)]\\n\\n if _op in [RotateLeft, RotateRight]: # only operations with scalar inputs\\n class Op(object): # need a class to store the randomness\\n op = _op\\n my_index = get_random_var_index()\\n offset = PRNG.randint(1, width - 1) # != 0\\n # kwargs required for external vars (see below)\\n def __new__(cls, args, **kwargs): return cls.op(args[cls.my_index], cls.offset)\\n\\n elif _op == SimpleReverse:\\n class Op(object):\\n op = _op\\n my_index = get_random_var_index()\\n def __new__(cls, args, **kwargs): return cls.op(args[cls.my_index])\\n\\n elif _op in [BvShl, BvLshr]: # ensure 2nd operand ct\\n class Op(object):\\n op = _op\\n my_index = get_random_var_index()\\n offset = core.Constant(PRNG.randint(1, width - 1), width)\\n def __new__(cls, args, **kwargs): return cls.op(args[cls.my_index], cls.offset)\\n\\n else:\\n assert issubclass(_op, operation.Operation)\\n assert _op.arity[1] == 0\\n\\n if _op.arity[0] >= 2 and PRNG.randint(0, 3) == 0:\\n # 1 in 4 to have a ct or external var (each 50%)\\n if external_variable_prefix is None or PRNG.randint(0, 1) == 0:\\n extra_arg = core.Constant(PRNG.randint(1, 2**width - 2), width) # != 0, allones\\n\\n class Op(object):\\n op = _op\\n indices = get_random_var_indices(_op.arity[0] - 1, False)\\n ct = extra_arg\\n def __new__(cls, args, **kwargs): return cls.op(*([args[i] for i in cls.indices] + [cls.ct]))\\n else:\\n evi = PRNG.randint(0, len(RandomBvFunction.round_keys))\\n if evi == len(RandomBvFunction.round_keys):\\n RandomBvFunction.round_keys.append(core.Variable(f\\\"{external_variable_prefix}{evi}\\\", width))\\n\\n class Op(object):\\n op = _op\\n indices = get_random_var_indices(_op.arity[0] - 1, False)\\n ev_index = evi\\n # kwargs[\\\"round_keys\\\"] instead of RandomBvFunction.round_keys\\n # to provide round_keys from cls in running time (in an argument of Op(\\n # (otherwise round_keys cannot be changed)\\n def __new__(cls, args, **kwargs): return cls.op(*([args[i] for i in cls.indices] +\\n [kwargs[\\\"round_keys\\\"][cls.ev_index]]))\\n else:\\n unique_indices = _op in [BvAnd, BvOr, BvXor, BvSub]\\n if unique_indices and len(list_of_lambda_assignments) + num_inputs == 1:\\n # avoid using duplicated inputs for these operations\\n continue\\n\\n class Op(object):\\n op = _op\\n indices = get_random_var_indices(_op.arity[0], unique_indices)\\n def __new__(cls, args, **kwargs): return cls.op(*[args[i] for i in cls.indices])\\n\\n if external_variable_prefix is not None and len(RandomBvFunction.round_keys) == 0:\\n # ensure at least 1 external variable\\n _op = BvXor\\n evi = 0\\n RandomBvFunction.round_keys.append(core.Variable(f\\\"{external_variable_prefix}{evi}\\\", width))\\n\\n class Op(object):\\n op = _op\\n indices = get_random_var_indices(_op.arity[0] - 1, False)\\n ev_index = evi\\n def __new__(cls, args, **kwargs): return cls.op(*([args[i] for i in cls.indices] +\\n [kwargs[\\\"round_keys\\\"][cls.ev_index]]))\\n\\n ## debugging\\n # print(f\\\"{len(list_of_lambda_assignments)+1}/{num_assignments} | op: {Op.op}\\\")\\n # if hasattr(Op, \\\"my_index\\\"): print(\\\"\\\\tmy_index:\\\", Op.my_index)\\n # if hasattr(Op, \\\"indices\\\"): print(\\\"\\\\tindices:\\\", Op.indices)\\n # if hasattr(Op, \\\"ct\\\"): print(\\\"\\\\tct:\\\", Op.ct)\\n # if hasattr(Op, \\\"offset\\\"): print(\\\"\\\\toffset:\\\", Op.offset)\\n # if hasattr(Op, \\\"ev_index\\\"): print(\\\"\\\\tev_index:\\\", Op.ev_index)\\n\\n list_of_lambda_assignments.append(Op)\\n if len(list_of_lambda_assignments) == num_assignments:\\n break\\n\\n list_of_lambda_assignments = tuple(list_of_lambda_assignments)\\n\\n @classmethod\\n def eval_method(cls, *args):\\n assert isinstance(args, collections.abc.Sequence)\\n all_vars = list(args)\\n round_keys = getattr(cls, \\\"round_keys\\\", None)\\n ## debugging\\n # print(f\\\"eval_method({args}):\\\")\\n for index_assign, lambda_assign in enumerate(list_of_lambda_assignments):\\n result = lambda_assign(all_vars, round_keys=round_keys)\\n\\n Op = lambda_assign\\n ffo_arg0, ffo_arg1, ffo_arg2 = \\\"\\\", \\\"\\\", \\\"\\\"\\n if hasattr(Op, \\\"my_index\\\"):\\n ffo_arg0 = all_vars[Op.my_index]\\n else:\\n assert hasattr(Op, \\\"indices\\\")\\n ffo_arg0 = all_vars[Op.indices[0]]\\n if len(Op.indices) >= 2:\\n ffo_arg1 = all_vars[Op.indices[1]]\\n if len(Op.indices) >= 3:\\n ffo_arg2 = all_vars[Op.indices[2]]\\n ffo_extra_args = \\\"\\\"\\n if hasattr(Op, \\\"ct\\\"):\\n ffo_extra_args = Op.ct\\n elif hasattr(Op, \\\"offset\\\"):\\n ffo_extra_args = Op.offset\\n elif hasattr(Op, \\\"ev_index\\\"):\\n ffo_extra_args = round_keys[Op.ev_index]\\n format_string = \\\"assignment {}/{}: {}({}, {}, {}, extra={}) = {}\\\"\\n ffo = [index_assign, len(list_of_lambda_assignments) - 1,\\n Op.op.__name__, ffo_arg0, ffo_arg1, ffo_arg2,\\n ffo_extra_args, result]\\n cls.log_msg(format_string, ffo)\\n\\n ## debugging\\n # print(f\\\"\\\\t{result.width}-width op: {Op.op.__name__}\\\")\\n # if hasattr(Op, \\\"my_index\\\"): print(\\\"\\\\t\\\\targ:\\\", all_vars[Op.my_index])\\n # if hasattr(Op, \\\"indices\\\"): print(\\\"\\\\t\\\\targs:\\\", [all_vars[i] for i in Op.indices])\\n # if hasattr(Op, \\\"ct\\\"): print(\\\"\\\\t\\\\tct:\\\", Op.ct)\\n # if hasattr(Op, \\\"offset\\\"): print(\\\"\\\\t\\\\toffset:\\\", Op.offset)\\n # if hasattr(Op, \\\"ev_index\\\"): print(\\\"\\\\t\\\\text_arg:\\\", round_keys[Op.ev_index])\\n # print(f\\\"\\\\t\\\\tresult:\\\", result)\\n all_vars.append(result)\\n return all_vars[-num_outputs:]\\n\\n RandomBvFunction.eval = eval_method\\n\\n # check RandomBvFunction does not return Constant\\n try:\\n RandomBvFunction(*[core.Variable(f\\\"x{i}\\\", width) for i in range(num_inputs)],\\n symbolic_inputs=True, simplify=False)\\n except ValueError as e:\\n if not str(e).startswith(\\\"if symbolic_inputs, expected no Constant values\\\"):\\n raise e\\n else:\\n continue\\n\\n if num_rounds is None:\\n return RandomBvFunction\\n else:\\n _num_rounds = num_rounds\\n\\n class RandomRBF(RandomBvFunction, RoundBasedFunction):\\n num_rounds = _num_rounds\\n\\n @classmethod\\n def eval(cls, *args):\\n for index_round in range(cls.num_rounds):\\n args = super().eval(*args)\\n\\n if index_round < cls.num_rounds - 1:\\n if len(args) < len(cls.input_widths):\\n args = args * ((len(cls.input_widths) // len(args)) + 1)\\n args = args[:len(cls.input_widths)]\\n\\n cls.add_round_outputs(*args)\\n\\n format_string = \\\"round {}/{}: outputs = (\\\" + \\\"{}, \\\"*len(args) + \\\")\\\"\\n ffo = [index_round, cls.num_rounds - 1] + list(args)\\n cls.log_msg(format_string, ffo)\\n return args\\n\\n @classmethod\\n def set_num_rounds(cls, new_num_rounds):\\n cls.num_rounds = new_num_rounds\\n\\n # check RandomRBF does not return Constant\\n try:\\n RandomRBF(*[core.Variable(f\\\"x{i}\\\", width) for i in range(num_inputs)],\\n symbolic_inputs=True, simplify=False)\\n except ValueError as e:\\n if not str(e).startswith(\\\"if symbolic_inputs, expected no Constant values\\\"):\\n raise e\\n else:\\n continue\\n else:\\n return RandomRBF\",\n \"def test_broadcast(self):\\n a = np.ones((3, 4, 1))\\n ai = np.ones((1, 2, 5), dtype=np.intp)\\n actual = take_along_axis(a, ai, axis=1)\\n assert_equal(actual.shape, (3, 2, 5))\",\n \"def multichannel(fcn):\\n return lambda args: (fcn(*args), )\",\n \"def evaluate_as_vector(self, chain_state): \\n def vector_representation(n, ordering, it):\\n return self.mapping.subspace(zip(ordering,it))\\n return self._evaluate(vector_representation, chain_state)\",\n \"def __rshift__(self, fn):\\n if self is Nothing:\\n return Nothing\\n else:\\n v = self.right if self.is_right() else self.left\\n fn = liftF(fn, self.__class__)\\n return unlift(fn(v))\",\n \"def apply(self, func, *args, **kwargs):\\n pass\",\n \"def normalize(X, norm=..., *, axis=..., copy=..., return_norm=...):\\n ...\",\n \"def apply(self, func, *args):\\n pass\",\n \"def ptwise(self, f):\\n m, n = self.shape\\n for i in range(m):\\n for j in range(n):\\n self[(i, j)] = f(self[(i, j)])\\n return self\",\n \"def apply_along_0_nb(a, apply_func_nb, *args):\\n out = np.empty_like(a, dtype=np.float_)\\n for col in range(a.shape[1]):\\n out[:, col] = apply_func_nb(col, a[:, col], *args)\\n return out\",\n \"def transform(tvec1, rvec1, tvec2, rvec2):\\n op = localToGlobal(np.squeeze(tvec2), np.squeeze(rvec2))\\n tvec3 = []\\n for tvec in tvec1:\\n #tvec = tvec.squeeze()\\n tvec3.append(np.matmul(op, tvec))\\n tvec3 = np.array(tvec3)\\n return tvec3\",\n \"def patternbroadcast(x, broadcastable):\\r\\n rval = Rebroadcast(*[(i, broadcastable[i])\\r\\n for i in xrange(len(broadcastable))])(x)\\r\\n return theano.tensor.opt.apply_rebroadcast_opt(rval)\",\n \"def power_unary(x, n, f):\\n return reduce(lambda g, h: lambda x: g(h(x)), itertools.repeat(f, n))(x)\",\n \"def v(x):\\n return x*x\",\n \"def array_input(f):\\n @wraps(f)\\n def wrapped(self, t):\\n t = np.atleast_1d(t)\\n r = f(self, t)\\n return r\\n return wrapped\",\n \"def tan_inplace(a):\",\n \"def get_vector_b(args):\\n\\treturn [f(arg) for arg in args]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71565306","0.71565306","0.6703871","0.62867755","0.6109641","0.60993487","0.60616183","0.5936452","0.59198844","0.5880423","0.57778794","0.57708","0.5769331","0.57459575","0.57459575","0.5743964","0.5737575","0.5717322","0.57160723","0.5654426","0.56408894","0.5619265","0.5617521","0.55880284","0.554674","0.55447054","0.55409676","0.5529907","0.5506441","0.5482419","0.54789937","0.5477233","0.54537827","0.5453116","0.54364145","0.54308385","0.53974867","0.5373911","0.53677285","0.5357918","0.5353356","0.53034014","0.53002596","0.53002596","0.5300079","0.52894926","0.52592546","0.5242782","0.52400595","0.52203524","0.5216443","0.52103055","0.5192522","0.5173244","0.51719785","0.51655656","0.5136331","0.5125801","0.51214737","0.51196504","0.51191974","0.5117013","0.5110392","0.50978214","0.50896484","0.5078249","0.5076371","0.5073293","0.50686854","0.50641245","0.5044709","0.50441957","0.50380313","0.5033092","0.5019578","0.5018088","0.5017408","0.5008465","0.5005993","0.50011146","0.49978295","0.49957788","0.49928954","0.49906155","0.49885157","0.4971907","0.49513167","0.49500594","0.49473488","0.494626","0.49386913","0.49382588","0.493819","0.49271098","0.49264523","0.49242696","0.49228382","0.49217686","0.49212718","0.4920717"],"string":"[\n \"0.71565306\",\n \"0.71565306\",\n \"0.6703871\",\n \"0.62867755\",\n \"0.6109641\",\n \"0.60993487\",\n \"0.60616183\",\n \"0.5936452\",\n \"0.59198844\",\n \"0.5880423\",\n \"0.57778794\",\n \"0.57708\",\n \"0.5769331\",\n \"0.57459575\",\n \"0.57459575\",\n \"0.5743964\",\n \"0.5737575\",\n \"0.5717322\",\n \"0.57160723\",\n \"0.5654426\",\n \"0.56408894\",\n \"0.5619265\",\n \"0.5617521\",\n \"0.55880284\",\n \"0.554674\",\n \"0.55447054\",\n \"0.55409676\",\n \"0.5529907\",\n \"0.5506441\",\n \"0.5482419\",\n \"0.54789937\",\n \"0.5477233\",\n \"0.54537827\",\n \"0.5453116\",\n \"0.54364145\",\n \"0.54308385\",\n \"0.53974867\",\n \"0.5373911\",\n \"0.53677285\",\n \"0.5357918\",\n \"0.5353356\",\n \"0.53034014\",\n \"0.53002596\",\n \"0.53002596\",\n \"0.5300079\",\n \"0.52894926\",\n \"0.52592546\",\n \"0.5242782\",\n \"0.52400595\",\n \"0.52203524\",\n \"0.5216443\",\n \"0.52103055\",\n \"0.5192522\",\n \"0.5173244\",\n \"0.51719785\",\n \"0.51655656\",\n \"0.5136331\",\n \"0.5125801\",\n \"0.51214737\",\n \"0.51196504\",\n \"0.51191974\",\n \"0.5117013\",\n \"0.5110392\",\n \"0.50978214\",\n \"0.50896484\",\n \"0.5078249\",\n \"0.5076371\",\n \"0.5073293\",\n \"0.50686854\",\n \"0.50641245\",\n \"0.5044709\",\n \"0.50441957\",\n \"0.50380313\",\n \"0.5033092\",\n \"0.5019578\",\n \"0.5018088\",\n \"0.5017408\",\n \"0.5008465\",\n \"0.5005993\",\n \"0.50011146\",\n \"0.49978295\",\n \"0.49957788\",\n \"0.49928954\",\n \"0.49906155\",\n \"0.49885157\",\n \"0.4971907\",\n \"0.49513167\",\n \"0.49500594\",\n \"0.49473488\",\n \"0.494626\",\n \"0.49386913\",\n \"0.49382588\",\n \"0.493819\",\n \"0.49271098\",\n \"0.49264523\",\n \"0.49242696\",\n \"0.49228382\",\n \"0.49217686\",\n \"0.49212718\",\n \"0.4920717\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6002288"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":90595,"cells":{"query":{"kind":"string","value":"Vectorized version of `fn` that accepts arguments of any rank."},"document":{"kind":"string","value":"def vectorized_fn(*args):\n with tf.name_scope(name or 'make_rank_polymorphic'):\n # If we got a single value for core_ndims, tile it across all args.\n core_ndims_structure = (\n core_ndims\n if tf.nest.is_nested(core_ndims)\n else tf.nest.map_structure(lambda _: core_ndims, args))\n\n # Build flat lists of all argument parts and their corresponding core\n # ndims.\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\n flat_args = nest.flatten_up_to(\n core_ndims_structure, args, check_types=False)\n\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\n # values for `core_ndims`). Other args will be passed through to `fn`\n # unmodified.\n (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\n fn,\n arg_structure=core_ndims_structure,\n flat_core_ndims=flat_core_ndims,\n flat_args=flat_args)\n\n # `vectorized_map` requires all inputs to have a single, common batch\n # dimension `[n]`. So we broadcast all input parts to a common\n # batch shape, then flatten it down to a single dimension.\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\n\n vectorized_arg_actual_core_ndims = []\n batch_shapes, core_shapes = [], []\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\n vectorized_arg_core_ndims):\n arg_nd = ps.rank_from_shape(arg_shape)\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\n # `batch_ndims` is always nonnegative.\n actual_core_nd = ps.minimum(arg_nd, core_nd)\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\n\n batch_ndims = arg_nd - actual_core_nd\n batch_ndims_ = tf.get_static_value(batch_ndims)\n if batch_ndims_ is not None:\n batch_shapes.append(arg_shape[:batch_ndims_])\n core_shapes.append(arg_shape[batch_ndims_:])\n else:\n arg_shape = tf.convert_to_tensor(arg_shape)\n batch_shapes.append(arg_shape[:batch_ndims])\n core_shapes.append(arg_shape[batch_ndims:])\n\n # Flatten all of the batch dimensions into one.\n broadcast_batch_shape = (\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\n\n static_n = tf.get_static_value(n)\n if static_n == 1:\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\n result_batch_dims = 0\n batched_result = fn_of_vectorized_args(\n tf.nest.map_structure(\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\n vectorized_args,\n vectorized_arg_actual_core_ndims,\n check_types=False))\n else:\n # Pad all input parts to the common shape, then flatten\n # into the single leading dimension `[n]`.\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\n # when batch rank is static so that we can exploit broadcasting.\n broadcast_vectorized_args = [\n tf.broadcast_to(part, ps.concat(\n [broadcast_batch_shape, core_shape], axis=0))\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\n vectorized_args_with_flattened_batch_dim = [\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\n for (part, core_shape) in zip(\n broadcast_vectorized_args, core_shapes)]\n result_batch_dims = 1\n batched_result = tf.vectorized_map(\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\n\n # Unflatten any `Tensor`s in the result.\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\n result = tf.nest.map_structure(\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\n expand_composites=True)\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper","def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper","def vectorize_inputs(f):\n return lambda args: f(*np.hsplit(args, args.shape[1]))","def fn(x):\n if x.ndim == 1:\n return np.sum(x**2)\n else:\n return np.sum(x**2, axis=1)","def vectorize_method(func):\n @wraps(func)\n def inner(obj, *iargs, **ikwargs):\n\n def functionalized_method(*args, **kwargs):\n return func(obj, *args, **kwargs)\n\n return np.vectorize(functionalized_method, otypes=[np.dtype('c16')])(*iargs, **ikwargs)\n #return np.vectorize(functionalized_method)(*iargs, **ikwargs)\n return inner","def _np_apply_along_axis(func1d, axis: int, arr: np.ndarray) -> np.ndarray:\n\n assert arr.ndim == 2\n assert axis in [0, 1]\n\n if axis == 0:\n result = np.empty(arr.shape[1])\n for i in range(len(result)):\n result[i] = func1d(arr[:, i])\n return result\n\n result = np.empty(arr.shape[0])\n for i in range(len(result)):\n result[i] = func1d(arr[i, :])\n\n return result","def array_map(fn, arrs, n):\n # we shouldn't need a special case for n == 0, but NumPy complains about indexing into a zero-dimensional\n # array a using a[(Ellipsis,)].\n if n == 0:\n return fn(*arrs)\n \n full_shape = tuple(np.array([a.shape[:n] for a in arrs]).max(0))\n result = None\n for full_idx in itertools.product(*map(range, full_shape)):\n inputs = [a[broadcast(full_idx, a.shape[:n]) + (Ellipsis,)] for a in arrs]\n curr = fn(*inputs)\n \n if result is None:\n if type(curr) == tuple:\n result = tuple(np.zeros(full_shape + np.asarray(c).shape) for c in curr)\n else:\n result = np.zeros(full_shape + np.asarray(curr).shape)\n\n if type(curr) == tuple:\n for i, c in enumerate(curr):\n result[i][full_idx + (Ellipsis,)] = c\n else:\n result[full_idx + (Ellipsis,)] = curr\n return result","def n_ary(func):\n def wrapper(x, *args):\n return x if not args else func(x, wrapper(*args))\n return wrapper","def vectorize(self, *args, **kwargs):\n kwargs['add_start'] = False\n kwargs['add_end'] = False\n return TorchRankerAgent.vectorize(self, *args, **kwargs)","def apply_over_rows(func, data, **kwargs):\n\n axis = 1\n cpu_cnt = multiprocessing.cpu_count()\n \n chunks = [(func, axis, split_data, kwargs) for split_data in np.array_split(data, cpu_cnt) if split_data.size > 0]\n\n pool = multiprocessing.Pool()\n map_results = pool.starmap(np_apply_along_axis, chunks)\n \n pool.close()\n pool.join()\n\n return np.concatenate(map_results)","def make_rank_polymorphic(fn, core_ndims, name=None):\n\n def vectorized_fn(*args):\n \"\"\"Vectorized version of `fn` that accepts arguments of any rank.\"\"\"\n with tf.name_scope(name or 'make_rank_polymorphic'):\n # If we got a single value for core_ndims, tile it across all args.\n core_ndims_structure = (\n core_ndims\n if tf.nest.is_nested(core_ndims)\n else tf.nest.map_structure(lambda _: core_ndims, args))\n\n # Build flat lists of all argument parts and their corresponding core\n # ndims.\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\n flat_args = nest.flatten_up_to(\n core_ndims_structure, args, check_types=False)\n\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\n # values for `core_ndims`). Other args will be passed through to `fn`\n # unmodified.\n (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\n fn,\n arg_structure=core_ndims_structure,\n flat_core_ndims=flat_core_ndims,\n flat_args=flat_args)\n\n # `vectorized_map` requires all inputs to have a single, common batch\n # dimension `[n]`. So we broadcast all input parts to a common\n # batch shape, then flatten it down to a single dimension.\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\n\n vectorized_arg_actual_core_ndims = []\n batch_shapes, core_shapes = [], []\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\n vectorized_arg_core_ndims):\n arg_nd = ps.rank_from_shape(arg_shape)\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\n # `batch_ndims` is always nonnegative.\n actual_core_nd = ps.minimum(arg_nd, core_nd)\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\n\n batch_ndims = arg_nd - actual_core_nd\n batch_ndims_ = tf.get_static_value(batch_ndims)\n if batch_ndims_ is not None:\n batch_shapes.append(arg_shape[:batch_ndims_])\n core_shapes.append(arg_shape[batch_ndims_:])\n else:\n arg_shape = tf.convert_to_tensor(arg_shape)\n batch_shapes.append(arg_shape[:batch_ndims])\n core_shapes.append(arg_shape[batch_ndims:])\n\n # Flatten all of the batch dimensions into one.\n broadcast_batch_shape = (\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\n\n static_n = tf.get_static_value(n)\n if static_n == 1:\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\n result_batch_dims = 0\n batched_result = fn_of_vectorized_args(\n tf.nest.map_structure(\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\n vectorized_args,\n vectorized_arg_actual_core_ndims,\n check_types=False))\n else:\n # Pad all input parts to the common shape, then flatten\n # into the single leading dimension `[n]`.\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\n # when batch rank is static so that we can exploit broadcasting.\n broadcast_vectorized_args = [\n tf.broadcast_to(part, ps.concat(\n [broadcast_batch_shape, core_shape], axis=0))\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\n vectorized_args_with_flattened_batch_dim = [\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\n for (part, core_shape) in zip(\n broadcast_vectorized_args, core_shapes)]\n result_batch_dims = 1\n batched_result = tf.vectorized_map(\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\n\n # Unflatten any `Tensor`s in the result.\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\n result = tf.nest.map_structure(\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\n expand_composites=True)\n return result\n\n return vectorized_fn","def n_ary(f):\n def n_ary_fn(x, *args):\n return x if not args else f(x, n_ary_fn(*args))\n return n_ary_fn","def custom_np_function(vector):\n summation = 0\n for item in vector:\n summation += item ** 2\n return summation","def transform(fn):\n def _(vec, dt):\n return np.einsum(\n 'ji,i,ki,k...->j...',\n evecs, fn(evals, dt), evecs, vec, optimize=True)\n\n return _","def vectorize_unpack(args):\n return vectorize(*args)","def vectorize_unpack(args):\n return vectorize(*args)","def _lock_in_non_vectorized_args(fn, arg_structure, flat_core_ndims, flat_args):\n\n # Extract the indices and values of args where core_ndims is not `None`.\n (vectorized_arg_indices,\n vectorized_arg_core_ndims,\n vectorized_args) = [], [], []\n if any(nd is not None for nd in flat_core_ndims):\n vectorized_arg_indices, vectorized_arg_core_ndims, vectorized_args = zip(*[\n (i, nd, tf.convert_to_tensor(t))\n for i, (nd, t) in enumerate(zip(flat_core_ndims, flat_args))\n if nd is not None])\n\n vectorized_arg_index_set = set(vectorized_arg_indices)\n\n def fn_of_vectorized_args(vectorized_args):\n with tf.name_scope('fn_of_vectorized_args'):\n vectorized_args_by_index = dict(\n zip(vectorized_arg_indices, vectorized_args))\n # Substitute the vectorized args into the original argument\n # structure.\n new_args_with_original_structure = tf.nest.pack_sequence_as(\n arg_structure, [vectorized_args_by_index[i]\n if i in vectorized_arg_index_set\n else v for (i, v) in enumerate(flat_args)])\n return tf.nest.map_structure(\n # If `fn` returns any Distribution instances, ensure that their\n # parameter batch shapes are padded to align after vectorization.\n _maybe_rectify_parameter_shapes,\n fn(*new_args_with_original_structure))\n\n return (vectorized_arg_core_ndims,\n vectorized_args,\n fn_of_vectorized_args)","def vectorize(func, processes=1, on_complete=None):\n if processes > 1:\n return __multiprocess_wrapper(func, processes, on_complete)\n else:\n return single_process_wrapper(func, on_complete)","def vecToFunc(vector):\n def f(x):\n f = 0\n for i in range(len(vector)):\n f += vector[i]*x**i\n return f\n return f","def apply_along_1_nb(a, apply_func_nb, *args):\n out = np.empty_like(a, dtype=np.float_)\n for i in range(a.shape[0]):\n out[i, :] = apply_func_nb(i, a[i, :], *args)\n return out","def rank_zero_only(fn):\n\n def wrapped(*args, **kwargs):\n if rank() == 0:\n return fn(*args, **kwargs)\n\n return wrapped","def fn(*args, **kwargs):\n pass","def csr_mulvec_wrap(fn):\n\n @functools.wraps(fn)\n def csr_mul_vector(A, x):\n if A.nnz > 50000 and _NUM_THREAD_WORKERS > 1:\n return par_dot_csr_matvec(A, x)\n else:\n y = fn(A, x)\n if isinstance(x, qarray):\n y = qarray(y)\n return y\n\n return csr_mul_vector","def Generate_Custom(f, n, m):\n return np.fromfunction(np.vectorize(f, otypes=[float]), (n,m))","def vec_apply_cost(self,\n arr: jnp.ndarray,\n axis: bool = 0,\n fn=None) -> jnp.ndarray:\n x, y = (self.x, self.y) if axis == 0 else (self.y, self.x)\n nx, ny = self._norm_x, self._norm_y\n nx, ny = (nx, ny) if axis == 0 else (ny, nx)\n\n applied_cost = jnp.dot(nx, arr).reshape(1, -1)\n applied_cost += ny.reshape(-1, 1) * jnp.sum(arr, axis=0).reshape(1, -1)\n applied_cost += -2.0 * jnp.dot(y, jnp.dot(x.T, arr))\n return fn(applied_cost) if fn else applied_cost","def n_ary(f):\n def n_ary_f(x,*args):\n return x if not args else f(x,n_ary_f(*args))\n return n_ary_f","def basis_fns(n=0):\n return lambda x: np.sum(x ** (n+1), axis=1)","def rank_transform(X):\n return np.apply_along_axis(scipy.stats.rankdata, 0, X)","def make_pbroadcast_function(fn, in_axes, out_axes, out_dtype):\n\n if not isinstance(in_axes, tuple):\n in_axes = (in_axes,)\n\n def pbroadcast_fn(*args):\n nest.assert_shallow_structure(args, in_axes)\n nest.assert_shallow_structure(out_dtype, out_axes)\n map_in_axes = nest.map_structure_up_to(args, canonicalize_axis_name,\n in_axes)\n map_out_axes = nest.map_structure_up_to(out_dtype, canonicalize_axis_name,\n out_axes)\n\n def _pbroadcast_input(out_axes, x, in_axes):\n psum_axes = [\n axis_name for axis_name in out_axes if axis_name not in in_axes\n ]\n return pbroadcast(x, psum_axes)\n\n def _flat_fn_index(i, *args):\n out = fn(*args)\n return tf.nest.flatten(out)[i]\n\n def _flat_fn(*args):\n outputs = []\n for i, out_axis in enumerate(nest.flatten_up_to(out_dtype, map_out_axes)):\n local_args = nest.map_structure_up_to(\n args, functools.partial(_pbroadcast_input, out_axis), args,\n map_in_axes)\n outputs.append(_flat_fn_index(i, *local_args))\n return tf.nest.pack_sequence_as(out_dtype, outputs)\n\n return _flat_fn(*args)\n\n return pbroadcast_fn","def vectorize(self):\n return vectorize(self)","def apply_along_0_nb(a, apply_func_nb, *args):\n out = np.empty_like(a, dtype=np.float_)\n for col in range(a.shape[1]):\n out[:, col] = apply_func_nb(col, a[:, col], *args)\n return out","def _chunk_vmapped_function(vmapped_fun, chunk_size, argnums=0):\n\n if chunk_size is None:\n return vmapped_fun\n\n if isinstance(argnums, int):\n argnums = (argnums,)\n\n def _fun(*args):\n\n n_elements = jax.tree_leaves(args[argnums[0]])[0].shape[0]\n n_chunks, n_rest = divmod(n_elements, chunk_size)\n\n if n_chunks == 0 or chunk_size >= n_elements:\n y = vmapped_fun(*args)\n else:\n # split inputs\n def _get_chunks(x):\n x_chunks = jax.tree_map(lambda x_: x_[: n_elements - n_rest, ...], x)\n x_chunks = _chunk(x_chunks, chunk_size)\n return x_chunks\n\n def _get_rest(x):\n x_rest = jax.tree_map(lambda x_: x_[n_elements - n_rest :, ...], x)\n return x_rest\n\n args_chunks = [\n _get_chunks(a) if i in argnums else a for i, a in enumerate(args)\n ]\n args_rest = [\n _get_rest(a) if i in argnums else a for i, a in enumerate(args)\n ]\n\n y_chunks = _unchunk(\n scanmap(vmapped_fun, scan_append, argnums)(*args_chunks)\n )\n\n if n_rest == 0:\n y = y_chunks\n else:\n y_rest = vmapped_fun(*args_rest)\n y = jax.tree_map(\n lambda y1, y2: jnp.concatenate((y1, y2)), y_chunks, y_rest\n )\n return y\n\n return _fun","def _fn(dtype, shape, name, trainable, add_variable_fn):\n loc, scale = loc_scale_fn_(dtype, shape, name, trainable, add_variable_fn)\n if scale is None:\n dist = deterministic_lib.Deterministic(loc=loc)\n else:\n dist = normal_lib.Normal(loc=loc, scale=scale)\n reinterpreted_batch_ndims = array_ops.shape(dist.batch_shape_tensor())[0]\n return independent_lib.Independent(\n dist, reinterpreted_batch_ndims=reinterpreted_batch_ndims)","def apply_fn(self,fn):\r\n \r\n self.check_Data()\r\n for split,data_ in self.processed_data.items():\r\n x = data_['x']\r\n x = np.array([fn(xi) for xi in x])\r\n data_['x'] = x","def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\n axis = check_axes(axis)\n if len(axis) == x.ndim:\n return func(x)\n\n other_axes = negate_indices(axis, x.ndim)\n begin = np.arange(len(other_axes))\n\n y = np.moveaxis(x, other_axes, begin)\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)","def evaluate_1darray_function_on_2d_array(function, samples, opts=None):\n num_args = get_num_args(function)\n assert samples.ndim == 2\n num_samples = samples.shape[1]\n if num_args == 2:\n values_0 = function(samples[:, 0], opts)\n else:\n values_0 = function(samples[:, 0])\n values_0 = np.atleast_1d(values_0)\n assert values_0.ndim == 1\n num_qoi = values_0.shape[0]\n values = np.empty((num_samples, num_qoi), float)\n values[0, :] = values_0\n for i in range(1, num_samples):\n if num_args == 2:\n values[i, :] = function(samples[:, i], opts)\n else:\n values[i, :] = function(samples[:, i])\n\n return values","def with_numpy(func):\r\n return func","def RunningFunc(x, N, func=np.nanmedian, loc='middle'):\n\n if len(x)<N+1:\n return np.ones(len(x))*func(x)\n \n result = np.zeros(len(x))\n \n idx = np.arange(N) + np.arange(len(x)-N+1)[:,None]\n b = [row[row>0] for row in x[idx]]\n \n if loc == 'middle':\n start = int(N/2)\n elif loc == 'right':\n start = 0\n else:\n start = int(N)\n\n result[start:start+len(idx)] = np.array([func(c) for c in b])\n result[:start] = result[int(N/2)-1]\n result[start+len(idx):] = result[-int(N/2)-1]\n\n return result","def apply(self, func, *args):\n pass","def specialize_arr_arr_element_wise(func):\n\n func_name_capital = ''.join(x.capitalize() or '_' for x in func.__name__.split('_'))\n num_func_args = len(inspect.getargspec(func).args)\n assert num_func_args == 2, \\\n \"Element-wise operations must take exactly two arguments; {0} given\".format(num_func_args)\n\n return LazyElemWiseArrayArrayOp.from_function(func, \"ElemArrayArrayOp\" + func_name_capital)","def array_input(f):\n @wraps(f)\n def wrapped(self, t):\n t = np.atleast_1d(t)\n r = f(self, t)\n return r\n return wrapped","def __call__(self, *args):\n if isinstance(args[0], (float, int, complex)):\n # scalar version:\n return self.constant\n else:\n # vectorized version:\n r = args[0].copy()\n # to get right dimension of the return array,\n # compute with args in a simple formula (sum of args)\n for a in args[1:]:\n r = r + a # in-place r+= won't work\n # (handles x,y,t - the last t just adds a constant)\n r[:] = self.constant\n return r","def numpyfunc(*args, **kwargs):\n def _decorator(func):\n return numpy.frompyfunc(func, *args, **kwargs)\n return _decorator","def function(fnc, *args, **kwargs):\n return Function(fnc, args=args, kwargs=kwargs).tunable()","def operate_on_narray(x, y, function):\n try:\n return [operate_on_narray(a, b, function) for a, b in zip(x, y)]\n # except TypeError as e:\n except TypeError:\n # Not iterable\n return function(x, y)","def vectorize(sch, tensor, vectorize_limit):\n inner_axis = s[tensor].op.axis[len(s[tensor].op.axis) - 1]\n inner_length = tensor.shape[len(tensor.shape) - 1].value\n if inner_length <= vectorize_limit:\n sch[tensor].vectorize(inner_axis)\n else:\n split_factor = 1\n for i in range(vectorize_limit, 1, -1):\n if inner_length % i == 0:\n split_factor = i\n break\n if split_factor > 1:\n _, inner_i = sch[tensor].split(inner_axis, split_factor)\n sch[tensor].vectorize(inner_i)","def _scal_elemwise_with_nfunc(nfunc, nin, nout):\r\n def construct(symbol):\r\n symbolname = symbol.__name__\r\n inplace = symbolname.endswith('_inplace')\r\n if inplace:\r\n msg = \"inplace\"\r\n else:\r\n msg = \"no_inplace\"\r\n\r\n n = \"Elemwise{%s,%s}\" % (symbolname, msg)\r\n\r\n if inplace:\r\n scalar_op = getattr(scal, symbolname[:-len('_inplace')])\r\n inplace_scalar_op = scalar_op.__class__(scal.transfer_type(0))\r\n rval = elemwise.Elemwise(inplace_scalar_op, {0: 0}, name=n,\r\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\r\n else:\r\n scalar_op = getattr(scal, symbolname)\r\n rval = elemwise.Elemwise(scalar_op, name=n,\r\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\r\n\r\n if getattr(symbol, '__doc__', False):\r\n rval.__doc__ = symbol.__doc__ + '\\n' + rval.__doc__\r\n\r\n # for the meaning of this see the ./epydoc script\r\n # it makes epydoc display rval as if it were a function, not an object\r\n rval.__epydoc_asRoutine = symbol\r\n rval.__module__ = 'tensor'\r\n\r\n pprint.assign(rval, printing.FunctionPrinter(symbolname))\r\n\r\n return rval\r\n return construct","def n_ary(n, f):\n if n < 0:\n raise ValueError(\"First argument to n_ary must be a non-negative integer\")\n\n args1, args2 = generate_args(inspect.getfullargspec(f), n)\n\n return eval(\"lambda \" + args1 + \": f(\" + args2 + \")\", {\"f\": f})","def apply(self, vec):\n raise NotImplementedError","def helper_fitness(chromosome_fitness_function):\n def fitness_function(population):\n return np.apply_along_axis(chromosome_fitness_function, 1, population)\n return fitness_function","def vectorize(features, vocab):\n vec = lil_matrix((1, len(vocab)))\n for feat in features:\n try:\n fidx = vocab[feat]\n vec[0, fidx] += 1.0\n except KeyError:\n pass\n return vec","def pytorch_func(function):\n def wrapper(self, *args, **kwargs):\n \"\"\" Evaluate function, Assign arugments and keyword arguments to a\n Pytorch function and return it as a numpy array.\n\n Args: \n *args: argument\n **kwargs: keyword arguments\n Return\n (np.array): output of function Tensor converted to numpy array\"\"\"\n torch_args = [torch.tensor(arg, requires_grad=True, dtype=torch.float64) if type(arg) is ndarray else arg for arg in args]\n torch_kwargs = {key: torch.tensor(kwarg, requires_grad=True, dtype=torch.float64) if type(kwarg) is ndarray else kwarg for key, kwarg in kwargs.items()}\n result = function(self, *torch_args, **torch_kwargs)\n return result.cpu().detach().numpy()\n return wrapper","def _compute_R1_from_vector(n, ind_mat, vec):\r\n\r\n R1 = 0\r\n for l in range(n):\r\n R1 += np.sum((2*ind_mat[:, l]+1) * vec**2)\r\n\r\n return R1","def map_fn(fn, elems, dtype=None, parallel_iterations=None, back_prop=True,\n swap_memory=False, infer_shape=True, name=None):\n if not callable(fn):\n raise TypeError(\"fn must be callable.\")\n\n if isinstance(elems, sparse_tensor.SparseTensor):\n raise TypeError(\n \"To perform a map on the values of a sparse tensor use either \"\n \" SparseTensor(input.indices, fn(input.values), input.dense_shape) or \"\n \" SparseTensor(input.indices, map_fn(fn, input.values), \"\n \"input.dense_shape)\")\n\n in_graph_mode = not context.executing_eagerly()\n # Set the default number of parallel_iterations depending on graph/eager mode.\n if in_graph_mode and not parallel_iterations:\n parallel_iterations = 10\n elif not in_graph_mode and not parallel_iterations:\n parallel_iterations = 1\n\n if not in_graph_mode and parallel_iterations > 1:\n logging.log_first_n(logging.WARN, \"Setting parallel_iterations > 1 has no \"\n \"effect when executing eagerly. Consider calling map_fn\"\n \" with tf.contrib.eager.defun to execute fn in \"\n \"parallel.\", 1)\n parallel_iterations = 1\n\n input_is_sequence = nest.is_sequence(elems)\n input_flatten = lambda x: nest.flatten(x) if input_is_sequence else [x]\n def input_pack(x):\n return nest.pack_sequence_as(elems, x) if input_is_sequence else x[0]\n\n if dtype is None:\n output_is_sequence = input_is_sequence\n output_flatten = input_flatten\n output_pack = input_pack\n else:\n output_is_sequence = nest.is_sequence(dtype)\n output_flatten = lambda x: nest.flatten(x) if output_is_sequence else [x]\n def output_pack(x):\n return (nest.pack_sequence_as(dtype, x)\n if output_is_sequence else x[0])\n\n elems_flat = input_flatten(elems)\n\n with ops.name_scope(name, \"map\", elems_flat):\n # TODO(akshayka): Remove the in_graph_mode check once caching devices are\n # supported in Eager\n if in_graph_mode:\n # Any get_variable calls in fn will cache the first call locally\n # and not issue repeated network I/O requests for each iteration.\n varscope = vs.get_variable_scope()\n varscope_caching_device_was_none = False\n if varscope.caching_device is None:\n # TODO(ebrevdo): Change to using colocate_with here and in other\n # methods.\n varscope.set_caching_device(lambda op: op.device)\n varscope_caching_device_was_none = True\n\n elems_flat = [\n ops.convert_to_tensor(elem, name=\"elem\") for elem in elems_flat]\n\n dtype = dtype or input_pack([elem.dtype for elem in elems_flat])\n dtype_flat = output_flatten(dtype)\n\n # Convert elems to tensor array. n may be known statically.\n static_shape = elems_flat[0].shape\n if static_shape.ndims is not None and static_shape.ndims < 1:\n if len(elems_flat) == 1:\n raise ValueError(\"elems must be a 1+ dimensional Tensor, not a scalar\")\n else:\n raise ValueError(\n \"elements in elems must be 1+ dimensional Tensors, not scalars\"\n )\n n = (tensor_shape.dimension_value(static_shape[0])\n or array_ops.shape(elems_flat[0])[0])\n\n # TensorArrays are always flat\n elems_ta = [\n tensor_array_ops.TensorArray(dtype=elem.dtype,\n size=n,\n dynamic_size=False,\n infer_shape=True)\n for elem in elems_flat]\n # Unpack elements\n elems_ta = [\n elem_ta.unstack(elem) for elem_ta, elem in zip(elems_ta, elems_flat)]\n\n i = constant_op.constant(0)\n\n accs_ta = [\n tensor_array_ops.TensorArray(dtype=dt,\n size=n,\n dynamic_size=False,\n infer_shape=infer_shape)\n for dt in dtype_flat]\n\n def compute(i, tas):\n \"\"\"The loop body of map_fn.\n\n Args:\n i: the loop counter\n tas: the flat TensorArray accumulator list\n\n Returns:\n (i + 1, tas): the updated counter + updated TensorArrays\n\n Raises:\n TypeError: if dtype and packed_fn_values structure do not match\n ValueType: if dtype and packed_fn_values lengths do not match\n \"\"\"\n packed_values = input_pack([elem_ta.read(i) for elem_ta in elems_ta])\n packed_fn_values = fn(packed_values)\n nest.assert_same_structure(dtype or elems, packed_fn_values)\n flat_fn_values = output_flatten(packed_fn_values)\n tas = [ta.write(i, value) for (ta, value) in zip(tas, flat_fn_values)]\n return (i + 1, tas)\n\n _, r_a = control_flow_ops.while_loop(\n lambda i, _: i < n, compute, (i, accs_ta),\n parallel_iterations=parallel_iterations,\n back_prop=back_prop,\n swap_memory=swap_memory,\n maximum_iterations=n)\n results_flat = [r.stack() for r in r_a]\n\n n_static = tensor_shape.Dimension(tensor_shape.dimension_value(\n elems_flat[0].get_shape().with_rank_at_least(1)[0]))\n for elem in elems_flat[1:]:\n n_static.merge_with(tensor_shape.Dimension(tensor_shape.dimension_value(\n elem.get_shape().with_rank_at_least(1)[0])))\n for r in results_flat:\n r.set_shape(tensor_shape.TensorShape(n_static).concatenate(\n r.get_shape()[1:]))\n\n # TODO(akshayka): Remove the in_graph_mode check once caching devices are\n # supported in Eager\n if in_graph_mode and varscope_caching_device_was_none:\n varscope.set_caching_device(None)\n\n return output_pack(results_flat)","def apply_function(f, args):\n if len(signature(f).parameters) == len(args):\n func = curry(f)\n for arg_value in args:\n func = func(arg_value)\n return func()\n else:\n raise Exception(\"the number of function's parameter is not matched args, len(args): \", len(args))","def vectorize_par(\n f: Callable, inputs: Iterable,\n pool: Pool = None, processes=None, chunksize=1,\n nout=None, otypes: Union[Sequence[Type], Type] = None,\n use_starmap=True, meshgrid_input=True,\n) -> Tuple[Union[Mapping[Any, Any], np.ndarray, Sequence[Any]], ...]:\n if isinstance(inputs, dict):\n raise NotImplementedError()\n # s = dict(signature(f).parameters)\n # ks, ds = zip(*[(k, v.default) for k, v in s.items()])\n # inputs = [inputs[k] if k in inputs else arrayobj1d([d]) for k, d in zip(ks, ds)]\n\n if meshgrid_input:\n inputs = [\n inp if (isinstance(inp, np.ndarray) and type(inp[0]) is object)\n else (arrayobj1d(inp) if is_iter(inp)\n else arrayobj1d([inp]))\n for inp in inputs]\n shape0 = [len(inp) for inp in inputs]\n mesh_inputs = np.meshgrid(*inputs, indexing='ij') # type: Iterable[np.ndarray]\n else:\n inputs = [arrayobj1d([inp]) if not is_iter(inp) else inp for inp in inputs]\n shape0 = broadcast_shapes(*[npy(v).shape for v in inputs])\n mesh_inputs = [np.broadcast_to(v, shape0) for v in inputs]\n mesh_inputs = [m.flatten() for m in mesh_inputs]\n\n m = zip(*mesh_inputs)\n m = [m1 for m1 in m]\n\n if pool is None:\n pool = Pool(processes=processes) # type: PoolParallel\n\n # if processes == 0:\n # use_starmap = False\n\n if chunksize is None:\n # NOTE: this doesn't seem to work well, unlike chunksize=1.\n # Need further experiment.\n chunksize = np.max([\n int(np.floor(np.prod(shape0) / pool._processes)),\n 1\n ])\n\n if use_starmap:\n try:\n outs = pool.starmap(f, m, chunksize=chunksize)\n except EOFError:\n print('EOFError from starmap! Trying again..')\n # Just try again - this seems to fix the issue\n try:\n outs = pool.starmap(f, m, chunksize=chunksize)\n except EOFError:\n print('EOFError again after trying again.. '\n 'Not trying again this time.')\n raise\n else:\n outs = pool.map(f, m, chunksize=chunksize)\n\n if nout is None:\n if otypes is not None and is_sequence(otypes):\n nout = len(otypes)\n else:\n try:\n nout = len(outs[0])\n except TypeError:\n nout = 1\n\n if otypes is None:\n otypes = [object] * nout\n elif not is_sequence(type(otypes)):\n otypes = [otypes] * nout\n\n # NOTE: deliberately keeping outs, outs1, and outs2 for debugging.\n # After confirming everything works well, rename all to \"outs\"\n # to save memory.\n # DEF: outs1[argout][i_input_flattened]\n if nout > 1:\n outs1 = zip(*outs)\n else:\n if use_starmap:\n outs1 = [outs]\n else:\n # Reverse the action of map() putting each output in a list\n outs1 = [[out1[0] for out1 in outs]]\n\n # --- outs2: reshape to inputs' dimensions\n # DEF: outs2[argout][i_input1, i_input2, ...]\n outs2 = [arrayobj1d(out).reshape(shape0) for out in outs1]\n\n # --- outs3: set to a correct otype\n # DEF: outs3[argout][i_input1, i_input2, ...]\n outs3 = [cell2mat(out, otype) if otype not in [object, object]\n else out\n for out, otype in zip(outs2, otypes)]\n return tuple(outs3)","def wrapper(self, *args, **kwargs):\n torch_args = [torch.tensor(arg, requires_grad=True, dtype=torch.float64) if type(arg) is ndarray else arg for arg in args]\n torch_kwargs = {key: torch.tensor(kwarg, requires_grad=True, dtype=torch.float64) if type(kwarg) is ndarray else kwarg for key, kwarg in kwargs.items()}\n result = function(self, *torch_args, **torch_kwargs)\n return result.cpu().detach().numpy()","def as_numpy(fn):\n\n def metric_fn(y_true, y_pred):\n if isinstance(y_true, (pd.Series, pd.DataFrame)):\n new_y_true = y_true.values\n elif isinstance(y_true, np.ndarray):\n new_y_true = y_true\n else:\n new_y_true = y_true.numpy()\n if isinstance(y_pred, (pd.Series, pd.DataFrame)):\n new_y_pred = y_pred.values\n elif isinstance(y_pred, np.ndarray):\n new_y_pred = y_pred\n else:\n new_y_pred = y_pred.numpy()\n if new_y_true.ndim == 1:\n new_y_true = np.expand_dims(new_y_true, 1)\n if new_y_pred.ndim == 1:\n new_y_pred = np.expand_dims(new_y_pred, 1)\n return fn(new_y_true, new_y_pred)\n return metric_fn","def lambda_fun(funk, x):\n # input must be 1d numpy.ndarray\n assert isinstance(x, np.ndarray) and x.ndim == 1\n\n # result from the lambdified function with array input\n abo = funk(x)\n\n if isinstance(abo, float):\n abo = np.array([[abo]])\n\n if abo.ndim < 3:\n # reshaping from (n,1) to (n,)\n abo = abo.reshape(abo.shape[0])\n\n # fix the term not properly broadcasted in the lambdified funtion\n abo_fix = np.array(np.broadcast_arrays(x, *abo)[1:])\n\n elif abo.ndim == 3:\n abo_fix = abo.reshape(abo.shape[0], -1)\n\n # roll the axis to obtain an array of matrix, and not a matrix of arrays\n abo_fix = np.moveaxis(abo_fix, -1, 0)\n\n return abo_fix","def generate_numba_apply_func(\n func: Callable[..., Scalar],\n nopython: bool,\n nogil: bool,\n parallel: bool,\n):\n numba_func = jit_user_function(func)\n if TYPE_CHECKING:\n import numba\n else:\n numba = import_optional_dependency(\"numba\")\n\n @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)\n def roll_apply(\n values: np.ndarray,\n begin: np.ndarray,\n end: np.ndarray,\n minimum_periods: int,\n *args: Any,\n ) -> np.ndarray:\n result = np.empty(len(begin))\n for i in numba.prange(len(result)):\n start = begin[i]\n stop = end[i]\n window = values[start:stop]\n count_nan = np.sum(np.isnan(window))\n if len(window) - count_nan >= minimum_periods:\n result[i] = numba_func(window, *args)\n else:\n result[i] = np.nan\n return result\n\n return roll_apply","def apply(self, func, *args, **kwargs):\n pass","def _wrapper(func, args):\n return func(*args)","def n_ary(f):\n #def n_ary_f(x, *args):\n #if len(args) == 0:\n #return x\n #return f(x,n_ary_f(args[0],*args[1:]))\n def n_ary_f(x, *args):\n return x if not args else f(x,n_ary_f(*args))\n return n_ary_f","def process_in_chunks(function, *args, batch_size, out=None, **kwargs):\n total_size = args[0].shape[0]\n first_output = function(*[x[0: batch_size] for x in args])\n output_shape = (total_size,) + tuple(first_output.shape[1:])\n if out is None:\n out = torch.zeros(*output_shape, dtype=first_output.dtype, device=first_output.device,\n layout=first_output.layout, **kwargs)\n\n out[0: batch_size] = first_output\n for i in range(batch_size, total_size, batch_size):\n batch_ix = slice(i, min(i + batch_size, total_size))\n out[batch_ix] = function(*[x[batch_ix] for x in args])\n return out","def f(x):\n n_particles = x.shape[0]\n j = [f_per_particle(x[i]) for i in range(n_particles)]\n #print(\"f j: \", j)\n return np.array(j)","def map(self, f_list: List[Callable[[np.ndarray], int]], axis: int = 0, chunksize: int = 1000, selection: np.ndarray = None) -> List[np.ndarray]:\n\t\tif hasattr(f_list, '__call__'):\n\t\t\traise ValueError(\"f_list must be a list of functions, not a function itself\")\n\n\t\tresult = []\n\t\tif axis == 0:\n\t\t\trows_per_chunk = chunksize\n\t\t\tfor i in range(len(f_list)):\n\t\t\t\tresult.append(np.zeros(self.shape[0]))\n\t\t\tix = 0\n\t\t\twhile ix < self.shape[0]:\n\t\t\t\trows_per_chunk = min(self.shape[0] - ix, rows_per_chunk)\n\t\t\t\tif selection is not None:\n\t\t\t\t\tchunk = self[ix:ix + rows_per_chunk, :][:, selection]\n\t\t\t\telse:\n\t\t\t\t\tchunk = self[ix:ix + rows_per_chunk, :]\n\t\t\t\tfor i in range(len(f_list)):\n\t\t\t\t\tresult[i][ix:ix + rows_per_chunk] = np.apply_along_axis(f_list[i], 1, chunk)\n\t\t\t\tix = ix + rows_per_chunk\n\t\telif axis == 1:\n\t\t\tcols_per_chunk = chunksize\n\t\t\tfor i in range(len(f_list)):\n\t\t\t\tresult.append(np.zeros(self.shape[1]))\n\t\t\tix = 0\n\t\t\twhile ix < self.shape[1]:\n\t\t\t\tcols_per_chunk = min(self.shape[1] - ix, cols_per_chunk)\n\t\t\t\tif selection is not None:\n\t\t\t\t\tchunk = self[:, ix:ix + cols_per_chunk][selection, :]\n\t\t\t\telse:\n\t\t\t\t\tchunk = self[:, ix:ix + cols_per_chunk]\n\t\t\t\tfor i in range(len(f_list)):\n\t\t\t\t\tresult[i][ix:ix + cols_per_chunk] = np.apply_along_axis(f_list[i], 0, chunk)\n\t\t\t\tix = ix + cols_per_chunk\n\t\treturn result","def multichannel(fcn):\n return lambda args: (fcn(*args), )","def squared_call(fn, arg):\n return fn(fn(arg))","def _scalar_vectorized(scalar, M):\n return scalar[:, np.newaxis, np.newaxis]*M","def apply(self, fn, column_label):\n return [fn(v) for v in self[column_label]]","def scoped_fn(fn: Callable[..., U]) -> Callable[..., U]:\n @functools.wraps(fn)\n def wrapper(*args: Any, **kwargs: Any) -> Any:\n with tf.variable_scope(fn.__name__):\n return fn(*args, **kwargs)\n\n return wrapper","def wrapper(*args, **kwargs):\n return fn(*args, **kwargs)","def vectorized_rounder():\n\n def f(num):\n if np.isnan(num):\n return np.nan\n else:\n return num // 10 ** (int(math.log(num, 10)))\n\n vf = np.vectorize(f)\n\n return(vf)","def rolling_apply_matrix_nb(a, window, apply_func_nb, *args):\n out = np.empty_like(a, dtype=np.float_)\n for i in range(a.shape[0]):\n window_a = a[max(0, i + 1 - window):i + 1, :]\n out[i, :] = apply_func_nb(i, window_a, *args)\n return out","def sp_mulvec_wrap(fn):\n\n @functools.wraps(fn)\n def qarrayed_fn(self, other):\n out = fn(self, other)\n if isinstance(other, qarray):\n out = qarray(out)\n return out\n\n return qarrayed_fn","def apply(df, f):\n return [f(row) for row in df]","def as_args(function):\n return lambda x: function(*x)","def __array_function__(self, func, types, args, kwargs):\n try:\n if not func.__module__.startswith(\"numpy\"):\n return NotImplemented\n except AttributeError:\n return NotImplemented\n _args = list(map(MetaTensor._convert, args))\n _kwargs = {k: MetaTensor._convert(v) for k, v in kwargs.items()}\n return func(*_args, **_kwargs)","def _apply_cost_to_vec(\n self, vec: jnp.ndarray, axis: int = 0, fn=None\n ) -> jnp.ndarray:\n vec = jnp.reshape(vec, self.grid_size)\n accum_vec = jnp.zeros_like(vec)\n indices = list(range(1, self.grid_dimension))\n for dimension, geom in enumerate(self.geometries):\n cost = geom.cost_matrix\n ind = indices.copy()\n ind.insert(dimension, 0)\n if axis == 0:\n cost = cost.T\n accum_vec += jnp.sum(\n jnp.tensordot(cost, vec, axes=([0], [dimension])),\n axis=indices,\n keepdims=True\n ).transpose(ind)\n return accum_vec.ravel()","def a(a,N): \n a=np.ravel(a, order='F') # Same order\n return a","def a(a,N): \n a=np.ravel(a, order='F') # Same order\n return a","def __call__(self, _x: np.ndarray) -> np.ndarray:\n return self.function(_x)","def expand_apply(f, axis=0):\n if axis not in [0, -1]:\n raise ValueError(\"expand_apply currently only supports axis=0 or axis=-1.\")\n\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n expand = lambda t: jnp.expand_dims(t, axis=axis)\n args = jax.tree_map(expand, args)\n kwargs = jax.tree_map(expand, kwargs)\n outputs = f(*args, **kwargs)\n return jax.tree_map(lambda t: jnp.squeeze(t, axis=axis), outputs)\n\n return wrapper","def batchify(fn, chunk):\n if chunk is None:\n return fn\n\n def ret(inputs, styles, alpha, feature):\n results = []\n for i in range(0, inputs.shape[0], chunk):\n input_chunk = inputs[i:i + chunk]\n style_chunk = styles[i:i + chunk]\n alpha_chunk = alpha[i:i + chunk] if alpha is not None else None\n feature_chunk = feature[i:i + chunk] if feature is not None else None\n results.append(fn(input_chunk, style_chunk, alpha_chunk, feature_chunk))\n return torch.cat(results, 0)\n return ret","def apply_and_reduce_nb(a, apply_func_nb, apply_args, reduce_func_nb, reduce_args):\n out = np.full(a.shape[1], np.nan, dtype=np.float_)\n\n for col in range(a.shape[1]):\n mapped = apply_func_nb(col, a[:, col], *apply_args)\n out[col] = reduce_func_nb(col, mapped, *reduce_args)\n return out","def benchmarkNFunc(iter, ns):\n def decorator(func):\n for n in ns:\n benchmarkFuncs.append((func, (n,), iter))\n return func\n return decorator","def vmap_chunked(f: Callable, in_axes=0, *, chunk_size: Optional[int]):\n if isinstance(in_axes, int):\n in_axes = (in_axes,)\n\n if not set(in_axes).issubset((0, None)):\n raise NotImplementedError(\"Only in_axes 0/None are currently supported\")\n\n argnums = tuple(\n map(lambda ix: ix[0], filter(lambda ix: ix[1] is not None, enumerate(in_axes)))\n )\n\n vmapped_fun = jax.vmap(f, in_axes=in_axes)\n\n return _chunk_vmapped_function(vmapped_fun, chunk_size, argnums)","def integrate_monte_carlo_nd(f, dim, limit, N=1000000):\n I, sum = 1/N, 0\n for n in range(dim):\n I *= (limit[n][1] - limit[n][0])\n\n for k in range(N):\n x = []\n for n in range(dim):\n x += [limit[n][0] + (limit[n][1] - limit[n][0])*rnd.random()]\n\n sum += f(x)\n return I*sum","def nkron(*args):\n return reduce(np.kron, args, np.array([1]))","def _sklearn_reshape_apply(func, return_result, X, *args, **kwargs):\n if not isinstance(X, np.ndarray):\n raise ValueError(\"data should be an np.ndarray, got %s.\" % type(X))\n orig_shape = X.shape\n X = np.reshape(X.transpose(0, 2, 1), (-1, orig_shape[1]))\n X = func(X, *args, **kwargs)\n if return_result:\n X.shape = (orig_shape[0], orig_shape[2], orig_shape[1])\n X = X.transpose(0, 2, 1)\n return X","def rng_fn_scipy(cls, rng, *args, **kwargs):","def repeat_n_times(n, fn, *args, **kwargs):\n if args:\n my_args = _transpose_list_of_lists(\n [_maybe_repeat(arg, n) for arg in args])\n else:\n my_args = [[] for _ in range(n)]\n my_kwargs = [{} for _ in range(n)]\n for k, v in six.iteritems(kwargs):\n vals = _maybe_repeat(v, n)\n for i in range(n):\n my_kwargs[i][k] = vals[i]\n\n # construct lists of functions\n fns = _maybe_repeat(fn, n)\n outputs = [fns[i](*my_args[i], **my_kwargs[i]) for i in range(n)]\n if isinstance(outputs[0], tuple):\n outputs = list(zip(*outputs))\n outputs = tuple([list(o) for o in outputs])\n return outputs","def make_psum_function(fn, in_axes, out_axes, out_dtype):\n\n out_axes = nest.map_structure_up_to(out_dtype, canonicalize_axis_name,\n out_axes)\n\n def psum_fn(*args):\n out = make_pbroadcast_function(fn, in_axes, out_axes, out_dtype)(*args)\n\n def _psum_output(x, out_axis):\n return psum(x, out_axis)\n\n return nest.map_structure_up_to(out_dtype, _psum_output, out, out_axes)\n\n return psum_fn","def lambda_fn(ds, fn):\n logger.info(\"Applying function '%s' on dataset.\", str(fn))\n return fn(ds)","def __call__(self, x, *args, **kwargs):\n joined_kwargs = dict(self.kwargs)\n joined_kwargs.update(kwargs)\n x = np.asarray(x)\n return Function.__call__(self, x, *(args + self.args),\n **joined_kwargs)","def run_in_thread(fn):\n def run(*k, **kw):\n t = threading.Thread(target=fn, args=k, kwargs=kw)\n t.start()\n return t\n return run","def run_in_thread(fn):\n def run(*k, **kw):\n t = threading.Thread(target=fn, args=k, kwargs=kw)\n t.start()\n return t\n return run","def _call_numpy(func, args, kwargs):\n\n numpy_args, numpy_kwargs = data_transfer._get_numpy_args(args, kwargs)\n\n numpy_res = func(*numpy_args, **numpy_kwargs)\n\n cupy_res = data_transfer._get_cupy_result(numpy_res)\n\n return cupy_res","def _call_n(x, f, n, *args, **kwargs):\n return [f(i, x, *args, **kwargs) for i in range(n)]","def minibatched_call(fn, mbsize, *args, **kwargs):\n tensor_list, _ = tree_util.tree_flatten((args, kwargs))\n batchsize = tensor_list[0].shape[0]\n mbs = [\n fn(*tree_slice(args, inds), **tree_slice(kwargs, inds))\n for inds in th.arange(batchsize).split(mbsize)\n ]\n return tree_cat(mbs, dim=0)"],"string":"[\n \"def autovectorized(f):\\r\\n def wrapper(input):\\r\\n if N.isscalar(input)==False:\\r\\n return N.vectorize(f)(input)\\r\\n return f(input)\\r\\n return wrapper\",\n \"def autovectorized(f):\\r\\n def wrapper(input):\\r\\n if N.isscalar(input)==False:\\r\\n return N.vectorize(f)(input)\\r\\n return f(input)\\r\\n return wrapper\",\n \"def vectorize_inputs(f):\\n return lambda args: f(*np.hsplit(args, args.shape[1]))\",\n \"def fn(x):\\n if x.ndim == 1:\\n return np.sum(x**2)\\n else:\\n return np.sum(x**2, axis=1)\",\n \"def vectorize_method(func):\\n @wraps(func)\\n def inner(obj, *iargs, **ikwargs):\\n\\n def functionalized_method(*args, **kwargs):\\n return func(obj, *args, **kwargs)\\n\\n return np.vectorize(functionalized_method, otypes=[np.dtype('c16')])(*iargs, **ikwargs)\\n #return np.vectorize(functionalized_method)(*iargs, **ikwargs)\\n return inner\",\n \"def _np_apply_along_axis(func1d, axis: int, arr: np.ndarray) -> np.ndarray:\\n\\n assert arr.ndim == 2\\n assert axis in [0, 1]\\n\\n if axis == 0:\\n result = np.empty(arr.shape[1])\\n for i in range(len(result)):\\n result[i] = func1d(arr[:, i])\\n return result\\n\\n result = np.empty(arr.shape[0])\\n for i in range(len(result)):\\n result[i] = func1d(arr[i, :])\\n\\n return result\",\n \"def array_map(fn, arrs, n):\\n # we shouldn't need a special case for n == 0, but NumPy complains about indexing into a zero-dimensional\\n # array a using a[(Ellipsis,)].\\n if n == 0:\\n return fn(*arrs)\\n \\n full_shape = tuple(np.array([a.shape[:n] for a in arrs]).max(0))\\n result = None\\n for full_idx in itertools.product(*map(range, full_shape)):\\n inputs = [a[broadcast(full_idx, a.shape[:n]) + (Ellipsis,)] for a in arrs]\\n curr = fn(*inputs)\\n \\n if result is None:\\n if type(curr) == tuple:\\n result = tuple(np.zeros(full_shape + np.asarray(c).shape) for c in curr)\\n else:\\n result = np.zeros(full_shape + np.asarray(curr).shape)\\n\\n if type(curr) == tuple:\\n for i, c in enumerate(curr):\\n result[i][full_idx + (Ellipsis,)] = c\\n else:\\n result[full_idx + (Ellipsis,)] = curr\\n return result\",\n \"def n_ary(func):\\n def wrapper(x, *args):\\n return x if not args else func(x, wrapper(*args))\\n return wrapper\",\n \"def vectorize(self, *args, **kwargs):\\n kwargs['add_start'] = False\\n kwargs['add_end'] = False\\n return TorchRankerAgent.vectorize(self, *args, **kwargs)\",\n \"def apply_over_rows(func, data, **kwargs):\\n\\n axis = 1\\n cpu_cnt = multiprocessing.cpu_count()\\n \\n chunks = [(func, axis, split_data, kwargs) for split_data in np.array_split(data, cpu_cnt) if split_data.size > 0]\\n\\n pool = multiprocessing.Pool()\\n map_results = pool.starmap(np_apply_along_axis, chunks)\\n \\n pool.close()\\n pool.join()\\n\\n return np.concatenate(map_results)\",\n \"def make_rank_polymorphic(fn, core_ndims, name=None):\\n\\n def vectorized_fn(*args):\\n \\\"\\\"\\\"Vectorized version of `fn` that accepts arguments of any rank.\\\"\\\"\\\"\\n with tf.name_scope(name or 'make_rank_polymorphic'):\\n # If we got a single value for core_ndims, tile it across all args.\\n core_ndims_structure = (\\n core_ndims\\n if tf.nest.is_nested(core_ndims)\\n else tf.nest.map_structure(lambda _: core_ndims, args))\\n\\n # Build flat lists of all argument parts and their corresponding core\\n # ndims.\\n flat_core_ndims = tf.nest.flatten(core_ndims_structure)\\n flat_args = nest.flatten_up_to(\\n core_ndims_structure, args, check_types=False)\\n\\n # Filter to only the `Tensor`-valued args (taken to be those with `None`\\n # values for `core_ndims`). Other args will be passed through to `fn`\\n # unmodified.\\n (vectorized_arg_core_ndims,\\n vectorized_args,\\n fn_of_vectorized_args) = _lock_in_non_vectorized_args(\\n fn,\\n arg_structure=core_ndims_structure,\\n flat_core_ndims=flat_core_ndims,\\n flat_args=flat_args)\\n\\n # `vectorized_map` requires all inputs to have a single, common batch\\n # dimension `[n]`. So we broadcast all input parts to a common\\n # batch shape, then flatten it down to a single dimension.\\n vectorized_arg_shapes = [ps.shape(arg) for arg in vectorized_args]\\n\\n vectorized_arg_actual_core_ndims = []\\n batch_shapes, core_shapes = [], []\\n for (arg_shape, core_nd) in zip(vectorized_arg_shapes,\\n vectorized_arg_core_ndims):\\n arg_nd = ps.rank_from_shape(arg_shape)\\n # Shrink 'core' ndims of rank-deficient args. This guarantees that\\n # `batch_ndims` is always nonnegative.\\n actual_core_nd = ps.minimum(arg_nd, core_nd)\\n vectorized_arg_actual_core_ndims.append(actual_core_nd)\\n\\n batch_ndims = arg_nd - actual_core_nd\\n batch_ndims_ = tf.get_static_value(batch_ndims)\\n if batch_ndims_ is not None:\\n batch_shapes.append(arg_shape[:batch_ndims_])\\n core_shapes.append(arg_shape[batch_ndims_:])\\n else:\\n arg_shape = tf.convert_to_tensor(arg_shape)\\n batch_shapes.append(arg_shape[:batch_ndims])\\n core_shapes.append(arg_shape[batch_ndims:])\\n\\n # Flatten all of the batch dimensions into one.\\n broadcast_batch_shape = (\\n functools.reduce(ps.broadcast_shape, batch_shapes, []))\\n n = ps.cast(ps.reduce_prod(broadcast_batch_shape), tf.int32)\\n\\n static_n = tf.get_static_value(n)\\n if static_n == 1:\\n # We can bypass `vectorized_map` if the batch shape is `[]`, `[1]`,\\n # `[1, 1]`, etc., just by flattening to batch shape `[]`.\\n result_batch_dims = 0\\n batched_result = fn_of_vectorized_args(\\n tf.nest.map_structure(\\n lambda x, nd: tf.reshape(x, ps.shape(x)[ps.rank(x) - nd:]),\\n vectorized_args,\\n vectorized_arg_actual_core_ndims,\\n check_types=False))\\n else:\\n # Pad all input parts to the common shape, then flatten\\n # into the single leading dimension `[n]`.\\n # TODO(b/145227909): If/when vmap supports broadcasting, use nested vmap\\n # when batch rank is static so that we can exploit broadcasting.\\n broadcast_vectorized_args = [\\n tf.broadcast_to(part, ps.concat(\\n [broadcast_batch_shape, core_shape], axis=0))\\n for (part, core_shape) in zip(vectorized_args, core_shapes)]\\n vectorized_args_with_flattened_batch_dim = [\\n tf.reshape(part, ps.concat([[n], core_shape], axis=0))\\n for (part, core_shape) in zip(\\n broadcast_vectorized_args, core_shapes)]\\n result_batch_dims = 1\\n batched_result = tf.vectorized_map(\\n fn_of_vectorized_args, vectorized_args_with_flattened_batch_dim)\\n\\n # Unflatten any `Tensor`s in the result.\\n unflatten = lambda x: tf.reshape(x, ps.concat([ # pylint: disable=g-long-lambda\\n broadcast_batch_shape, ps.shape(x)[result_batch_dims:]], axis=0))\\n result = tf.nest.map_structure(\\n lambda x: unflatten(x) if tf.is_tensor(x) else x, batched_result,\\n expand_composites=True)\\n return result\\n\\n return vectorized_fn\",\n \"def n_ary(f):\\n def n_ary_fn(x, *args):\\n return x if not args else f(x, n_ary_fn(*args))\\n return n_ary_fn\",\n \"def custom_np_function(vector):\\n summation = 0\\n for item in vector:\\n summation += item ** 2\\n return summation\",\n \"def transform(fn):\\n def _(vec, dt):\\n return np.einsum(\\n 'ji,i,ki,k...->j...',\\n evecs, fn(evals, dt), evecs, vec, optimize=True)\\n\\n return _\",\n \"def vectorize_unpack(args):\\n return vectorize(*args)\",\n \"def vectorize_unpack(args):\\n return vectorize(*args)\",\n \"def _lock_in_non_vectorized_args(fn, arg_structure, flat_core_ndims, flat_args):\\n\\n # Extract the indices and values of args where core_ndims is not `None`.\\n (vectorized_arg_indices,\\n vectorized_arg_core_ndims,\\n vectorized_args) = [], [], []\\n if any(nd is not None for nd in flat_core_ndims):\\n vectorized_arg_indices, vectorized_arg_core_ndims, vectorized_args = zip(*[\\n (i, nd, tf.convert_to_tensor(t))\\n for i, (nd, t) in enumerate(zip(flat_core_ndims, flat_args))\\n if nd is not None])\\n\\n vectorized_arg_index_set = set(vectorized_arg_indices)\\n\\n def fn_of_vectorized_args(vectorized_args):\\n with tf.name_scope('fn_of_vectorized_args'):\\n vectorized_args_by_index = dict(\\n zip(vectorized_arg_indices, vectorized_args))\\n # Substitute the vectorized args into the original argument\\n # structure.\\n new_args_with_original_structure = tf.nest.pack_sequence_as(\\n arg_structure, [vectorized_args_by_index[i]\\n if i in vectorized_arg_index_set\\n else v for (i, v) in enumerate(flat_args)])\\n return tf.nest.map_structure(\\n # If `fn` returns any Distribution instances, ensure that their\\n # parameter batch shapes are padded to align after vectorization.\\n _maybe_rectify_parameter_shapes,\\n fn(*new_args_with_original_structure))\\n\\n return (vectorized_arg_core_ndims,\\n vectorized_args,\\n fn_of_vectorized_args)\",\n \"def vectorize(func, processes=1, on_complete=None):\\n if processes > 1:\\n return __multiprocess_wrapper(func, processes, on_complete)\\n else:\\n return single_process_wrapper(func, on_complete)\",\n \"def vecToFunc(vector):\\n def f(x):\\n f = 0\\n for i in range(len(vector)):\\n f += vector[i]*x**i\\n return f\\n return f\",\n \"def apply_along_1_nb(a, apply_func_nb, *args):\\n out = np.empty_like(a, dtype=np.float_)\\n for i in range(a.shape[0]):\\n out[i, :] = apply_func_nb(i, a[i, :], *args)\\n return out\",\n \"def rank_zero_only(fn):\\n\\n def wrapped(*args, **kwargs):\\n if rank() == 0:\\n return fn(*args, **kwargs)\\n\\n return wrapped\",\n \"def fn(*args, **kwargs):\\n pass\",\n \"def csr_mulvec_wrap(fn):\\n\\n @functools.wraps(fn)\\n def csr_mul_vector(A, x):\\n if A.nnz > 50000 and _NUM_THREAD_WORKERS > 1:\\n return par_dot_csr_matvec(A, x)\\n else:\\n y = fn(A, x)\\n if isinstance(x, qarray):\\n y = qarray(y)\\n return y\\n\\n return csr_mul_vector\",\n \"def Generate_Custom(f, n, m):\\n return np.fromfunction(np.vectorize(f, otypes=[float]), (n,m))\",\n \"def vec_apply_cost(self,\\n arr: jnp.ndarray,\\n axis: bool = 0,\\n fn=None) -> jnp.ndarray:\\n x, y = (self.x, self.y) if axis == 0 else (self.y, self.x)\\n nx, ny = self._norm_x, self._norm_y\\n nx, ny = (nx, ny) if axis == 0 else (ny, nx)\\n\\n applied_cost = jnp.dot(nx, arr).reshape(1, -1)\\n applied_cost += ny.reshape(-1, 1) * jnp.sum(arr, axis=0).reshape(1, -1)\\n applied_cost += -2.0 * jnp.dot(y, jnp.dot(x.T, arr))\\n return fn(applied_cost) if fn else applied_cost\",\n \"def n_ary(f):\\n def n_ary_f(x,*args):\\n return x if not args else f(x,n_ary_f(*args))\\n return n_ary_f\",\n \"def basis_fns(n=0):\\n return lambda x: np.sum(x ** (n+1), axis=1)\",\n \"def rank_transform(X):\\n return np.apply_along_axis(scipy.stats.rankdata, 0, X)\",\n \"def make_pbroadcast_function(fn, in_axes, out_axes, out_dtype):\\n\\n if not isinstance(in_axes, tuple):\\n in_axes = (in_axes,)\\n\\n def pbroadcast_fn(*args):\\n nest.assert_shallow_structure(args, in_axes)\\n nest.assert_shallow_structure(out_dtype, out_axes)\\n map_in_axes = nest.map_structure_up_to(args, canonicalize_axis_name,\\n in_axes)\\n map_out_axes = nest.map_structure_up_to(out_dtype, canonicalize_axis_name,\\n out_axes)\\n\\n def _pbroadcast_input(out_axes, x, in_axes):\\n psum_axes = [\\n axis_name for axis_name in out_axes if axis_name not in in_axes\\n ]\\n return pbroadcast(x, psum_axes)\\n\\n def _flat_fn_index(i, *args):\\n out = fn(*args)\\n return tf.nest.flatten(out)[i]\\n\\n def _flat_fn(*args):\\n outputs = []\\n for i, out_axis in enumerate(nest.flatten_up_to(out_dtype, map_out_axes)):\\n local_args = nest.map_structure_up_to(\\n args, functools.partial(_pbroadcast_input, out_axis), args,\\n map_in_axes)\\n outputs.append(_flat_fn_index(i, *local_args))\\n return tf.nest.pack_sequence_as(out_dtype, outputs)\\n\\n return _flat_fn(*args)\\n\\n return pbroadcast_fn\",\n \"def vectorize(self):\\n return vectorize(self)\",\n \"def apply_along_0_nb(a, apply_func_nb, *args):\\n out = np.empty_like(a, dtype=np.float_)\\n for col in range(a.shape[1]):\\n out[:, col] = apply_func_nb(col, a[:, col], *args)\\n return out\",\n \"def _chunk_vmapped_function(vmapped_fun, chunk_size, argnums=0):\\n\\n if chunk_size is None:\\n return vmapped_fun\\n\\n if isinstance(argnums, int):\\n argnums = (argnums,)\\n\\n def _fun(*args):\\n\\n n_elements = jax.tree_leaves(args[argnums[0]])[0].shape[0]\\n n_chunks, n_rest = divmod(n_elements, chunk_size)\\n\\n if n_chunks == 0 or chunk_size >= n_elements:\\n y = vmapped_fun(*args)\\n else:\\n # split inputs\\n def _get_chunks(x):\\n x_chunks = jax.tree_map(lambda x_: x_[: n_elements - n_rest, ...], x)\\n x_chunks = _chunk(x_chunks, chunk_size)\\n return x_chunks\\n\\n def _get_rest(x):\\n x_rest = jax.tree_map(lambda x_: x_[n_elements - n_rest :, ...], x)\\n return x_rest\\n\\n args_chunks = [\\n _get_chunks(a) if i in argnums else a for i, a in enumerate(args)\\n ]\\n args_rest = [\\n _get_rest(a) if i in argnums else a for i, a in enumerate(args)\\n ]\\n\\n y_chunks = _unchunk(\\n scanmap(vmapped_fun, scan_append, argnums)(*args_chunks)\\n )\\n\\n if n_rest == 0:\\n y = y_chunks\\n else:\\n y_rest = vmapped_fun(*args_rest)\\n y = jax.tree_map(\\n lambda y1, y2: jnp.concatenate((y1, y2)), y_chunks, y_rest\\n )\\n return y\\n\\n return _fun\",\n \"def _fn(dtype, shape, name, trainable, add_variable_fn):\\n loc, scale = loc_scale_fn_(dtype, shape, name, trainable, add_variable_fn)\\n if scale is None:\\n dist = deterministic_lib.Deterministic(loc=loc)\\n else:\\n dist = normal_lib.Normal(loc=loc, scale=scale)\\n reinterpreted_batch_ndims = array_ops.shape(dist.batch_shape_tensor())[0]\\n return independent_lib.Independent(\\n dist, reinterpreted_batch_ndims=reinterpreted_batch_ndims)\",\n \"def apply_fn(self,fn):\\r\\n \\r\\n self.check_Data()\\r\\n for split,data_ in self.processed_data.items():\\r\\n x = data_['x']\\r\\n x = np.array([fn(xi) for xi in x])\\r\\n data_['x'] = x\",\n \"def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\\n axis = check_axes(axis)\\n if len(axis) == x.ndim:\\n return func(x)\\n\\n other_axes = negate_indices(axis, x.ndim)\\n begin = np.arange(len(other_axes))\\n\\n y = np.moveaxis(x, other_axes, begin)\\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)\",\n \"def evaluate_1darray_function_on_2d_array(function, samples, opts=None):\\n num_args = get_num_args(function)\\n assert samples.ndim == 2\\n num_samples = samples.shape[1]\\n if num_args == 2:\\n values_0 = function(samples[:, 0], opts)\\n else:\\n values_0 = function(samples[:, 0])\\n values_0 = np.atleast_1d(values_0)\\n assert values_0.ndim == 1\\n num_qoi = values_0.shape[0]\\n values = np.empty((num_samples, num_qoi), float)\\n values[0, :] = values_0\\n for i in range(1, num_samples):\\n if num_args == 2:\\n values[i, :] = function(samples[:, i], opts)\\n else:\\n values[i, :] = function(samples[:, i])\\n\\n return values\",\n \"def with_numpy(func):\\r\\n return func\",\n \"def RunningFunc(x, N, func=np.nanmedian, loc='middle'):\\n\\n if len(x)<N+1:\\n return np.ones(len(x))*func(x)\\n \\n result = np.zeros(len(x))\\n \\n idx = np.arange(N) + np.arange(len(x)-N+1)[:,None]\\n b = [row[row>0] for row in x[idx]]\\n \\n if loc == 'middle':\\n start = int(N/2)\\n elif loc == 'right':\\n start = 0\\n else:\\n start = int(N)\\n\\n result[start:start+len(idx)] = np.array([func(c) for c in b])\\n result[:start] = result[int(N/2)-1]\\n result[start+len(idx):] = result[-int(N/2)-1]\\n\\n return result\",\n \"def apply(self, func, *args):\\n pass\",\n \"def specialize_arr_arr_element_wise(func):\\n\\n func_name_capital = ''.join(x.capitalize() or '_' for x in func.__name__.split('_'))\\n num_func_args = len(inspect.getargspec(func).args)\\n assert num_func_args == 2, \\\\\\n \\\"Element-wise operations must take exactly two arguments; {0} given\\\".format(num_func_args)\\n\\n return LazyElemWiseArrayArrayOp.from_function(func, \\\"ElemArrayArrayOp\\\" + func_name_capital)\",\n \"def array_input(f):\\n @wraps(f)\\n def wrapped(self, t):\\n t = np.atleast_1d(t)\\n r = f(self, t)\\n return r\\n return wrapped\",\n \"def __call__(self, *args):\\n if isinstance(args[0], (float, int, complex)):\\n # scalar version:\\n return self.constant\\n else:\\n # vectorized version:\\n r = args[0].copy()\\n # to get right dimension of the return array,\\n # compute with args in a simple formula (sum of args)\\n for a in args[1:]:\\n r = r + a # in-place r+= won't work\\n # (handles x,y,t - the last t just adds a constant)\\n r[:] = self.constant\\n return r\",\n \"def numpyfunc(*args, **kwargs):\\n def _decorator(func):\\n return numpy.frompyfunc(func, *args, **kwargs)\\n return _decorator\",\n \"def function(fnc, *args, **kwargs):\\n return Function(fnc, args=args, kwargs=kwargs).tunable()\",\n \"def operate_on_narray(x, y, function):\\n try:\\n return [operate_on_narray(a, b, function) for a, b in zip(x, y)]\\n # except TypeError as e:\\n except TypeError:\\n # Not iterable\\n return function(x, y)\",\n \"def vectorize(sch, tensor, vectorize_limit):\\n inner_axis = s[tensor].op.axis[len(s[tensor].op.axis) - 1]\\n inner_length = tensor.shape[len(tensor.shape) - 1].value\\n if inner_length <= vectorize_limit:\\n sch[tensor].vectorize(inner_axis)\\n else:\\n split_factor = 1\\n for i in range(vectorize_limit, 1, -1):\\n if inner_length % i == 0:\\n split_factor = i\\n break\\n if split_factor > 1:\\n _, inner_i = sch[tensor].split(inner_axis, split_factor)\\n sch[tensor].vectorize(inner_i)\",\n \"def _scal_elemwise_with_nfunc(nfunc, nin, nout):\\r\\n def construct(symbol):\\r\\n symbolname = symbol.__name__\\r\\n inplace = symbolname.endswith('_inplace')\\r\\n if inplace:\\r\\n msg = \\\"inplace\\\"\\r\\n else:\\r\\n msg = \\\"no_inplace\\\"\\r\\n\\r\\n n = \\\"Elemwise{%s,%s}\\\" % (symbolname, msg)\\r\\n\\r\\n if inplace:\\r\\n scalar_op = getattr(scal, symbolname[:-len('_inplace')])\\r\\n inplace_scalar_op = scalar_op.__class__(scal.transfer_type(0))\\r\\n rval = elemwise.Elemwise(inplace_scalar_op, {0: 0}, name=n,\\r\\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\\r\\n else:\\r\\n scalar_op = getattr(scal, symbolname)\\r\\n rval = elemwise.Elemwise(scalar_op, name=n,\\r\\n nfunc_spec=(nfunc and (nfunc, nin, nout)))\\r\\n\\r\\n if getattr(symbol, '__doc__', False):\\r\\n rval.__doc__ = symbol.__doc__ + '\\\\n' + rval.__doc__\\r\\n\\r\\n # for the meaning of this see the ./epydoc script\\r\\n # it makes epydoc display rval as if it were a function, not an object\\r\\n rval.__epydoc_asRoutine = symbol\\r\\n rval.__module__ = 'tensor'\\r\\n\\r\\n pprint.assign(rval, printing.FunctionPrinter(symbolname))\\r\\n\\r\\n return rval\\r\\n return construct\",\n \"def n_ary(n, f):\\n if n < 0:\\n raise ValueError(\\\"First argument to n_ary must be a non-negative integer\\\")\\n\\n args1, args2 = generate_args(inspect.getfullargspec(f), n)\\n\\n return eval(\\\"lambda \\\" + args1 + \\\": f(\\\" + args2 + \\\")\\\", {\\\"f\\\": f})\",\n \"def apply(self, vec):\\n raise NotImplementedError\",\n \"def helper_fitness(chromosome_fitness_function):\\n def fitness_function(population):\\n return np.apply_along_axis(chromosome_fitness_function, 1, population)\\n return fitness_function\",\n \"def vectorize(features, vocab):\\n vec = lil_matrix((1, len(vocab)))\\n for feat in features:\\n try:\\n fidx = vocab[feat]\\n vec[0, fidx] += 1.0\\n except KeyError:\\n pass\\n return vec\",\n \"def pytorch_func(function):\\n def wrapper(self, *args, **kwargs):\\n \\\"\\\"\\\" Evaluate function, Assign arugments and keyword arguments to a\\n Pytorch function and return it as a numpy array.\\n\\n Args: \\n *args: argument\\n **kwargs: keyword arguments\\n Return\\n (np.array): output of function Tensor converted to numpy array\\\"\\\"\\\"\\n torch_args = [torch.tensor(arg, requires_grad=True, dtype=torch.float64) if type(arg) is ndarray else arg for arg in args]\\n torch_kwargs = {key: torch.tensor(kwarg, requires_grad=True, dtype=torch.float64) if type(kwarg) is ndarray else kwarg for key, kwarg in kwargs.items()}\\n result = function(self, *torch_args, **torch_kwargs)\\n return result.cpu().detach().numpy()\\n return wrapper\",\n \"def _compute_R1_from_vector(n, ind_mat, vec):\\r\\n\\r\\n R1 = 0\\r\\n for l in range(n):\\r\\n R1 += np.sum((2*ind_mat[:, l]+1) * vec**2)\\r\\n\\r\\n return R1\",\n \"def map_fn(fn, elems, dtype=None, parallel_iterations=None, back_prop=True,\\n swap_memory=False, infer_shape=True, name=None):\\n if not callable(fn):\\n raise TypeError(\\\"fn must be callable.\\\")\\n\\n if isinstance(elems, sparse_tensor.SparseTensor):\\n raise TypeError(\\n \\\"To perform a map on the values of a sparse tensor use either \\\"\\n \\\" SparseTensor(input.indices, fn(input.values), input.dense_shape) or \\\"\\n \\\" SparseTensor(input.indices, map_fn(fn, input.values), \\\"\\n \\\"input.dense_shape)\\\")\\n\\n in_graph_mode = not context.executing_eagerly()\\n # Set the default number of parallel_iterations depending on graph/eager mode.\\n if in_graph_mode and not parallel_iterations:\\n parallel_iterations = 10\\n elif not in_graph_mode and not parallel_iterations:\\n parallel_iterations = 1\\n\\n if not in_graph_mode and parallel_iterations > 1:\\n logging.log_first_n(logging.WARN, \\\"Setting parallel_iterations > 1 has no \\\"\\n \\\"effect when executing eagerly. Consider calling map_fn\\\"\\n \\\" with tf.contrib.eager.defun to execute fn in \\\"\\n \\\"parallel.\\\", 1)\\n parallel_iterations = 1\\n\\n input_is_sequence = nest.is_sequence(elems)\\n input_flatten = lambda x: nest.flatten(x) if input_is_sequence else [x]\\n def input_pack(x):\\n return nest.pack_sequence_as(elems, x) if input_is_sequence else x[0]\\n\\n if dtype is None:\\n output_is_sequence = input_is_sequence\\n output_flatten = input_flatten\\n output_pack = input_pack\\n else:\\n output_is_sequence = nest.is_sequence(dtype)\\n output_flatten = lambda x: nest.flatten(x) if output_is_sequence else [x]\\n def output_pack(x):\\n return (nest.pack_sequence_as(dtype, x)\\n if output_is_sequence else x[0])\\n\\n elems_flat = input_flatten(elems)\\n\\n with ops.name_scope(name, \\\"map\\\", elems_flat):\\n # TODO(akshayka): Remove the in_graph_mode check once caching devices are\\n # supported in Eager\\n if in_graph_mode:\\n # Any get_variable calls in fn will cache the first call locally\\n # and not issue repeated network I/O requests for each iteration.\\n varscope = vs.get_variable_scope()\\n varscope_caching_device_was_none = False\\n if varscope.caching_device is None:\\n # TODO(ebrevdo): Change to using colocate_with here and in other\\n # methods.\\n varscope.set_caching_device(lambda op: op.device)\\n varscope_caching_device_was_none = True\\n\\n elems_flat = [\\n ops.convert_to_tensor(elem, name=\\\"elem\\\") for elem in elems_flat]\\n\\n dtype = dtype or input_pack([elem.dtype for elem in elems_flat])\\n dtype_flat = output_flatten(dtype)\\n\\n # Convert elems to tensor array. n may be known statically.\\n static_shape = elems_flat[0].shape\\n if static_shape.ndims is not None and static_shape.ndims < 1:\\n if len(elems_flat) == 1:\\n raise ValueError(\\\"elems must be a 1+ dimensional Tensor, not a scalar\\\")\\n else:\\n raise ValueError(\\n \\\"elements in elems must be 1+ dimensional Tensors, not scalars\\\"\\n )\\n n = (tensor_shape.dimension_value(static_shape[0])\\n or array_ops.shape(elems_flat[0])[0])\\n\\n # TensorArrays are always flat\\n elems_ta = [\\n tensor_array_ops.TensorArray(dtype=elem.dtype,\\n size=n,\\n dynamic_size=False,\\n infer_shape=True)\\n for elem in elems_flat]\\n # Unpack elements\\n elems_ta = [\\n elem_ta.unstack(elem) for elem_ta, elem in zip(elems_ta, elems_flat)]\\n\\n i = constant_op.constant(0)\\n\\n accs_ta = [\\n tensor_array_ops.TensorArray(dtype=dt,\\n size=n,\\n dynamic_size=False,\\n infer_shape=infer_shape)\\n for dt in dtype_flat]\\n\\n def compute(i, tas):\\n \\\"\\\"\\\"The loop body of map_fn.\\n\\n Args:\\n i: the loop counter\\n tas: the flat TensorArray accumulator list\\n\\n Returns:\\n (i + 1, tas): the updated counter + updated TensorArrays\\n\\n Raises:\\n TypeError: if dtype and packed_fn_values structure do not match\\n ValueType: if dtype and packed_fn_values lengths do not match\\n \\\"\\\"\\\"\\n packed_values = input_pack([elem_ta.read(i) for elem_ta in elems_ta])\\n packed_fn_values = fn(packed_values)\\n nest.assert_same_structure(dtype or elems, packed_fn_values)\\n flat_fn_values = output_flatten(packed_fn_values)\\n tas = [ta.write(i, value) for (ta, value) in zip(tas, flat_fn_values)]\\n return (i + 1, tas)\\n\\n _, r_a = control_flow_ops.while_loop(\\n lambda i, _: i < n, compute, (i, accs_ta),\\n parallel_iterations=parallel_iterations,\\n back_prop=back_prop,\\n swap_memory=swap_memory,\\n maximum_iterations=n)\\n results_flat = [r.stack() for r in r_a]\\n\\n n_static = tensor_shape.Dimension(tensor_shape.dimension_value(\\n elems_flat[0].get_shape().with_rank_at_least(1)[0]))\\n for elem in elems_flat[1:]:\\n n_static.merge_with(tensor_shape.Dimension(tensor_shape.dimension_value(\\n elem.get_shape().with_rank_at_least(1)[0])))\\n for r in results_flat:\\n r.set_shape(tensor_shape.TensorShape(n_static).concatenate(\\n r.get_shape()[1:]))\\n\\n # TODO(akshayka): Remove the in_graph_mode check once caching devices are\\n # supported in Eager\\n if in_graph_mode and varscope_caching_device_was_none:\\n varscope.set_caching_device(None)\\n\\n return output_pack(results_flat)\",\n \"def apply_function(f, args):\\n if len(signature(f).parameters) == len(args):\\n func = curry(f)\\n for arg_value in args:\\n func = func(arg_value)\\n return func()\\n else:\\n raise Exception(\\\"the number of function's parameter is not matched args, len(args): \\\", len(args))\",\n \"def vectorize_par(\\n f: Callable, inputs: Iterable,\\n pool: Pool = None, processes=None, chunksize=1,\\n nout=None, otypes: Union[Sequence[Type], Type] = None,\\n use_starmap=True, meshgrid_input=True,\\n) -> Tuple[Union[Mapping[Any, Any], np.ndarray, Sequence[Any]], ...]:\\n if isinstance(inputs, dict):\\n raise NotImplementedError()\\n # s = dict(signature(f).parameters)\\n # ks, ds = zip(*[(k, v.default) for k, v in s.items()])\\n # inputs = [inputs[k] if k in inputs else arrayobj1d([d]) for k, d in zip(ks, ds)]\\n\\n if meshgrid_input:\\n inputs = [\\n inp if (isinstance(inp, np.ndarray) and type(inp[0]) is object)\\n else (arrayobj1d(inp) if is_iter(inp)\\n else arrayobj1d([inp]))\\n for inp in inputs]\\n shape0 = [len(inp) for inp in inputs]\\n mesh_inputs = np.meshgrid(*inputs, indexing='ij') # type: Iterable[np.ndarray]\\n else:\\n inputs = [arrayobj1d([inp]) if not is_iter(inp) else inp for inp in inputs]\\n shape0 = broadcast_shapes(*[npy(v).shape for v in inputs])\\n mesh_inputs = [np.broadcast_to(v, shape0) for v in inputs]\\n mesh_inputs = [m.flatten() for m in mesh_inputs]\\n\\n m = zip(*mesh_inputs)\\n m = [m1 for m1 in m]\\n\\n if pool is None:\\n pool = Pool(processes=processes) # type: PoolParallel\\n\\n # if processes == 0:\\n # use_starmap = False\\n\\n if chunksize is None:\\n # NOTE: this doesn't seem to work well, unlike chunksize=1.\\n # Need further experiment.\\n chunksize = np.max([\\n int(np.floor(np.prod(shape0) / pool._processes)),\\n 1\\n ])\\n\\n if use_starmap:\\n try:\\n outs = pool.starmap(f, m, chunksize=chunksize)\\n except EOFError:\\n print('EOFError from starmap! Trying again..')\\n # Just try again - this seems to fix the issue\\n try:\\n outs = pool.starmap(f, m, chunksize=chunksize)\\n except EOFError:\\n print('EOFError again after trying again.. '\\n 'Not trying again this time.')\\n raise\\n else:\\n outs = pool.map(f, m, chunksize=chunksize)\\n\\n if nout is None:\\n if otypes is not None and is_sequence(otypes):\\n nout = len(otypes)\\n else:\\n try:\\n nout = len(outs[0])\\n except TypeError:\\n nout = 1\\n\\n if otypes is None:\\n otypes = [object] * nout\\n elif not is_sequence(type(otypes)):\\n otypes = [otypes] * nout\\n\\n # NOTE: deliberately keeping outs, outs1, and outs2 for debugging.\\n # After confirming everything works well, rename all to \\\"outs\\\"\\n # to save memory.\\n # DEF: outs1[argout][i_input_flattened]\\n if nout > 1:\\n outs1 = zip(*outs)\\n else:\\n if use_starmap:\\n outs1 = [outs]\\n else:\\n # Reverse the action of map() putting each output in a list\\n outs1 = [[out1[0] for out1 in outs]]\\n\\n # --- outs2: reshape to inputs' dimensions\\n # DEF: outs2[argout][i_input1, i_input2, ...]\\n outs2 = [arrayobj1d(out).reshape(shape0) for out in outs1]\\n\\n # --- outs3: set to a correct otype\\n # DEF: outs3[argout][i_input1, i_input2, ...]\\n outs3 = [cell2mat(out, otype) if otype not in [object, object]\\n else out\\n for out, otype in zip(outs2, otypes)]\\n return tuple(outs3)\",\n \"def wrapper(self, *args, **kwargs):\\n torch_args = [torch.tensor(arg, requires_grad=True, dtype=torch.float64) if type(arg) is ndarray else arg for arg in args]\\n torch_kwargs = {key: torch.tensor(kwarg, requires_grad=True, dtype=torch.float64) if type(kwarg) is ndarray else kwarg for key, kwarg in kwargs.items()}\\n result = function(self, *torch_args, **torch_kwargs)\\n return result.cpu().detach().numpy()\",\n \"def as_numpy(fn):\\n\\n def metric_fn(y_true, y_pred):\\n if isinstance(y_true, (pd.Series, pd.DataFrame)):\\n new_y_true = y_true.values\\n elif isinstance(y_true, np.ndarray):\\n new_y_true = y_true\\n else:\\n new_y_true = y_true.numpy()\\n if isinstance(y_pred, (pd.Series, pd.DataFrame)):\\n new_y_pred = y_pred.values\\n elif isinstance(y_pred, np.ndarray):\\n new_y_pred = y_pred\\n else:\\n new_y_pred = y_pred.numpy()\\n if new_y_true.ndim == 1:\\n new_y_true = np.expand_dims(new_y_true, 1)\\n if new_y_pred.ndim == 1:\\n new_y_pred = np.expand_dims(new_y_pred, 1)\\n return fn(new_y_true, new_y_pred)\\n return metric_fn\",\n \"def lambda_fun(funk, x):\\n # input must be 1d numpy.ndarray\\n assert isinstance(x, np.ndarray) and x.ndim == 1\\n\\n # result from the lambdified function with array input\\n abo = funk(x)\\n\\n if isinstance(abo, float):\\n abo = np.array([[abo]])\\n\\n if abo.ndim < 3:\\n # reshaping from (n,1) to (n,)\\n abo = abo.reshape(abo.shape[0])\\n\\n # fix the term not properly broadcasted in the lambdified funtion\\n abo_fix = np.array(np.broadcast_arrays(x, *abo)[1:])\\n\\n elif abo.ndim == 3:\\n abo_fix = abo.reshape(abo.shape[0], -1)\\n\\n # roll the axis to obtain an array of matrix, and not a matrix of arrays\\n abo_fix = np.moveaxis(abo_fix, -1, 0)\\n\\n return abo_fix\",\n \"def generate_numba_apply_func(\\n func: Callable[..., Scalar],\\n nopython: bool,\\n nogil: bool,\\n parallel: bool,\\n):\\n numba_func = jit_user_function(func)\\n if TYPE_CHECKING:\\n import numba\\n else:\\n numba = import_optional_dependency(\\\"numba\\\")\\n\\n @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)\\n def roll_apply(\\n values: np.ndarray,\\n begin: np.ndarray,\\n end: np.ndarray,\\n minimum_periods: int,\\n *args: Any,\\n ) -> np.ndarray:\\n result = np.empty(len(begin))\\n for i in numba.prange(len(result)):\\n start = begin[i]\\n stop = end[i]\\n window = values[start:stop]\\n count_nan = np.sum(np.isnan(window))\\n if len(window) - count_nan >= minimum_periods:\\n result[i] = numba_func(window, *args)\\n else:\\n result[i] = np.nan\\n return result\\n\\n return roll_apply\",\n \"def apply(self, func, *args, **kwargs):\\n pass\",\n \"def _wrapper(func, args):\\n return func(*args)\",\n \"def n_ary(f):\\n #def n_ary_f(x, *args):\\n #if len(args) == 0:\\n #return x\\n #return f(x,n_ary_f(args[0],*args[1:]))\\n def n_ary_f(x, *args):\\n return x if not args else f(x,n_ary_f(*args))\\n return n_ary_f\",\n \"def process_in_chunks(function, *args, batch_size, out=None, **kwargs):\\n total_size = args[0].shape[0]\\n first_output = function(*[x[0: batch_size] for x in args])\\n output_shape = (total_size,) + tuple(first_output.shape[1:])\\n if out is None:\\n out = torch.zeros(*output_shape, dtype=first_output.dtype, device=first_output.device,\\n layout=first_output.layout, **kwargs)\\n\\n out[0: batch_size] = first_output\\n for i in range(batch_size, total_size, batch_size):\\n batch_ix = slice(i, min(i + batch_size, total_size))\\n out[batch_ix] = function(*[x[batch_ix] for x in args])\\n return out\",\n \"def f(x):\\n n_particles = x.shape[0]\\n j = [f_per_particle(x[i]) for i in range(n_particles)]\\n #print(\\\"f j: \\\", j)\\n return np.array(j)\",\n \"def map(self, f_list: List[Callable[[np.ndarray], int]], axis: int = 0, chunksize: int = 1000, selection: np.ndarray = None) -> List[np.ndarray]:\\n\\t\\tif hasattr(f_list, '__call__'):\\n\\t\\t\\traise ValueError(\\\"f_list must be a list of functions, not a function itself\\\")\\n\\n\\t\\tresult = []\\n\\t\\tif axis == 0:\\n\\t\\t\\trows_per_chunk = chunksize\\n\\t\\t\\tfor i in range(len(f_list)):\\n\\t\\t\\t\\tresult.append(np.zeros(self.shape[0]))\\n\\t\\t\\tix = 0\\n\\t\\t\\twhile ix < self.shape[0]:\\n\\t\\t\\t\\trows_per_chunk = min(self.shape[0] - ix, rows_per_chunk)\\n\\t\\t\\t\\tif selection is not None:\\n\\t\\t\\t\\t\\tchunk = self[ix:ix + rows_per_chunk, :][:, selection]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tchunk = self[ix:ix + rows_per_chunk, :]\\n\\t\\t\\t\\tfor i in range(len(f_list)):\\n\\t\\t\\t\\t\\tresult[i][ix:ix + rows_per_chunk] = np.apply_along_axis(f_list[i], 1, chunk)\\n\\t\\t\\t\\tix = ix + rows_per_chunk\\n\\t\\telif axis == 1:\\n\\t\\t\\tcols_per_chunk = chunksize\\n\\t\\t\\tfor i in range(len(f_list)):\\n\\t\\t\\t\\tresult.append(np.zeros(self.shape[1]))\\n\\t\\t\\tix = 0\\n\\t\\t\\twhile ix < self.shape[1]:\\n\\t\\t\\t\\tcols_per_chunk = min(self.shape[1] - ix, cols_per_chunk)\\n\\t\\t\\t\\tif selection is not None:\\n\\t\\t\\t\\t\\tchunk = self[:, ix:ix + cols_per_chunk][selection, :]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tchunk = self[:, ix:ix + cols_per_chunk]\\n\\t\\t\\t\\tfor i in range(len(f_list)):\\n\\t\\t\\t\\t\\tresult[i][ix:ix + cols_per_chunk] = np.apply_along_axis(f_list[i], 0, chunk)\\n\\t\\t\\t\\tix = ix + cols_per_chunk\\n\\t\\treturn result\",\n \"def multichannel(fcn):\\n return lambda args: (fcn(*args), )\",\n \"def squared_call(fn, arg):\\n return fn(fn(arg))\",\n \"def _scalar_vectorized(scalar, M):\\n return scalar[:, np.newaxis, np.newaxis]*M\",\n \"def apply(self, fn, column_label):\\n return [fn(v) for v in self[column_label]]\",\n \"def scoped_fn(fn: Callable[..., U]) -> Callable[..., U]:\\n @functools.wraps(fn)\\n def wrapper(*args: Any, **kwargs: Any) -> Any:\\n with tf.variable_scope(fn.__name__):\\n return fn(*args, **kwargs)\\n\\n return wrapper\",\n \"def wrapper(*args, **kwargs):\\n return fn(*args, **kwargs)\",\n \"def vectorized_rounder():\\n\\n def f(num):\\n if np.isnan(num):\\n return np.nan\\n else:\\n return num // 10 ** (int(math.log(num, 10)))\\n\\n vf = np.vectorize(f)\\n\\n return(vf)\",\n \"def rolling_apply_matrix_nb(a, window, apply_func_nb, *args):\\n out = np.empty_like(a, dtype=np.float_)\\n for i in range(a.shape[0]):\\n window_a = a[max(0, i + 1 - window):i + 1, :]\\n out[i, :] = apply_func_nb(i, window_a, *args)\\n return out\",\n \"def sp_mulvec_wrap(fn):\\n\\n @functools.wraps(fn)\\n def qarrayed_fn(self, other):\\n out = fn(self, other)\\n if isinstance(other, qarray):\\n out = qarray(out)\\n return out\\n\\n return qarrayed_fn\",\n \"def apply(df, f):\\n return [f(row) for row in df]\",\n \"def as_args(function):\\n return lambda x: function(*x)\",\n \"def __array_function__(self, func, types, args, kwargs):\\n try:\\n if not func.__module__.startswith(\\\"numpy\\\"):\\n return NotImplemented\\n except AttributeError:\\n return NotImplemented\\n _args = list(map(MetaTensor._convert, args))\\n _kwargs = {k: MetaTensor._convert(v) for k, v in kwargs.items()}\\n return func(*_args, **_kwargs)\",\n \"def _apply_cost_to_vec(\\n self, vec: jnp.ndarray, axis: int = 0, fn=None\\n ) -> jnp.ndarray:\\n vec = jnp.reshape(vec, self.grid_size)\\n accum_vec = jnp.zeros_like(vec)\\n indices = list(range(1, self.grid_dimension))\\n for dimension, geom in enumerate(self.geometries):\\n cost = geom.cost_matrix\\n ind = indices.copy()\\n ind.insert(dimension, 0)\\n if axis == 0:\\n cost = cost.T\\n accum_vec += jnp.sum(\\n jnp.tensordot(cost, vec, axes=([0], [dimension])),\\n axis=indices,\\n keepdims=True\\n ).transpose(ind)\\n return accum_vec.ravel()\",\n \"def a(a,N): \\n a=np.ravel(a, order='F') # Same order\\n return a\",\n \"def a(a,N): \\n a=np.ravel(a, order='F') # Same order\\n return a\",\n \"def __call__(self, _x: np.ndarray) -> np.ndarray:\\n return self.function(_x)\",\n \"def expand_apply(f, axis=0):\\n if axis not in [0, -1]:\\n raise ValueError(\\\"expand_apply currently only supports axis=0 or axis=-1.\\\")\\n\\n @functools.wraps(f)\\n def wrapper(*args, **kwargs):\\n expand = lambda t: jnp.expand_dims(t, axis=axis)\\n args = jax.tree_map(expand, args)\\n kwargs = jax.tree_map(expand, kwargs)\\n outputs = f(*args, **kwargs)\\n return jax.tree_map(lambda t: jnp.squeeze(t, axis=axis), outputs)\\n\\n return wrapper\",\n \"def batchify(fn, chunk):\\n if chunk is None:\\n return fn\\n\\n def ret(inputs, styles, alpha, feature):\\n results = []\\n for i in range(0, inputs.shape[0], chunk):\\n input_chunk = inputs[i:i + chunk]\\n style_chunk = styles[i:i + chunk]\\n alpha_chunk = alpha[i:i + chunk] if alpha is not None else None\\n feature_chunk = feature[i:i + chunk] if feature is not None else None\\n results.append(fn(input_chunk, style_chunk, alpha_chunk, feature_chunk))\\n return torch.cat(results, 0)\\n return ret\",\n \"def apply_and_reduce_nb(a, apply_func_nb, apply_args, reduce_func_nb, reduce_args):\\n out = np.full(a.shape[1], np.nan, dtype=np.float_)\\n\\n for col in range(a.shape[1]):\\n mapped = apply_func_nb(col, a[:, col], *apply_args)\\n out[col] = reduce_func_nb(col, mapped, *reduce_args)\\n return out\",\n \"def benchmarkNFunc(iter, ns):\\n def decorator(func):\\n for n in ns:\\n benchmarkFuncs.append((func, (n,), iter))\\n return func\\n return decorator\",\n \"def vmap_chunked(f: Callable, in_axes=0, *, chunk_size: Optional[int]):\\n if isinstance(in_axes, int):\\n in_axes = (in_axes,)\\n\\n if not set(in_axes).issubset((0, None)):\\n raise NotImplementedError(\\\"Only in_axes 0/None are currently supported\\\")\\n\\n argnums = tuple(\\n map(lambda ix: ix[0], filter(lambda ix: ix[1] is not None, enumerate(in_axes)))\\n )\\n\\n vmapped_fun = jax.vmap(f, in_axes=in_axes)\\n\\n return _chunk_vmapped_function(vmapped_fun, chunk_size, argnums)\",\n \"def integrate_monte_carlo_nd(f, dim, limit, N=1000000):\\n I, sum = 1/N, 0\\n for n in range(dim):\\n I *= (limit[n][1] - limit[n][0])\\n\\n for k in range(N):\\n x = []\\n for n in range(dim):\\n x += [limit[n][0] + (limit[n][1] - limit[n][0])*rnd.random()]\\n\\n sum += f(x)\\n return I*sum\",\n \"def nkron(*args):\\n return reduce(np.kron, args, np.array([1]))\",\n \"def _sklearn_reshape_apply(func, return_result, X, *args, **kwargs):\\n if not isinstance(X, np.ndarray):\\n raise ValueError(\\\"data should be an np.ndarray, got %s.\\\" % type(X))\\n orig_shape = X.shape\\n X = np.reshape(X.transpose(0, 2, 1), (-1, orig_shape[1]))\\n X = func(X, *args, **kwargs)\\n if return_result:\\n X.shape = (orig_shape[0], orig_shape[2], orig_shape[1])\\n X = X.transpose(0, 2, 1)\\n return X\",\n \"def rng_fn_scipy(cls, rng, *args, **kwargs):\",\n \"def repeat_n_times(n, fn, *args, **kwargs):\\n if args:\\n my_args = _transpose_list_of_lists(\\n [_maybe_repeat(arg, n) for arg in args])\\n else:\\n my_args = [[] for _ in range(n)]\\n my_kwargs = [{} for _ in range(n)]\\n for k, v in six.iteritems(kwargs):\\n vals = _maybe_repeat(v, n)\\n for i in range(n):\\n my_kwargs[i][k] = vals[i]\\n\\n # construct lists of functions\\n fns = _maybe_repeat(fn, n)\\n outputs = [fns[i](*my_args[i], **my_kwargs[i]) for i in range(n)]\\n if isinstance(outputs[0], tuple):\\n outputs = list(zip(*outputs))\\n outputs = tuple([list(o) for o in outputs])\\n return outputs\",\n \"def make_psum_function(fn, in_axes, out_axes, out_dtype):\\n\\n out_axes = nest.map_structure_up_to(out_dtype, canonicalize_axis_name,\\n out_axes)\\n\\n def psum_fn(*args):\\n out = make_pbroadcast_function(fn, in_axes, out_axes, out_dtype)(*args)\\n\\n def _psum_output(x, out_axis):\\n return psum(x, out_axis)\\n\\n return nest.map_structure_up_to(out_dtype, _psum_output, out, out_axes)\\n\\n return psum_fn\",\n \"def lambda_fn(ds, fn):\\n logger.info(\\\"Applying function '%s' on dataset.\\\", str(fn))\\n return fn(ds)\",\n \"def __call__(self, x, *args, **kwargs):\\n joined_kwargs = dict(self.kwargs)\\n joined_kwargs.update(kwargs)\\n x = np.asarray(x)\\n return Function.__call__(self, x, *(args + self.args),\\n **joined_kwargs)\",\n \"def run_in_thread(fn):\\n def run(*k, **kw):\\n t = threading.Thread(target=fn, args=k, kwargs=kw)\\n t.start()\\n return t\\n return run\",\n \"def run_in_thread(fn):\\n def run(*k, **kw):\\n t = threading.Thread(target=fn, args=k, kwargs=kw)\\n t.start()\\n return t\\n return run\",\n \"def _call_numpy(func, args, kwargs):\\n\\n numpy_args, numpy_kwargs = data_transfer._get_numpy_args(args, kwargs)\\n\\n numpy_res = func(*numpy_args, **numpy_kwargs)\\n\\n cupy_res = data_transfer._get_cupy_result(numpy_res)\\n\\n return cupy_res\",\n \"def _call_n(x, f, n, *args, **kwargs):\\n return [f(i, x, *args, **kwargs) for i in range(n)]\",\n \"def minibatched_call(fn, mbsize, *args, **kwargs):\\n tensor_list, _ = tree_util.tree_flatten((args, kwargs))\\n batchsize = tensor_list[0].shape[0]\\n mbs = [\\n fn(*tree_slice(args, inds), **tree_slice(kwargs, inds))\\n for inds in th.arange(batchsize).split(mbsize)\\n ]\\n return tree_cat(mbs, dim=0)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6786364","0.6786364","0.6500684","0.5944921","0.5887587","0.5769011","0.5756932","0.55749714","0.5569364","0.5535822","0.55204463","0.5485098","0.5388941","0.5376015","0.53529257","0.53529257","0.53479564","0.53440005","0.5334205","0.529618","0.5241454","0.51292723","0.5117598","0.510972","0.5062967","0.50494176","0.5032803","0.5004581","0.49960765","0.49782124","0.49712935","0.49646565","0.49622804","0.49535635","0.4948065","0.49384856","0.4923873","0.49229062","0.4907642","0.4895839","0.4894204","0.48858592","0.4883329","0.4873913","0.48678872","0.4836459","0.4835398","0.4831488","0.4828143","0.4814722","0.48067614","0.48009062","0.48008657","0.47982612","0.47963896","0.47947446","0.47932714","0.47907892","0.47863805","0.4781009","0.47727147","0.4756957","0.47566915","0.4753166","0.4752135","0.47474322","0.47371897","0.47342002","0.47246176","0.4708002","0.47068182","0.47063723","0.47044745","0.47028005","0.4702573","0.4695447","0.46941543","0.4691075","0.4684562","0.46825078","0.46825078","0.4673545","0.46727213","0.46624583","0.46263513","0.46242324","0.4617605","0.46155053","0.46072975","0.460604","0.4600071","0.45976844","0.45959005","0.45954105","0.45945096","0.459053","0.459053","0.45870635","0.45859772","0.4579689"],"string":"[\n \"0.6786364\",\n \"0.6786364\",\n \"0.6500684\",\n \"0.5944921\",\n \"0.5887587\",\n \"0.5769011\",\n \"0.5756932\",\n \"0.55749714\",\n \"0.5569364\",\n \"0.5535822\",\n \"0.55204463\",\n \"0.5485098\",\n \"0.5388941\",\n \"0.5376015\",\n \"0.53529257\",\n \"0.53529257\",\n \"0.53479564\",\n \"0.53440005\",\n \"0.5334205\",\n \"0.529618\",\n \"0.5241454\",\n \"0.51292723\",\n \"0.5117598\",\n \"0.510972\",\n \"0.5062967\",\n \"0.50494176\",\n \"0.5032803\",\n \"0.5004581\",\n \"0.49960765\",\n \"0.49782124\",\n \"0.49712935\",\n \"0.49646565\",\n \"0.49622804\",\n \"0.49535635\",\n \"0.4948065\",\n \"0.49384856\",\n \"0.4923873\",\n \"0.49229062\",\n \"0.4907642\",\n \"0.4895839\",\n \"0.4894204\",\n \"0.48858592\",\n \"0.4883329\",\n \"0.4873913\",\n \"0.48678872\",\n \"0.4836459\",\n \"0.4835398\",\n \"0.4831488\",\n \"0.4828143\",\n \"0.4814722\",\n \"0.48067614\",\n \"0.48009062\",\n \"0.48008657\",\n \"0.47982612\",\n \"0.47963896\",\n \"0.47947446\",\n \"0.47932714\",\n \"0.47907892\",\n \"0.47863805\",\n \"0.4781009\",\n \"0.47727147\",\n \"0.4756957\",\n \"0.47566915\",\n \"0.4753166\",\n \"0.4752135\",\n \"0.47474322\",\n \"0.47371897\",\n \"0.47342002\",\n \"0.47246176\",\n \"0.4708002\",\n \"0.47068182\",\n \"0.47063723\",\n \"0.47044745\",\n \"0.47028005\",\n \"0.4702573\",\n \"0.4695447\",\n \"0.46941543\",\n \"0.4691075\",\n \"0.4684562\",\n \"0.46825078\",\n \"0.46825078\",\n \"0.4673545\",\n \"0.46727213\",\n \"0.46624583\",\n \"0.46263513\",\n \"0.46242324\",\n \"0.4617605\",\n \"0.46155053\",\n \"0.46072975\",\n \"0.460604\",\n \"0.4600071\",\n \"0.45976844\",\n \"0.45959005\",\n \"0.45954105\",\n \"0.45945096\",\n \"0.459053\",\n \"0.459053\",\n \"0.45870635\",\n \"0.45859772\",\n \"0.4579689\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65664375"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":90596,"cells":{"query":{"kind":"string","value":"Adds master file location for each page to the metadata_local.xml saf output file."},"document":{"kind":"string","value":"def add_page_admin_data(self, top, record):\n # type: (Element, Element) -> None\n cdm_struc = Fields.cdm_structural_elements\n dspace_local = Fields.dspace_local_field\n\n structure_el = record.find(cdm_struc['compound_object_container'])\n pages_el = structure_el.iterfind('.//' + cdm_struc['compound_object_page'])\n\n for page in pages_el:\n title = page.find(cdm_struc['compound_object_page_title'])\n page_files = page.iterfind(cdm_struc['compound_object_page_file'])\n for file_el in page_files:\n type_el = file_el.find(cdm_struc['compound_object_page_file_type'])\n if type_el.text == 'master':\n file_location = file_el.find(cdm_struc['compound_object_page_file_loc'])\n master_el = ET.SubElement(top, 'dcvalue')\n master_el.set('element', dspace_local['preservation_location'])\n if file_location.text is not None:\n master_el.text = title.text + ' master: ' + file_location.text"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _build_local_metadata_file(files, home=''):\n filepaths = [os.path.join(home, f) for f in files]\n shas = [_get_sha_metadata(f) for f in filepaths]\n metadata = dict(zip(files, shas))\n\n with open(LOCAL_METADATA_FILE, 'w') as f:\n f.write(json.dumps(metadata))","def master_archive(f, e):\n template = e.get_template(TEMPLATES['archive'])\n write_file(\"archives.html\", template.render(entries=f))","def writeInfo(self, location=None, masters=None):\n if self.currentInstance is None:\n return\n infoElement = ET.Element(\"info\")\n if location is not None:\n locationElement = self._makeLocationElement(location)\n infoElement.append(locationElement)\n self.currentInstance.append(infoElement)","def _write_meta(self, parameter_set_files):\n # Always overwrite the meta data file to ensure that *all* parameter file names are included.\n with open(self.parameter_study_meta_file, 'w') as meta_file:\n if self.output_file:\n meta_file.write(f\"{self.output_file.resolve()}\\n\")\n else:\n for parameter_set_file in parameter_set_files:\n meta_file.write(f\"{parameter_set_file.resolve()}\\n\")","def set_dirinfo(self):\n self.hostname = globals.hostname\n self.local_dirname = globals.local_path.name # @UndefinedVariable\n if self.fh:\n if self.hostname:\n self.fh.write(\"Hostname %s\\n\" % self.hostname)\n if self.local_dirname:\n self.fh.write(\"Localdir %s\\n\" % Quote(self.local_dirname))\n return self","def metadata_callback(files): # type: (t.List[t.Tuple[str, str]]) -> None\n config = self\n\n if config.metadata_path:\n files.append((os.path.abspath(config.metadata_path), config.metadata_path))","def write_metadata(dir_path, fs, *metas, global_metadata=True):\n assert metas\n md = metas[0]\n with fs.open(\"/\".join([dir_path, \"_common_metadata\"]), \"wb\") as fil:\n md.write_metadata_file(fil)\n if global_metadata:\n for meta in metas[1:]:\n md.append_row_groups(meta)\n with fs.open(\"/\".join([dir_path, \"_metadata\"]), \"wb\") as fil:\n md.write_metadata_file(fil)","def generate_metadata(self):\n self.metadata = {\n 'title': os.path.basename(self.source_file).rsplit('.', 1)[0],\n 'url': self.relative_destination_file,\n 'full_path': os.path.dirname(self.relative_destination_file),\n 'short_path': self.shorten_path(\n os.path.dirname(self.relative_destination_file))\n }","def generate_metadata_files(self):\n\n data_folder = self.get_data_folder(mode='absolute')\n\n parents = (data_folder / '_').parents\n\n for mfile in self.mdata:\n for regex, level in METADATA_LEVEL_BY_NAME.items():\n if re.compile(regex).match(mfile.name):\n create_file(mfile, parents[(3-level)] / mfile.name,\n mode='copy')","def detail_pages(f, e):\n template = e.get_template(TEMPLATES['detail'])\n for file in f:\n write_file(file['url'], template.render(entry=file, entries=f))","def __appendMetaData(self, filename):\n metadata = {'Model': 'LFM',\n 'Source': filename,\n 'Date processed': datetime.datetime.now(),\n 'Start date': self.startDate\n }\n \n self.data.append(key='meta',\n name='Metadata for LFM Solar Wind file',\n units='n/a',\n data=metadata)","def write_sitemaps():\n sitemap_index = open('static/sitemaps/sitemap.xml', 'w')\n sitemap_index.write('<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n<sitemapindex xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\\n')\n\n max_urls = 50000\n page_count = 0\n url_count = 0\n sitemap_file = None\n\n for loc, last_mod in sitemap_urls():\n\n # if we've maxed out the number of urls per sitemap \n # close out the one we have open and open a new one\n if url_count % max_urls == 0:\n page_count += 1\n if sitemap_file: \n sitemap.write('</urlset>\\n')\n sitemap.close()\n sitemap_file = 'sitemap-%05d.xml' % page_count\n sitemap_path = 'static/sitemaps/%s' % sitemap_file\n _logger.info(\"writing %s\" % sitemap_path)\n sitemap = open(sitemap_path, 'w')\n sitemap.write('<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\\n')\n sitemap_index.write('<sitemap><loc>http://chroniclingamerica.loc.gov/%s</loc></sitemap>\\n' % sitemap_file)\n \n # add a url to the sitemap\n sitemap.write(\"<url><loc>http://chroniclingamerica.loc.gov%s</loc><lastmod>%s</lastmod></url>\\n\" % (loc, rfc3339(last_mod)))\n url_count += 1\n\n # necessary to avoid memory bloat when settings.DEBUG = True\n if url_count % 1000 == 0:\n reset_queries()\n\n # wrap up some open files\n sitemap.write('</urlset>\\n')\n sitemap.close()\n sitemap_index.write('</sitemapindex>\\n')\n sitemap_index.close()","def files(self):\n if os.path.exists(self.xml_file):\n self.xml_link='<li>XML <a href=\"../../%(xml_file)s?download=true\">%(xml_file)s</a></li>'.format(self.xml_file)\n else:\n self.xml_link=''\n # <a href=\"../../%(xml)s?download=true\">%(xml)s</a></li>\n #self.xml = glob.glob('*.xml')[0]","def main():\n \n root = Folder(name=os.getcwd(), file='meta.json',\n collection='.github/jekyll')\n root.update()\n root.export_folders(True)","def targetPath(self):\n return FileUtils.createPath(self.site.targetWebRootPath, 'sitemap.xml', isFile=True)","def masterPath(self):\n\t\treturn fl.File( self._path + '/master.data' )","def _write_master(self):\n text = _condor_master_template % {\n 'meds_files':self.meds_files,\n }\n master_script=files.get_condor_master_path(self['run'])\n print('writing master:',master_script)\n with open(master_script,'w') as fobj:\n fobj.write(text)\n\n os.system('chmod 755 %s' % master_script)","def create_output_loc(self):\n self.output_name = [self.args.xml_out, 'gatk4_' + self.json_file['name'].lower().split(' ')[0] + '.xml']\n if not self.args.xml_out.endswith('/'):\n return '/'.join(self.output_name)\n else:\n return ''.join(self.output_name)","def publish_metadata_in_ipfs(self):\n self._printout(self._publish_metadata_in_ipfs(self.args.metadata_file))","def on_new_site(self, files):\n init_index()","def getLocalFiles(self):\r\n\r\n for dirpath, dirnames, filenames in os.walk(self.dlLocation):\r\n for name in filenames:\r\n currentPath = os.path.join(dirpath, name)\r\n currentPath = re.sub('^\\w:', '', currentPath)\r\n currentPath = re.sub(r\"\\\\\",'/', currentPath)\r\n self.localStore.append(currentPath)\r\n\r\n return self.localStore","def _update_filesystem_metadata(self, metadata):\n directory, fname = os.path.split(self.fname)\n fbase = os.path.splitext(fname)[0]\n \n # Test for presence and size of zip file\n zip_file = fbase + '.zip'\n zip_path = os.path.join(directory, zip_file)\n \n if os.path.isfile(zip_path):\n location = 'on_disk'\n data_file_size = os.path.getsize(zip_path)\n else:\n location = 'on_tape'\n data_file_size = 0\n \n # Test for presence of quick look PNG file\n quicklook_file = fbase + '.png'\n quicklook_path = os.path.join(directory, quicklook_file)\n \n if not os.path.isfile(quicklook_path):\n quicklook_file = ''\n\n # Add to metadata dictionary\n item_map = {'directory': directory, 'metadata_file': fname,\n 'data_file': zip_file, 'location': location, \n 'data_file_size': data_file_size, 'quicklook_file': quicklook_file}\n \n for key, value in item_map.items():\n metadata[key] = value","def copy_metadata():\n\n common_root = os.path.join(os.path.dirname(__file__), \"wsdotroute\", \"esri\")\n src = os.path.join(common_root, \"toolboxes\")\n dest = os.path.join(common_root, \"help\", \"gp\", \"toolboxes\")\n\n if os.path.exists(dest):\n shutil.rmtree(dest)\n\n shutil.copytree(src, dest, ignore=shutil.ignore_patterns(\"*.pyt\"))\n\n print(\"Completed copying metadata XML files\")","def _add_filename_metadata(self, extra_metadata): \n \n # Make sure product_info section exists\n extra_metadata.setdefault('product_info', {})\n \n file_name = os.path.basename(self.fname)\n fn_comps = file_name.split(\"_\")\n \n if self.__class__ == SAFESentinel1:\n component = fn_comps[2]\n if len(component) < 4: \n resolution = 'N/A'\n else:\n resolution = component[-1]\n \n extra_metadata['product_info']['Resolution'] = resolution\n \n # Add file/scan name \n extra_metadata['product_info']['Name'] = os.path.splitext(file_name)[0]\n \n # Add Satellite and Mission from the file path\n comp_1 = fn_comps[0].upper()\n extra_metadata['platform']['Mission'] = \"Sentinel-%s\" % comp_1[1]\n extra_metadata['platform']['Satellite'] = \"Sentinel-%s\" % comp_1[1:]","def _add_redirects(self):\n with open(REDIRECTS_FILE, encoding=\"utf-8\") as mapping_fd:\n reader = csv.reader(mapping_fd)\n for row in reader:\n if not row or row[0].strip().startswith(\"#\"):\n continue\n\n html_path = os.path.join(BUILD_PATH, \"html\")\n path = os.path.join(html_path, *row[0].split(\"/\")) + \".html\"\n\n if not self.include_api and (\n os.path.join(html_path, \"reference\") in path\n or os.path.join(html_path, \"generated\") in path\n ):\n continue\n\n try:\n title = self._get_page_title(row[1])\n except Exception:\n # the file can be an ipynb and not an rst, or docutils\n # may not be able to read the rst because it has some\n # sphinx specific stuff\n title = \"this page\"\n\n with open(path, \"w\", encoding=\"utf-8\") as moved_page_fd:\n html = f\"\"\"\\\n<html>\n <head>\n <meta http-equiv=\"refresh\" content=\"0;URL={row[1]}.html\"/>\n </head>\n <body>\n <p>\n The page has been moved to <a href=\"{row[1]}.html\">{title}</a>\n </p>\n </body>\n<html>\"\"\"\n\n moved_page_fd.write(html)","def load_metadata(self):\n handler = open('meta.xml').read()\n soup = BeautifulSoup(handler, 'xml')\n\n for meta in soup.find_all(re.compile(\"^title\")):\n if meta.string:\n self.meta_title = unicode(meta.string)\n\n for meta in soup.find_all(re.compile(\"^initial.creator\")):\n if meta.string:\n self.meta_initial_creator = unicode(meta.string)\n\n for meta in soup.find_all(re.compile(\"^date\")):\n if meta.string:\n self.meta_date = unicode(meta.string)","def _save_metadata(self, search_name):\r\n with open_(self.output_path / \"metadata\", \"a\") as f:\r\n f.write(\r\n f\"\"\"name={self.name}\r\n non_linear_search={search_name}\r\n \"\"\"\r\n )","def set_local_path(self):\n return HERE","def generate_metadata(self):\n if self.options.mbtiles:\n return\n if not os.path.exists(self.output):\n os.makedirs(self.output)\n\n if self.options.profile == 'mercator':\n\n south, west = self.mercator.MetersToLatLon( self.ominx, self.ominy)\n north, east = self.mercator.MetersToLatLon( self.omaxx, self.omaxy)\n south, west = max(-85.05112878, south), max(-180.0, west)\n north, east = min(85.05112878, north), min(180.0, east)\n self.swne = (south, west, north, east)\n\n # Generate googlemaps.html\n if self.options.webviewer in ('all','google') and self.options.profile == 'mercator':\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'googlemaps.html')):\n f = open(os.path.join(self.output, 'googlemaps.html'), 'w')\n f.write( self.generate_googlemaps() )\n f.close()\n\n # Generate openlayers.html\n if self.options.webviewer in ('all','openlayers'):\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\n f.write( self.generate_openlayers() )\n f.close()\n\n elif self.options.profile == 'geodetic':\n\n west, south = self.ominx, self.ominy\n east, north = self.omaxx, self.omaxy\n south, west = max(-90.0, south), max(-180.0, west)\n north, east = min(90.0, north), min(180.0, east)\n self.swne = (south, west, north, east)\n\n # Generate openlayers.html\n if self.options.webviewer in ('all','openlayers'):\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\n f.write( self.generate_openlayers() )\n f.close()\n\n elif self.options.profile in ['raster','gearth','garmin']:\n\n west, south = self.ominx, self.ominy\n east, north = self.omaxx, self.omaxy\n\n self.swne = (south, west, north, east)\n\n # Generate openlayers.html\n if self.options.webviewer in ('all','openlayers'):\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\n f.write( self.generate_openlayers() )\n f.close()\n\n\n # Generate tilemapresource.xml.\n if (self.options.tile_format != 'hybrid' and self.options.profile != 'garmin'\n and (not self.options.resume or not os.path.exists(os.path.join(self.output, 'tilemapresource.xml')))):\n f = open(os.path.join(self.output, 'tilemapresource.xml'), 'w')\n f.write( self.generate_tilemapresource())\n f.close()","def write_sitemap ( self ):\n try:\n self.output_fd = open ( file=dflt_cfg.DFLT_CFG[ OUTPUT_PATH ], mode='w' )\n self.print_url_links ( self.root )\n except (PermissionError, AttributeError) as err:\n self.logger.error ( \"Error {0} occurred. Output file {1} cannot be created\".format ( err, \\\n dflt_cfg.DFLT_CFG[\n OUTPUT_PATH ] ) )\n except Exception as err:\n self.logger.error ( \"Error {0} occurred while writing sitemap in output file: {1}\".format ( err, \\\n dflt_cfg.DFLT_CFG[ OUTPUT_PATH ] ) )\n self.output_fd.close ( )\n else:\n print(\"Sitemap for {} is written in {}.\".format(dflt_cfg.DFLT_CFG[DOMAIN], dflt_cfg.DFLT_CFG[ OUTPUT_PATH ]))\n print( \"Logs (Broken or dead URLs along with application logs) for domain {0} are available in {1} directory.\".format ( dflt_cfg.DFLT_CFG[DOMAIN], \"./logs\" ) )\n self.output_fd.close ( )","def save_master(master_directory):\n global MASTER_SHELF\n MASTER_SHELF = shelve.open(str(PurePath(SHELF_DIR / \"MASTER_SHELF\")))\n MASTER_SHELF[\"master\"] = master_directory\n MASTER_SHELF.close()","def _add_redirects(self):\n with open(REDIRECTS_FILE) as mapping_fd:\n reader = csv.reader(mapping_fd)\n for row in reader:\n if not row or row[0].strip().startswith(\"#\"):\n continue\n\n html_path = os.path.join(BUILD_PATH, \"html\")\n path = os.path.join(html_path, *row[0].split(\"/\")) + \".html\"\n\n if not self.include_api and (\n os.path.join(html_path, \"reference\") in path\n or os.path.join(html_path, \"generated\") in path\n ):\n continue\n\n try:\n title = self._get_page_title(row[1])\n except Exception:\n # the file can be an ipynb and not an rst, or docutils\n # may not be able to read the rst because it has some\n # sphinx specific stuff\n title = \"this page\"\n\n with open(path, \"w\") as moved_page_fd:\n html = f\"\"\"\\\n<html>\n <head>\n <meta http-equiv=\"refresh\" content=\"0;URL={row[1]}.html\"/>\n </head>\n <body>\n <p>\n The page has been moved to <a href=\"{row[1]}.html\">{title}</a>\n </p>\n </body>\n<html>\"\"\"\n\n moved_page_fd.write(html)","def do_root(self, line):\n self.root_directory = line\n if self.source_file:\n self.source_file = self.root_directory + \"/\" + self.source_file\n print(f\"Root directory to read & write files is: {line}\")","def addMasters(self,masterNames):\n #--Load Masters\n #--Master FileRefs\n proItems = []\n totSize = 0\n for masterName in masterNames:\n #--Don't have fileRef? FileRef out of date?\n masterInfo = modInfos[masterName]\n fileRefs = masterInfo.extras.get('FileRefs')\n if not fileRefs:\n fileRefs = masterInfo.extras['FileRefs'] = FileRefs(masterInfo,True,True)\n fileRefs.setDebrisIds()\n refreshSize = fileRefs.refreshSize()\n if refreshSize:\n proItems.append((fileRefs,refreshSize))\n totSize += refreshSize\n #--Refresh masters\n cumSize = 0\n for (fileRefs,size) in proItems:\n self.progress.setBaseScale(1.0*cumSize/totSize, 1.0*size/totSize)\n fileRefs.progress = self.progress\n fileRefs.refresh()\n cumSize += size\n #--Do Mapping\n del proItems[:]\n totSize = 0\n for masterName in masterNames:\n size = len(modInfos[masterName].extras['FileRefs'].cells)\n proItems.append((masterName,size))\n totSize += size\n cumSize = 0\n for (masterName,size) in proItems:\n if size: self.progress.setBaseScale(1.0*cumSize/totSize, 1.0*size/totSize)\n self.addMaster(masterName)\n cumSize += size","def save_meta(self):\n # jOut = os.path.join(self.meta[\"wdir\"], meta_file)\n with open(self.meta_filepath, \"w\") as f:\n json.dump(self.meta, f)","def _newfile(counter):\n name = '%s/sitemap-%s.xml.gz' % (settings.SITEMAPS_DIR,\n counter)\n fp = gzip.open(name, 'wb')\n fp.write(\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\\n\"\"\")\n return fp","def edited_file_locations(self):","def test_existing_current_files(self):\n\n m = Mothur(**self.init_vars)\n self.set_current_dirs(m)\n m.summary.seqs(fasta='test_fasta_1.fasta')\n m.summary.seqs()\n\n return","def build_masters(opts):\n logger.info(\"Reading designspace file...\")\n ds = DesignSpaceDocument.fromfile(opts.dsPath)\n validateDesignspaceDoc(ds)\n master_paths = [s.path for s in ds.sources]\n\n logger.info(\"Building local OTFs for master font paths...\")\n curDir = os.getcwd()\n dsDir = os.path.dirname(opts.dsPath)\n\n for master_path in master_paths:\n master_path = os.path.join(dsDir, master_path)\n masterDir = os.path.dirname(master_path)\n ufoName = os.path.basename(master_path)\n otfName = os.path.splitext(ufoName)[0]\n otfName = f\"{otfName}.otf\"\n\n if masterDir:\n os.chdir(masterDir)\n\n makeotf(['-nshw', '-f', ufoName, '-o', otfName,\n '-r', '-nS'] + opts.mkot)\n logger.info(f\"Built OTF font for {master_path}\")\n generalizeCFF(otfName)\n os.chdir(curDir)","def load_xml_files_erisk(local_dir, token_position=0):\n users = {}\n prep = Preprocessor()\n c = 0\n for dir_path, dir_names, filenames in os.walk(local_dir):\n for name in filenames:\n tok = name.split(\"_\")\n if token_position > 0:\n key = tok[0] + tok[token_position]\n else:\n key = tok[token_position]\n key = key.strip(\".xml\")\n full_file = os.path.abspath(os.path.join(dir_path, name))\n dom = ET.parse(full_file, parser=ET.XMLParser(encoding=\"utf-8\"))\n writing = dom.findall('WRITING')\n for w in writing:\n title = w.find('TITLE').text\n text = w.find('TEXT').text\n post = title + \" \" + text\n # preprocess text\n new_text = prep.tokenize_reddit(post)\n\n if key in users.keys():\n users[key] += new_text + ' end_ '\n else:\n users[key] = new_text + ' end_ '\n\n c += 1\n print(\"Preprocessed chunk: \", c)\n\n return users","def add_file_metadata(self):\n metadata = self.__file.require_group(METADATA)\n self.__write_value(metadata, DATE_CREATED, date.today().strftime(\"%Y-%m-%d\"))\n self.__write_value(metadata, SDK_VERSION, __version__)","def run(self, info):\n\n # Write the metadata to the file's xattrs\n self._downloader.to_screen('[metadata] Writing metadata to file\\'s xattrs')\n\n filename = info['filepath']\n\n try:\n xattr_mapping = {\n 'user.xdg.referrer.url': 'webpage_url',\n # 'user.xdg.comment': 'description',\n 'user.dublincore.title': 'title',\n 'user.dublincore.date': 'upload_date',\n 'user.dublincore.description': 'description',\n 'user.dublincore.contributor': 'uploader',\n 'user.dublincore.format': 'format',\n }\n\n num_written = 0\n for xattrname, infoname in xattr_mapping.items():\n\n value = info.get(infoname)\n\n if value:\n if infoname == 'upload_date':\n value = hyphenate_date(value)\n\n byte_value = value.encode('utf-8')\n write_xattr(filename, xattrname, byte_value)\n num_written += 1\n\n return [], info\n\n except XAttrUnavailableError as e:\n self._downloader.report_error(str(e))\n return [], info\n\n except XAttrMetadataError as e:\n if e.reason == 'NO_SPACE':\n self._downloader.report_warning(\n 'There\\'s no disk space left, disk quota exceeded or filesystem xattr limit exceeded. '\n + (('Some ' if num_written else '') + 'extended attributes are not written.').capitalize())\n elif e.reason == 'VALUE_TOO_LONG':\n self._downloader.report_warning(\n 'Unable to write extended attributes due to too long values.')\n else:\n msg = 'This filesystem doesn\\'t support extended attributes. '\n if compat_os_name == 'nt':\n msg += 'You need to use NTFS.'\n else:\n msg += '(You may have to enable them in your /etc/fstab)'\n self._downloader.report_error(msg)\n return [], info","def update_metadata(self):\n parser = GenericParser(\n fn_re='{}/(e\\d+s\\d+)_.*/Production.nc'.format(self.data_folder),\n group_names=['sim'],\n group_transforms=[lambda x: x],\n top_fn='',\n step_ps=self.timestep\n )\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\n self.meta = meta","def collect_outputs(self):\n # collect submex output hdf urls and add them to top mex outputs section\n top_mex = self.bqSession.fetchxml(self.options.mexURL, view='deep')\n outputTag = top_mex.xpath('/mex/tag[@name=\"outputs\"]')\n if not outputTag:\n # no \"outputs\" tag in mex => add it now\n etree.SubElement(top_mex, 'tag', name='outputs') \n top_mex = self.bqSession.postxml(url=top_mex.get('uri'), xml=top_mex, view='deep')\n outputTag = top_mex.xpath('/mex/tag[@name=\"outputs\"]')\n outputTag = outputTag[0]\n output_hdfs = top_mex.xpath('/mex/mex/tag[@name=\"outputs\"]/tag[@name=\"output_hdf\"]/@value')\n etree.SubElement(outputTag, 'tag', name='all_outputs', value=';'.join([ohdf.split('/')[-1] for ohdf in output_hdfs]))\n self.bqSession.postxml(url=outputTag.get('uri'), xml=outputTag)","def toc_add_files(self, refnodes: list[dict[str, Any]]) -> None:\n refnodes.insert(0, {\n 'level': 1,\n 'refuri': html.escape(self.config.root_doc + self.out_suffix),\n 'text': ssp(html.escape(\n self.env.titles[self.config.root_doc].astext())),\n })\n for file, text in reversed(self.config.epub_pre_files):\n refnodes.insert(0, {\n 'level': 1,\n 'refuri': html.escape(file),\n 'text': ssp(html.escape(text)),\n })\n for file, text in self.config.epub_post_files:\n refnodes.append({\n 'level': 1,\n 'refuri': html.escape(file),\n 'text': ssp(html.escape(text)),\n })","def maps():\n flatmap_list = []\n root_path = pathlib.Path(settings['FLATMAP_ROOT'])\n if root_path.is_dir():\n for flatmap_dir in root_path.iterdir():\n index = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.json')\n mbtiles = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.mbtiles')\n if os.path.isdir(flatmap_dir) and os.path.exists(index) and os.path.exists(mbtiles):\n with open(index) as fp:\n index = json.loads(fp.read())\n version = index.get('version', 1.0)\n reader = MBTilesReader(mbtiles)\n if version >= 1.3:\n metadata = read_metadata(reader, 'metadata')\n if (('id' not in metadata or flatmap_dir.name != metadata['id'])\n and ('uuid' not in metadata or flatmap_dir.name != metadata['uuid'].split(':')[-1])):\n app.logger.error(f'Flatmap id mismatch: {flatmap_dir}')\n continue\n flatmap = {\n 'id': metadata['id'],\n 'source': metadata['source'],\n 'version': version\n }\n if 'created' in metadata:\n flatmap['created'] = metadata['created']\n if 'taxon' in metadata:\n flatmap['taxon'] = normalise_identifier(metadata['taxon'])\n flatmap['describes'] = metadata['describes'] if 'describes' in metadata else flatmap['taxon']\n elif 'describes' in metadata:\n flatmap['taxon'] = normalise_identifier(metadata['describes'])\n flatmap['describes'] = flatmap['taxon']\n if 'biological-sex' in metadata:\n flatmap['biologicalSex'] = metadata['biological-sex']\n if 'uuid' in metadata:\n flatmap['uuid'] = metadata['uuid']\n if 'name' in metadata:\n flatmap['name'] = metadata['name']\n else:\n try:\n source_row = reader._query(\"SELECT value FROM metadata WHERE name='source'\").fetchone()\n except (InvalidFormatError, sqlite3.OperationalError):\n flask.abort(404, 'Cannot read tile database: {}'.format(mbtiles))\n if source_row is None:\n continue\n flatmap = {\n 'id': flatmap_dir.name,\n 'source': source_row[0]\n }\n created = reader._query(\"SELECT value FROM metadata WHERE name='created'\").fetchone()\n if created is not None:\n flatmap['created'] = created[0]\n describes = reader._query(\"SELECT value FROM metadata WHERE name='describes'\").fetchone()\n if describes is not None and describes[0]:\n flatmap['describes'] = normalise_identifier(describes[0])\n flatmap_list.append(flatmap)\n return flask.jsonify(flatmap_list)","def test_history_import_relpath_in_metadata():\n with HistoryArchive() as history_archive:\n history_archive.write_metafiles(dataset_file_name='../outside.txt')\n history_archive.write_file('datasets/Pasted_Entry_1.txt', 'foo')\n history_archive.write_outside()\n _run_jihaw_cleanup_check_secure(history_archive, 'Relative parent path in datasets_attrs.txt allowed')","def writeMeta(outDir, metaData, fulltextData):\n filename = join(outDir, 'articleMeta.tab')\n logging.debug('Appending metadata to %s' % filename)\n minId = pubConf.identifierStart['crawler']\n metaData['articleId'] = str(minId + int(metaData['pmid']))\n if 'main.html' in metaData:\n metaData['fulltextUrl'] = metaData['main.html']['url']\n elif 'landingUrl' in metaData:\n metaData['fulltextUrl'] = metaData['landingUrl']\n if not isfile(filename):\n codecs.open(filename, 'w', encoding='utf8').write(u'\\t'.join(metaHeaders) + '\\n')\n maxCommon.appendTsvDict(filename, metaData, metaHeaders)\n row = []\n for h in metaHeaders:\n row.append(metaData.get(h, ''))\n\n dbFname = join(outDir, 'articles.db')\n con, cur = maxTables.openSqliteCreateTable(dbFname, 'articles', metaHeaders, idxFields=['pmid', 'pmcId', 'doi'], intFields=['pmid', 'articleId', 'pmcId'], primKey='pmid', retries=100)\n writeOk = False\n tryCount = 100\n logging.log(5, '%s' % row)\n while not writeOk and tryCount > 0:\n try:\n try:\n maxTables.insertSqliteRow(cur, con, 'articles', metaHeaders, row)\n except sqlite3.IntegrityError:\n logging.warn('Already present in meta info db')\n\n writeOk = True\n except sqlite3.OperationalError:\n logging.info('sqlite db is locked, waiting for 60 secs')\n time.sleep(60)\n tryCount -= 1\n\n if not writeOk:\n raise Exception('Could not write to sqlite db')","def set_master_table(filepath):\n my_globals['master_table_path'] = filepath\n my_globals['master_table_data'] = None","def storeFilesNoZip(pmid, metaData, fulltextData, outDir):\n warnMsgs = []\n fileDir = join(outDir, 'files')\n if not isdir(fileDir):\n os.makedirs(fileDir)\n suppFnames = []\n suppUrls = []\n pdfFound = False\n for suffix, pageDict in fulltextData.iteritems():\n if suffix in ('status', 'crawlerName'):\n continue\n if suffix == 'landingPage':\n metaData['landingUrl'] = pageDict['url']\n continue\n filename = pmid + '.' + suffix\n warnMinSize = 5000\n if len(pageDict['data']) < warnMinSize:\n warnMsgs.append('%s is smaller than %d bytes' % (suffix, warnMinSize))\n if suffix == 'main.html':\n if '<html' in pageDict['data']:\n warnMsgs.append('main.html contains html tag')\n metaData['mainHtmlFile'] = filename\n metaData['mainHtmlUrl'] = pageDict['url']\n elif suffix == 'main.pdf':\n pdfFound = True\n checkIfPdf(pageDict, metaData)\n metaData['mainPdfFile'] = filename\n metaData['mainPdfUrl'] = pageDict['url']\n elif suffix.startswith('S'):\n suppFnames.append(filename)\n suppUrls.append(pageDict['url'])\n fileData = pageDict['data']\n filePath = join(fileDir, filename)\n logging.debug('Writing file %s' % filePath)\n fh = open(filePath, 'wb')\n fh.write(fileData)\n fh.close()\n\n if not pdfFound:\n warnMsgs.append('No PDF file')\n suppFnames = [ s.replace(',', '') for s in suppFnames ]\n suppFnames = [ s.replace('\\t', '') for s in suppFnames ]\n suppUrls = [ s.replace(',', '') for s in suppUrls ]\n suppUrls = [ s.replace('\\t', '') for s in suppUrls ]\n metaData['suppFiles'] = ','.join(suppFnames)\n metaData['suppUrls'] = ','.join(suppUrls)\n return (metaData, warnMsgs)","def build_content(self) -> None:\n logger.info(__('writing content.opf file...'))\n metadata = self.content_metadata()\n\n # files\n self.files: list[str] = []\n self.ignored_files = ['.buildinfo', 'mimetype', 'content.opf',\n 'toc.ncx', 'META-INF/container.xml',\n 'Thumbs.db', 'ehthumbs.db', '.DS_Store',\n 'nav.xhtml', self.config.epub_basename + '.epub'] + \\\n self.config.epub_exclude_files\n if not self.use_index:\n self.ignored_files.append('genindex' + self.out_suffix)\n for root, dirs, files in os.walk(self.outdir):\n dirs.sort()\n for fn in sorted(files):\n filename = relpath(path.join(root, fn), self.outdir)\n if filename in self.ignored_files:\n continue\n ext = path.splitext(filename)[-1]\n if ext not in self.media_types:\n # we always have JS and potentially OpenSearch files, don't\n # always warn about them\n if ext not in ('.js', '.xml'):\n logger.warning(__('unknown mimetype for %s, ignoring'), filename,\n type='epub', subtype='unknown_project_files')\n continue\n filename = filename.replace(os.sep, '/')\n item = ManifestItem(html.escape(quote(filename)),\n html.escape(self.make_id(filename)),\n html.escape(self.media_types[ext]))\n metadata['manifest_items'].append(item)\n self.files.append(filename)\n\n # spine\n spinefiles = set()\n for refnode in self.refnodes:\n if '#' in refnode['refuri']:\n continue\n if refnode['refuri'] in self.ignored_files:\n continue\n spine = Spine(html.escape(self.make_id(refnode['refuri'])), True)\n metadata['spines'].append(spine)\n spinefiles.add(refnode['refuri'])\n for info in self.domain_indices:\n spine = Spine(html.escape(self.make_id(info[0] + self.out_suffix)), True)\n metadata['spines'].append(spine)\n spinefiles.add(info[0] + self.out_suffix)\n if self.use_index:\n spine = Spine(html.escape(self.make_id('genindex' + self.out_suffix)), True)\n metadata['spines'].append(spine)\n spinefiles.add('genindex' + self.out_suffix)\n # add auto generated files\n for name in self.files:\n if name not in spinefiles and name.endswith(self.out_suffix):\n spine = Spine(html.escape(self.make_id(name)), False)\n metadata['spines'].append(spine)\n\n # add the optional cover\n html_tmpl = None\n if self.config.epub_cover:\n image, html_tmpl = self.config.epub_cover\n image = image.replace(os.sep, '/')\n metadata['cover'] = html.escape(self.make_id(image))\n if html_tmpl:\n spine = Spine(html.escape(self.make_id(self.coverpage_name)), True)\n metadata['spines'].insert(0, spine)\n if self.coverpage_name not in self.files:\n ext = path.splitext(self.coverpage_name)[-1]\n self.files.append(self.coverpage_name)\n item = ManifestItem(html.escape(self.coverpage_name),\n html.escape(self.make_id(self.coverpage_name)),\n html.escape(self.media_types[ext]))\n metadata['manifest_items'].append(item)\n ctx = {'image': html.escape(image), 'title': self.config.project}\n self.handle_page(\n path.splitext(self.coverpage_name)[0], ctx, html_tmpl)\n spinefiles.add(self.coverpage_name)\n\n auto_add_cover = True\n auto_add_toc = True\n if self.config.epub_guide:\n for type, uri, title in self.config.epub_guide:\n file = uri.split('#')[0]\n if file not in self.files:\n self.files.append(file)\n if type == 'cover':\n auto_add_cover = False\n if type == 'toc':\n auto_add_toc = False\n metadata['guides'].append(Guide(html.escape(type),\n html.escape(title),\n html.escape(uri)))\n if auto_add_cover and html_tmpl:\n metadata['guides'].append(Guide('cover',\n self.guide_titles['cover'],\n html.escape(self.coverpage_name)))\n if auto_add_toc and self.refnodes:\n metadata['guides'].append(Guide('toc',\n self.guide_titles['toc'],\n html.escape(self.refnodes[0]['refuri'])))\n\n # write the project file\n copy_asset_file(path.join(self.template_dir, 'content.opf_t'), self.outdir, metadata)","def _save_target_info(self):\n \n #make sure the file exists\n path = self.communicator.image_store.project_path + \\\n self.target_file_name\n fout = open(path, 'w')\n\n print str(1)\n print str(len(self.target_list)-1)\n for i in range(1, len(self.target_list)):\n fout.write(self.target_list[i].format_info())\n fout.write(\"\\n\\n\")\n fout.close()","def generate_metadata(self):\n\n if not os.path.exists(self.output_folder):\n os.makedirs(self.output_folder)\n\n if self.options.profile == 'mercator':\n\n south, west = self.mercator.MetersToLatLon(self.ominx, self.ominy)\n north, east = self.mercator.MetersToLatLon(self.omaxx, self.omaxy)\n south, west = max(-85.05112878, south), max(-180.0, west)\n north, east = min(85.05112878, north), min(180.0, east)\n self.swne = (south, west, north, east)\n\n # Generate googlemaps.html\n if self.options.webviewer in ('all', 'google') and self.options.profile == 'mercator':\n if (not self.options.resume or not\n os.path.exists(os.path.join(self.output_folder, 'googlemaps.html'))):\n with open(os.path.join(self.output_folder, 'googlemaps.html'), 'wb') as f:\n f.write(self.generate_googlemaps().encode('utf-8'))\n\n # Generate openlayers.html\n if self.options.webviewer in ('all', 'openlayers'):\n if (not self.options.resume or not\n os.path.exists(os.path.join(self.output_folder, 'openlayers.html'))):\n with open(os.path.join(self.output_folder, 'openlayers.html'), 'wb') as f:\n f.write(self.generate_openlayers().encode('utf-8'))\n\n # Generate leaflet.html\n if self.options.webviewer in ('all', 'leaflet'):\n if (not self.options.resume or not\n os.path.exists(os.path.join(self.output_folder, 'leaflet.html'))):\n with open(os.path.join(self.output_folder, 'leaflet.html'), 'wb') as f:\n f.write(self.generate_leaflet().encode('utf-8'))\n\n elif self.options.profile == 'geodetic':\n\n west, south = self.ominx, self.ominy\n east, north = self.omaxx, self.omaxy\n south, west = max(-90.0, south), max(-180.0, west)\n north, east = min(90.0, north), min(180.0, east)\n self.swne = (south, west, north, east)\n\n # Generate openlayers.html\n if self.options.webviewer in ('all', 'openlayers'):\n if (not self.options.resume or not\n os.path.exists(os.path.join(self.output_folder, 'openlayers.html'))):\n with open(os.path.join(self.output_folder, 'openlayers.html'), 'wb') as f:\n f.write(self.generate_openlayers().encode('utf-8'))\n\n elif self.options.profile == 'raster':\n\n west, south = self.ominx, self.ominy\n east, north = self.omaxx, self.omaxy\n\n self.swne = (south, west, north, east)\n\n # Generate openlayers.html\n if self.options.webviewer in ('all', 'openlayers'):\n if (not self.options.resume or not\n os.path.exists(os.path.join(self.output_folder, 'openlayers.html'))):\n with open(os.path.join(self.output_folder, 'openlayers.html'), 'wb') as f:\n f.write(self.generate_openlayers().encode('utf-8'))\n\n # Generate tilemapresource.xml.\n if not self.options.resume or not os.path.exists(os.path.join(self.output_folder, 'tilemapresource.xml')):\n with open(os.path.join(self.output_folder, 'tilemapresource.xml'), 'wb') as f:\n f.write(self.generate_tilemapresource().encode('utf-8'))\n\n if self.kml:\n # TODO: Maybe problem for not automatically generated tminz\n # The root KML should contain links to all tiles in the tminz level\n children = []\n xmin, ymin, xmax, ymax = self.tminmax[self.tminz]\n for x in range(xmin, xmax+1):\n for y in range(ymin, ymax+1):\n children.append([x, y, self.tminz])\n # Generate Root KML\n if self.kml:\n if (not self.options.resume or not\n os.path.exists(os.path.join(self.output_folder, 'doc.kml'))):\n with open(os.path.join(self.output_folder, 'doc.kml'), 'wb') as f:\n f.write(generate_kml(\n None, None, None, self.tileext, self.tilesize, self.tileswne,\n self.options, children\n ).encode('utf-8'))","def save(self):\n for page in self.pages.get_published_pages():\n site_path = page.path_to_page.replace('.md', '').replace(\n self.source_path, '').strip('/')\n save_path = self.output_path\n\n # ensure we are not creating a directory for the index file that\n # that lives at the source_path\n if page.full_path() != f'{self.source_path}{os.sep}index.md':\n site_path = slugify_path(site_path)\n save_path = os.path.join('', self.output_path, site_path)\n\n try:\n os.makedirs(save_path, exist_ok=True)\n except Exception as e:\n log((f'unable to create directories: {save_path}'\n f' because: {e}'), True)\n continue\n\n try:\n save_file = os.path.join(save_path, 'index.html')\n log(f'saving {save_file}')\n\n published = self.pages.get_published_pages()\n prev_page = self.pages.get_previous_page(page)\n next_page = self.pages.get_next_page(page)\n content = page.render(published_pages=published,\n previous_page=prev_page, next_page=next_page)\n write(save_file, content)\n except Exception as e:\n log(f'unable to save file: {save_file} -- {e}', True)\n\n unpublished = self.pages.get_unpublished_pages()\n if len(unpublished):\n log('')\n log('these pages were unpublished and not rendered:', True)\n for up in unpublished:\n log(up.path_to_page, True)\n log('')\n\n # build the _tags pages\n for tag, pages in self.tags.pages.items():\n content = self.tags.render(tag, pages)\n tag_index_dir = f'{self.tag_dir}/{slugify(tag)}'\n tag_index = f'{tag_index_dir}/index.html'\n os.makedirs(tag_index_dir, exist_ok=True)\n write(tag_index, content)\n\n log('finished builidng site')","def run(self):\n for filepage in self.generator:\n print (filepage)\n filepage.touch()","def generate_all(self, incremental=False):\n logger.info(\"Reading site contents\")\n self.load_template_if_needed()\n self.template.clear_caches()\n self.initialize()\n self.load_site_if_needed()\n self.events.begin_site()\n logger.info(\"Generating site to [%s]\" %\n self.site.config.deploy_root_path)\n self.__generate_node__(self.site.content, incremental)\n self.events.site_complete()\n self.finalize()\n self.generated_once = True","def generate_pages(self, writer):\r\n write = partial(writer.write_file,\r\n relative_urls=self.settings['RELATIVE_URLS'])\r\n\r\n # to minimize the number of relative path stuff modification\r\n # in writer, articles pass first\r\n self.generate_articles(write)\r\n self.generate_period_archives(write)\r\n self.generate_direct_templates(write)\r\n\r\n # and subfolders after that\r\n self.generate_tags(write)\r\n self.generate_categories(write)\r\n self.generate_authors(write)\r\n self.generate_drafts(write)","def on_files(self, files, config, **kwargs):\n linked_md_file = File(\n path=self.config[\"path_to_file\"],\n src_dir=self.config[\"path_to_src_dir\"],\n dest_dir=config[\"site_dir\"],\n use_directory_urls=config[\"use_directory_urls\"]\n )\n files.append(linked_md_file)\n return files","def _local_dir(self):\n return []","def save_all_files_locally(file_list, path):\n for file in file_list:\n home = os.getenv(\"HOME\")\n save_single_file_locally(path + file, home + \"/regulations-data/\")","def write_master_file( manga_plate_master, manga_fiberID_master,\n nsa_plate_master, nsa_fiberID_master, nsa_mjd_master,\n nsa_gal_idx_master, nsa_ra_master, nsa_dec_master,\n nsa_axes_ratio_master, nsa_phi_master, nsa_z_master,\n nsa_mStar_master,\n LOCAL_PATH):\n ###########################################################################\n # Convert the master data arrays into Column objects to add to the master\n # data table.\n #--------------------------------------------------------------------------\n manga_plate_col = Column( manga_plate_master)\n manga_fiberID_col = Column( manga_fiberID_master)\n nsa_plate_col = Column( nsa_plate_master)\n nsa_fiberID_col = Column( nsa_fiberID_master)\n nsa_mjd_col = Column( nsa_mjd_master)\n nsa_gal_idx_col = Column( nsa_gal_idx_master)\n nsa_ra_col = Column( nsa_ra_master)\n nsa_dec_col = Column( nsa_dec_master)\n nsa_axes_ratio_col = Column( nsa_axes_ratio_master)\n nsa_phi_col = Column( nsa_phi_master)\n nsa_z_col = Column( nsa_z_master)\n nsa_mStar_col = Column( nsa_mStar_master)\n ###########################################################################\n\n\n ###########################################################################\n # Add the column objects to an astropy QTable.\n #--------------------------------------------------------------------------\n master_table = QTable([ manga_plate_col,\n manga_fiberID_col,\n nsa_plate_col,\n nsa_fiberID_col,\n nsa_mjd_col,\n nsa_gal_idx_col,\n nsa_ra_col * u.degree,\n nsa_dec_col * u.degree,\n nsa_axes_ratio_col,\n nsa_phi_col * u.degree,\n nsa_z_col,\n nsa_mStar_col],\n names = ['MaNGA_plate',\n 'MaNGA_fiberID',\n 'NSA_plate',\n 'NSA_fiberID',\n 'NSA_MJD',\n 'NSA_index',\n 'NSA_RA',\n 'NSA_DEC',\n 'NSA_b/a',\n 'NSA_phi',\n 'NSA_redshift',\n 'NSA_mStar'])\n ###########################################################################\n\n\n ###########################################################################\n # Write the master data file in ecsv format.\n #--------------------------------------------------------------------------\n ascii.write( master_table, LOCAL_PATH + '/master_file.txt',\n format = 'ecsv',\n overwrite = True)\n ###########################################################################","def copy_unmanaged_files(self, reader):\n for entry in reader.index:\n if (\n entry.path == \"l10n.toml\"\n or entry.path.startswith(\"templates/\")\n or entry.path.startswith(\"locales/\")\n ):\n continue\n\n self.index.add(entry)","def add_metadata(self, infos: Dict[str, Any]) -> None:\n if self.output is None:\n raise RuntimeError(ERR_CLOSED_WRITER)\n self.output.add_metadata(infos)","def print_local_output_files_stats():\n print \"\\n\\nFILES CREATED:\"\n for filename in os.listdir('../output'):\n filesize = os.path.getsize('../output/' + filename)\n print str(filesize) + \"\\t\" + filename\n print \"\\n\"","def _load_files(self):\n for filedoc in self._docset.get_files():\n path = filedoc.get_path()\n if not path:\n # In case of only partially loaded file information,\n # the path information is not set for unloaded files.\n continue\n if not os.path.isabs(path):\n path = os.path.join(self._source_root, path)\n extension = os.path.splitext(path)[1]\n # We don't care about Markdown files that only produce pages\n # (and fail the directory check below).\n if extension == '.md':\n continue\n dirdoc = filedoc.get_directory()\n if not dirdoc:\n self._reporter.xml_assert(filedoc.get_xml_path(),\n \"file is not in any directory in Doxygen\")\n continue\n relpath = self._get_rel_path(path)\n fileobj = self._files.get(relpath)\n if not fileobj:\n fileobj = File(path, relpath, self._docmap[dirdoc])\n self._files[relpath] = fileobj\n fileobj.set_doc_xml(filedoc, self)\n self._docmap[filedoc] = fileobj","def saveMetadata(self):\n pickle.dump(self.metadata, open(self.metadataFile, 'w+b'))","def set_location(self):\n if self.has_non_empty_attribute(\"localitate\"):\n loc_item = None\n if utils.count_wikilinks(self.localitate) > 0:\n loc_link = utils.get_wikilinks(self.localitate)[0]\n loc_item = utils.q_from_wikipedia(\"ro\", loc_link.title)\n adm_item = self.get_statement_values(\"located_adm\")\n if loc_item and loc_item != adm_item[0]:\n self.add_statement(\"location\", loc_item)\n\n if not loc_item:\n self.add_to_report(\"localitate\", self.localitate, \"location\")","def download_meta(self):\n for f in self._manager.remote.list_contents(\".yml\"):\n self._manager.remote.download(f)","def test_maff(self):\n index_file = os.path.join(self.test_input, 'folder1#中文', 'mypage.maff')\n os.makedirs(os.path.dirname(index_file), exist_ok=True)\n with zipfile.ZipFile(index_file, 'w') as zh:\n zh.writestr('20200101000000000/index.html', \"\"\"\\\n<!DOCTYPE html>\n<html\n data-scrapbook-create=\"20200101000000000\"\n data-scrapbook-modify=\"20200101000000000\"\n data-scrapbook-source=\"http://example.com\">\n<head>\n<meta charset=\"UTF-8\">\n<title>MyTitle 中文</title>\n</head>\n<body>\npage content\n</body>\n</html>\n\"\"\")\n\n for _info in file2wsb.run(self.test_input, self.test_output):\n pass\n\n book = Host(self.test_output).books['']\n book.load_meta_files()\n book.load_toc_files()\n\n id_folder1, id_item = book.meta.keys()\n self.assertDictEqual(book.meta, {\n id_folder1: {\n 'title': 'folder1#中文',\n 'type': 'folder',\n 'create': id_folder1,\n 'modify': id_folder1,\n },\n id_item: {\n 'title': 'MyTitle 中文',\n 'type': '',\n 'index': f'{id_item}.maff',\n 'create': '20200101000000000',\n 'modify': '20200101000000000',\n 'source': 'http://example.com',\n 'icon': '',\n 'comment': '',\n },\n })\n self.assertDictEqual(book.toc, {\n 'root': [\n id_folder1,\n ],\n id_folder1: [\n id_item,\n ],\n })\n self.assertEqual(set(glob.iglob(os.path.join(self.test_output, '**'), recursive=True)), {\n os.path.join(self.test_output, ''),\n os.path.join(self.test_output, f'{id_item}.maff'),\n })","def writeXml(self):\n curdir = os.getcwd()\n os.chdir(self.Imagedir)\n allImageLists = [self.sciImlist, self.ctxImlist, self.wgtImlist, self.rmsImlist]\n \n for imlist in allImageLists:\n for im in imlist:\n file = xmlUtil.markupImage(im,dataset=self.obsName)\n \n # Don't write these images as output of this module, which\n # really doesn't have any.\n \n #if file not in self.outputList.keys():\n # self.outputList[file] = [im]\n \n os.chdir(curdir)\n return","def setup_local_site(self):\n raise NotImplementedError","def metadata_path(self):\n return os.path.join(self.path, 'metadata.txt')","def save_complete(self):\n self.save_assets(reset_html=False)\n # new_file(self.url_obj.file_path, content=tostring(self.lxml, encoding=self.encoding))\n self.lxml.getroottree().write(self.url_obj.file_path, method=\"html\")\n\n self._lxml = None # reset the tree","def sitemap():\n pages = []\n pages.append(['http://mattcarter.co/', '2018-07-21'])\n pages.append(['http://mattcarter.co/blog', '2018-07-21'])\n\n content_path = os.path.join(app.root_path, 'content')\n for file in os.listdir(content_path):\n if not file.endswith('.md'):\n continue\n full_path = os.path.join(content_path, file)\n post_obj = parse_markdown_post(full_path)\n url = 'http://mattcarter.co/blog/%s' % file.replace('.md', '')\n last_mod = post_obj.date\n pages.append([url, last_mod])\n\n response= make_response(render_template(\"sitemap.xml\", pages=pages))\n response.headers['Content-Type'] = 'application/xml'\n return response","def write_homepage(self, status_info):\n self.logger.info('writing homepage')\n with tempfile.NamedTemporaryFile(mode='w', dir=str(self.output_path),\n encoding='utf-8',\n delete=False) as index:\n try:\n index.file.write(self.homepage_template.format(**status_info))\n except BaseException:\n index.delete = True\n raise\n else:\n os.fchmod(index.file.fileno(), 0o664)\n os.replace(index.name, str(self.output_path / 'index.html'))","def registerDirMetaData(self, lfn, meta_dict):\n filename = os.path.basename(lfn)\n lpn = lfn.split(filename)[0].rstrip('/')\n res = self.fc.setMetadata(lpn, meta_dict)\n if not res['OK']:\n gLogger.error('Setting Meta Data from file (%s) on dir (%s) failed with message (%s)' %(filename, lpn, res['Message']))\n else:\n gLogger.info('Setting meta data on lpn (%s) succeeded' %lpn)\n ### res is either S_OK or S_ERROR\n return res","def prepare_info(self, infoxml_file):\n\n self.info = InfoXML(infoxml_file)\n\n if self.info.name:\n self.LOGGER << f\"Mod Name from info.xml: {self.info.name}\"\n\n self._install_dirname = self.info.name.lower()","def index_all_files(self, root_dir):\n pass","def create_master(asciitest_out_dir):\n # path join uses backslash under windows which is not cmake compatible\n filename_out = os.path.join(asciitest_out_dir, \"asciitest-master.cmake\").replace(\"\\\\\",\"/\")\n # path join uses backslash under windows which is not cmake compatible\n filename_in = os.path.join(asciitest_out_dir, \"asciitest-all_input_files.txt\").replace(\"\\\\\",\"/\")\n\n with open(filename_out + \".temp\", 'w') as f_out:\n for line in open(filename_in).readlines():\n f_out.write(\"# %s\" % line)\n # path join uses backslash win32 which is not cmake compatible\n cmake_include_filename = os.path.join(\n asciitest_out_dir,\n save_cmake_filename(line)).replace(\"\\\\\", \"/\")\n #print(\"create entry '%s'\" %cmake_include_filename)\n f_out.write(\"include(%s)\\n\" % cmake_include_filename )\n open(cmake_include_filename, 'a').close()\n\n update_if_different(filename_out + \".temp\", filename_out)","def write_manifests( file_lists, target_dir, output_dir ):\n for i, lst in enumerate( file_lists ):\n with open( os.path.join( output_dir, \"manifest-{}.txt\".format( i ) ), \"w\" ) as fout:\n for r in lst:\n fout.write( insert_rsync_marker( r, target_dir ) + \"\\n\" )","def writeContent(self):\n self.content = [(int(x.size), x.name) for x in self.tarfile.getmembers()]","def set_content(self):\n should_process = False # whether wiki page need to be updated\n soup = BeautifulSoup(self.body, \"html.parser\")\n\n try:\n # Test Cluster Wiki Page\n tag = soup.find(text=self.server_name).find_next('span').find(text=re.compile('4.[0-9].[0-9].[0-9](.[0-9]b[0-9]{1,4})?|UNKNOWN')).find_parent()\n print(str(tag))\n except Exception as e:\n print('No server name Found')\n print('Now Looking for IP address instead\\n')\n try:\n tag = soup.find(text=self.ip_addr).find_next('span').find(text=re.compile('4.[0-9].[0-9].[0-9](.[0-9]b[0-9]{1,4})?')).find_parent()\n print(str(tag))\n except:\n print('No IP address Found')\n print('Now Looking for alias name instead\\n')\n try:\n tag = soup.find_all(text=re.compile(self.alias_name+'.*'))[-1].find_next('span').find(text=re.compile('4.[0-9].[0-9].[0-9](.[0-9]b[0-9]{1,4})?|UNKNOWN')).find_parent()\n print(str(tag))\n except:\n print('No alias name Found')\n return should_process\n\n # compare unravel version in wiki page with local\n if tag.string and tag.string != self.unravel_version:\n tag.string = self.unravel_version\n should_process = True\n elif not tag.string and self.unravel_version:\n tag.string = self.unravel_version\n should_process = True\n\n # Create new wiki page content for update\n self.new_content = str(soup)\n return should_process","def __gen_pointing_file(self, top_level_layer):\n paula_id = '{}.{}.{}_{}_pointing'.format(top_level_layer,\n self.corpus_name, self.name,\n top_level_layer)\n self.paulamap['pointing'][top_level_layer] = paula_id\n E, tree = gen_paula_etree(paula_id)\n\n pointing_edges = select_edges_by(self.dg, layer=top_level_layer,\n edge_type=EdgeTypes.pointing_relation,\n data=True)\n pointing_dict = defaultdict(lambda: defaultdict(str))\n for source_id, target_id, edge_attrs in pointing_edges:\n pointing_dict[source_id][target_id] = edge_attrs\n\n # NOTE: we don't add a base file here, because the nodes could be\n # tokens or structural nodes\n rlist = E('relList')\n for source_id in pointing_dict:\n for target_id in pointing_dict[source_id]:\n source_href = self.__gen_node_href(top_level_layer, source_id)\n target_href = self.__gen_node_href(top_level_layer, target_id)\n rel = E('rel',\n {'id': 'rel_{}_{}'.format(source_id, target_id),\n XLINKHREF: source_href,\n 'target': target_href})\n\n # adds source/target node labels as a <!-- comment -->\n if self.human_readable:\n source_label = self.dg.node[source_id].get('label')\n target_label = self.dg.node[target_id].get('label')\n rel.append(Comment(u'{} - {}'.format(source_label,\n target_label)))\n rlist.append(rel)\n tree.append(rlist)\n self.files[paula_id] = tree\n self.file2dtd[paula_id] = PaulaDTDs.rel\n return paula_id","def create_master_turnstile_file(filenames, output_file):\n with open(output_file, 'w') as master_file:\n master_file.write('C/A,UNIT,SCP,DATEn,TIMEn,DESCn,ENTRIESn,EXITSn\\n')\n writer = csv.writer(master_file, delimiter=',')\n for filename in filenames:\n with open(filename, 'rb') as f:\n reader = csv.reader(f)\n for row in reader:\n writer.writerow(row)","def gather_documents(self):\n self.document_gatherer.gather_and_save_everything(Constants.path_cord, \n Constants.path_metadata, \n Constants.path_linked_documents,\n Constants.path_unlinked_documents,\n Constants.path_parsed_documents,\n Constants.path_all_documents)\n \n print(\"Done gathering documents.\")","def prepend_file(self, file_hex):\n new_file_byte_length = int(len(file_hex)/2)\n self._local_file_headers = f'{file_hex}{self._local_file_headers}'\n\n for header in self.get_central_dir_list():\n header.shift_relative_local_header_offset(new_file_byte_length)\n\n self._end_central_dir.shift_start_central_dir_start_offset(\n new_file_byte_length)","def write_map( file_lists, target_dir, output_dir ):\n tld_to_volumes = {}\n for i, group in enumerate( file_lists ):\n for node in group:\n tld = toplevel_subdir( node, target_dir )\n tld_to_volumes.setdefault( tld, set() ).add( i )\n with open( os.path.join( output_dir, \"map.txt\" ), \"w\" ) as fout:\n for tld, volumes in tld_to_volumes.items():\n fout.write( \"{:24s}: {}\\n\".format( tld, \" \".join( [ str( x ) for x in volumes ] ) ) )","def write(self):\n\n mr = MakoRenderer(self._TEMPLATE, StaticFlowEnvironment.rootTemplatePath, {'sitemap':self})\n result = mr.render()\n\n if not mr.success:\n self.site.writeLogError(unicode(mr.errorMessage))\n return False\n\n if not FileUtils.putContents(result, self.targetPath):\n self.site.writeLogError(u'Unable to save sitemap file at: \"%s\"' % self.targetPath)\n return False\n\n self.site.writeLogSuccess(u'SITEMAP', u'Created sitemap at: \"%s\"' % self.targetPath)\n return True","def process_master(\n session: Session, output_path: Path, service_names: List[ServiceName]\n) -> MasterPackage:\n logger.debug(f\"Parsing master\")\n master_package = parse_master_package(session, service_names)\n logger.debug(f\"Writing master to {NicePath(output_path)}\")\n\n modified_paths = write_master_package(master_package, output_path)\n for modified_path in modified_paths:\n logger.debug(f\"Updated {NicePath(modified_path)}\")\n\n return master_package","def add_masters_to_writer(ufos, regular, axes, writer):\n for font in ufos:\n family, style = font.info.familyName, font.info.styleName\n # MutatorMath.DesignSpaceDocumentWriter iterates over the location\n # dictionary, which is non-deterministic so it can cause test failures.\n # We therefore use an OrderedDict to which we insert in axis order.\n # Since glyphsLib will switch to DesignSpaceDocument once that is\n # integrated into fonttools, it's not worth fixing upstream.\n # https://github.com/googlei18n/glyphsLib/issues/165\n location = OrderedDict()\n for axis in axes:\n location[axis] = font.lib.get(\n GLYPHS_PREFIX + axis + 'Value', DEFAULT_LOCS[axis])\n is_regular = (font is regular)\n writer.addSource(\n path=font.path, name='%s %s' % (family, style),\n familyName=family, styleName=style, location=location,\n copyFeatures=is_regular, copyGroups=is_regular, copyInfo=is_regular,\n copyLib=is_regular)","def updateFrontPages(self):\n nTmessage(\"Starting %s\" % getCallerName())\n htmlDir = os.path.join(self.results_dir, \"HTML\")\n if os.path.isdir(htmlDir):\n# nTdebug(\"Removing original html directory for NRG-CING.\")\n rmdir(htmlDir)\n # end if\n nTmessage(\"Creating HTML directory for %s.\" % self.results_base)\n mkdirs(htmlDir)\n# srcHtmlPath = os.path.join(cingRoot, cingPaths.html) \n data_dir = os.path.join (self.base_dir, \"data\" )\n base_data_dir = os.path.join (data_dir, self.results_base )\n # Most crud can come in from the traditional method.\n copyCingHtmlJsAndCssToDirectory(htmlDir)\n \n nTmessage(\"Adding frontpage-specific html.\")\n fnList = \"\"\"\n about.html \n contact.html \n credits.html \n help.html \n helpCing.html \n helpPlot.html \n helpTutorials.html\n glossary.html \n index.html\n download.html \n plot.html \n cing.png \n icon_email.gif\n icon_reference.gif\n icon_website.png\n icon_youtube.jpeg\n icon_download.gif\n NRG-CING_circle.png\n \"\"\".split()\n for fn in fnList:\n srcFile = os.path.join(base_data_dir, fn)\n dstFile = os.path.join(htmlDir, fn)\n if not fn.endswith('.html'):\n copyfile(srcFile, dstFile)\n# nTdebug(\"-1- Added extra file %s.\" % dstFile)\n continue\n # end if\n file_content = open(srcFile, 'r').read() \n old_string = r\"<!-- INSERT NEW FOOTER HERE -->\"\n file_content = string.replace(file_content, old_string, self.htmlFooter)\n old_string = r\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE) \n old_string = r\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE) \n if fn != 'index.html':\n writeTextToFile(dstFile, file_content)\n# nTdebug(\"-2- Added extra file %s.\" % dstFile)\n continue\n # end if\n # Get framework input\n file_content = self._format_html(file_content) \n htmlfile = os.path.join(htmlDir, 'index.html')\n writeTextToFile(htmlfile, file_content)\n# nTdebug(\"-3- Written HTML index file: %s\" % htmlfile) \n # end for\n nTmessage(\"Copy the overall index\")\n org_file = os.path.join(data_dir, 'redirect.html')\n new_file = os.path.join(self.results_dir, 'index.html')\n shutil.copy(org_file, new_file)\n \n nTmessage(\"Copy the python cgi server for TableTools\\n\")\n cgi_file_name = 'DataTablesServer.py'\n if not os.path.exists(self.cgi_dir):\n nTerror(\"Please first create the server directory as expected at: %s\" % self.cgi_dir)\n return True\n # end if\n org_file = os.path.join(self.base_dir, 'server', cgi_file_name)\n new_file = os.path.join(self.cgi_dir, cgi_file_name)\n if os.path.exists(new_file): # remove because if it's a hard link the copy will fail.\n os.unlink(new_file)\n # end if\n shutil.copy(org_file, new_file)","def write_shortfile_table(self):\n\n # KMEL actually removes duplicate short filenames from this\n # table.\n\n start_of_shortfiles = self.db_file.tell()\n\n shortfiles = {}\n for miEntry in self.mainIndex:\n short_filename = miEntry.encodedShortfile\n if short_filename in shortfiles:\n miEntry.set_shortfile_offset(\n shortfiles[short_filename])\n else:\n shortfiles[short_filename] = \\\n self.db_file.tell() - start_of_shortfiles\n\n miEntry.set_shortfile_offset(\n shortfiles[short_filename])\n self.db_file.write(short_filename)","def write_downloaded_links():\n global downloaded_links_fn\n text_file = open(downloaded_links_fn,\"w\")\n for link in downloaded_links.items():\n text_file.write(link[0] + \"\\n\")\n text_file.close()","def test_path04(self):\n index_file = os.path.join(self.test_input, 'index.html')\n with open(index_file, 'w', encoding='UTF-8') as fh:\n fh.write(\"\"\"\\\n<!DOCTYPE html>\n<html\n data-scrapbook-create=\"20200101000000000\"\n data-scrapbook-modify=\"20200101000000000\"\n data-scrapbook-source=\"http://example.com\">\n<head>\n<meta charset=\"UTF-8\">\n<title>MyTitle 中文</title>\n</head>\n<body>\npage content\n</body>\n</html>\n\"\"\")\n\n for _info in file2wsb.run(self.test_input, self.test_output):\n pass\n\n book = Host(self.test_output).books['']\n book.load_meta_files()\n book.load_toc_files()\n\n id_item, = book.meta.keys()\n self.assertDictEqual(book.meta, {\n id_item: {\n 'title': 'MyTitle 中文',\n 'type': '',\n 'index': f'{id_item}/index.html',\n 'create': '20200101000000000',\n 'modify': '20200101000000000',\n 'source': 'http://example.com',\n 'icon': '',\n 'comment': '',\n },\n })\n self.assertDictEqual(book.toc, {\n 'root': [\n id_item,\n ],\n })\n self.assertEqual(set(glob.iglob(os.path.join(self.test_output, '**'), recursive=True)), {\n os.path.join(self.test_output, ''),\n os.path.join(self.test_output, id_item),\n os.path.join(self.test_output, id_item, 'index.html'),\n })","def test_path05(self):\n index_file = os.path.join(self.test_input, 'index.html')\n with open(index_file, 'w', encoding='UTF-8') as fh:\n fh.write(\"\"\"\\\n<!DOCTYPE html>\n<html\n data-scrapbook-create=\"20200101000000000\"\n data-scrapbook-modify=\"20200101000000000\"\n data-scrapbook-source=\"http://example.com\">\n<head>\n<meta charset=\"UTF-8\">\n<title>MyTitle 中文</title>\n</head>\n<body>\npage content\n</body>\n</html>\n\"\"\")\n\n for _info in file2wsb.run(self.test_input, self.test_output, no_preserve_filename=True):\n pass\n\n book = Host(self.test_output).books['']\n book.load_meta_files()\n book.load_toc_files()\n\n id_item, = book.meta.keys()\n self.assertDictEqual(book.meta, {\n id_item: {\n 'title': 'MyTitle 中文',\n 'type': '',\n 'index': f'{id_item}.html',\n 'create': '20200101000000000',\n 'modify': '20200101000000000',\n 'source': 'http://example.com',\n 'icon': '',\n 'comment': '',\n },\n })\n self.assertDictEqual(book.toc, {\n 'root': [\n id_item,\n ],\n })\n self.assertEqual(set(glob.iglob(os.path.join(self.test_output, '**'), recursive=True)), {\n os.path.join(self.test_output, ''),\n os.path.join(self.test_output, f'{id_item}.html'),\n })","def test_history_import_abspath_in_metadata():\n with HistoryArchive() as history_archive:\n history_archive.write_metafiles(\n dataset_file_name=os.path.join(history_archive.temp_directory, 'outside.txt'))\n history_archive.write_file('datasets/Pasted_Entry_1.txt', 'foo')\n history_archive.write_outside()\n _run_jihaw_cleanup_check_secure(history_archive, 'Absolute path in datasets_attrs.txt allowed')","def writeOutServers(self):\n # we'll be writing out to the server tracker file, overwriting\n # anything that may exist in it\n global server_tracker_file\n \n with open(server_tracker_file, 'wb') as outfile:\n # let's leverage the printStatus method we have\n outfile.write(self.printStatus())\n \n return","def export_at_once(export_dir, page_names):\r\n\r\n print 'Getting export with full list of pages'\r\n pages_param = '\\n'.join(page_names)\r\n export_filename = os.path.join(export_dir, 'wiki_export.xml')\r\n get_export(pages_param, export_filename)\r\n\r\n return [export_filename]","def savemetadata(self, newmeta):\n with open(self.outputMetadata, 'w') as f:\n json.dump(newmeta, f)","def writeDomainFile():\n writeTemplate(localTemplate)"],"string":"[\n \"def _build_local_metadata_file(files, home=''):\\n filepaths = [os.path.join(home, f) for f in files]\\n shas = [_get_sha_metadata(f) for f in filepaths]\\n metadata = dict(zip(files, shas))\\n\\n with open(LOCAL_METADATA_FILE, 'w') as f:\\n f.write(json.dumps(metadata))\",\n \"def master_archive(f, e):\\n template = e.get_template(TEMPLATES['archive'])\\n write_file(\\\"archives.html\\\", template.render(entries=f))\",\n \"def writeInfo(self, location=None, masters=None):\\n if self.currentInstance is None:\\n return\\n infoElement = ET.Element(\\\"info\\\")\\n if location is not None:\\n locationElement = self._makeLocationElement(location)\\n infoElement.append(locationElement)\\n self.currentInstance.append(infoElement)\",\n \"def _write_meta(self, parameter_set_files):\\n # Always overwrite the meta data file to ensure that *all* parameter file names are included.\\n with open(self.parameter_study_meta_file, 'w') as meta_file:\\n if self.output_file:\\n meta_file.write(f\\\"{self.output_file.resolve()}\\\\n\\\")\\n else:\\n for parameter_set_file in parameter_set_files:\\n meta_file.write(f\\\"{parameter_set_file.resolve()}\\\\n\\\")\",\n \"def set_dirinfo(self):\\n self.hostname = globals.hostname\\n self.local_dirname = globals.local_path.name # @UndefinedVariable\\n if self.fh:\\n if self.hostname:\\n self.fh.write(\\\"Hostname %s\\\\n\\\" % self.hostname)\\n if self.local_dirname:\\n self.fh.write(\\\"Localdir %s\\\\n\\\" % Quote(self.local_dirname))\\n return self\",\n \"def metadata_callback(files): # type: (t.List[t.Tuple[str, str]]) -> None\\n config = self\\n\\n if config.metadata_path:\\n files.append((os.path.abspath(config.metadata_path), config.metadata_path))\",\n \"def write_metadata(dir_path, fs, *metas, global_metadata=True):\\n assert metas\\n md = metas[0]\\n with fs.open(\\\"/\\\".join([dir_path, \\\"_common_metadata\\\"]), \\\"wb\\\") as fil:\\n md.write_metadata_file(fil)\\n if global_metadata:\\n for meta in metas[1:]:\\n md.append_row_groups(meta)\\n with fs.open(\\\"/\\\".join([dir_path, \\\"_metadata\\\"]), \\\"wb\\\") as fil:\\n md.write_metadata_file(fil)\",\n \"def generate_metadata(self):\\n self.metadata = {\\n 'title': os.path.basename(self.source_file).rsplit('.', 1)[0],\\n 'url': self.relative_destination_file,\\n 'full_path': os.path.dirname(self.relative_destination_file),\\n 'short_path': self.shorten_path(\\n os.path.dirname(self.relative_destination_file))\\n }\",\n \"def generate_metadata_files(self):\\n\\n data_folder = self.get_data_folder(mode='absolute')\\n\\n parents = (data_folder / '_').parents\\n\\n for mfile in self.mdata:\\n for regex, level in METADATA_LEVEL_BY_NAME.items():\\n if re.compile(regex).match(mfile.name):\\n create_file(mfile, parents[(3-level)] / mfile.name,\\n mode='copy')\",\n \"def detail_pages(f, e):\\n template = e.get_template(TEMPLATES['detail'])\\n for file in f:\\n write_file(file['url'], template.render(entry=file, entries=f))\",\n \"def __appendMetaData(self, filename):\\n metadata = {'Model': 'LFM',\\n 'Source': filename,\\n 'Date processed': datetime.datetime.now(),\\n 'Start date': self.startDate\\n }\\n \\n self.data.append(key='meta',\\n name='Metadata for LFM Solar Wind file',\\n units='n/a',\\n data=metadata)\",\n \"def write_sitemaps():\\n sitemap_index = open('static/sitemaps/sitemap.xml', 'w')\\n sitemap_index.write('<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n<sitemapindex xmlns=\\\"http://www.sitemaps.org/schemas/sitemap/0.9\\\">\\\\n')\\n\\n max_urls = 50000\\n page_count = 0\\n url_count = 0\\n sitemap_file = None\\n\\n for loc, last_mod in sitemap_urls():\\n\\n # if we've maxed out the number of urls per sitemap \\n # close out the one we have open and open a new one\\n if url_count % max_urls == 0:\\n page_count += 1\\n if sitemap_file: \\n sitemap.write('</urlset>\\\\n')\\n sitemap.close()\\n sitemap_file = 'sitemap-%05d.xml' % page_count\\n sitemap_path = 'static/sitemaps/%s' % sitemap_file\\n _logger.info(\\\"writing %s\\\" % sitemap_path)\\n sitemap = open(sitemap_path, 'w')\\n sitemap.write('<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n<urlset xmlns=\\\"http://www.sitemaps.org/schemas/sitemap/0.9\\\">\\\\n')\\n sitemap_index.write('<sitemap><loc>http://chroniclingamerica.loc.gov/%s</loc></sitemap>\\\\n' % sitemap_file)\\n \\n # add a url to the sitemap\\n sitemap.write(\\\"<url><loc>http://chroniclingamerica.loc.gov%s</loc><lastmod>%s</lastmod></url>\\\\n\\\" % (loc, rfc3339(last_mod)))\\n url_count += 1\\n\\n # necessary to avoid memory bloat when settings.DEBUG = True\\n if url_count % 1000 == 0:\\n reset_queries()\\n\\n # wrap up some open files\\n sitemap.write('</urlset>\\\\n')\\n sitemap.close()\\n sitemap_index.write('</sitemapindex>\\\\n')\\n sitemap_index.close()\",\n \"def files(self):\\n if os.path.exists(self.xml_file):\\n self.xml_link='<li>XML <a href=\\\"../../%(xml_file)s?download=true\\\">%(xml_file)s</a></li>'.format(self.xml_file)\\n else:\\n self.xml_link=''\\n # <a href=\\\"../../%(xml)s?download=true\\\">%(xml)s</a></li>\\n #self.xml = glob.glob('*.xml')[0]\",\n \"def main():\\n \\n root = Folder(name=os.getcwd(), file='meta.json',\\n collection='.github/jekyll')\\n root.update()\\n root.export_folders(True)\",\n \"def targetPath(self):\\n return FileUtils.createPath(self.site.targetWebRootPath, 'sitemap.xml', isFile=True)\",\n \"def masterPath(self):\\n\\t\\treturn fl.File( self._path + '/master.data' )\",\n \"def _write_master(self):\\n text = _condor_master_template % {\\n 'meds_files':self.meds_files,\\n }\\n master_script=files.get_condor_master_path(self['run'])\\n print('writing master:',master_script)\\n with open(master_script,'w') as fobj:\\n fobj.write(text)\\n\\n os.system('chmod 755 %s' % master_script)\",\n \"def create_output_loc(self):\\n self.output_name = [self.args.xml_out, 'gatk4_' + self.json_file['name'].lower().split(' ')[0] + '.xml']\\n if not self.args.xml_out.endswith('/'):\\n return '/'.join(self.output_name)\\n else:\\n return ''.join(self.output_name)\",\n \"def publish_metadata_in_ipfs(self):\\n self._printout(self._publish_metadata_in_ipfs(self.args.metadata_file))\",\n \"def on_new_site(self, files):\\n init_index()\",\n \"def getLocalFiles(self):\\r\\n\\r\\n for dirpath, dirnames, filenames in os.walk(self.dlLocation):\\r\\n for name in filenames:\\r\\n currentPath = os.path.join(dirpath, name)\\r\\n currentPath = re.sub('^\\\\w:', '', currentPath)\\r\\n currentPath = re.sub(r\\\"\\\\\\\\\\\",'/', currentPath)\\r\\n self.localStore.append(currentPath)\\r\\n\\r\\n return self.localStore\",\n \"def _update_filesystem_metadata(self, metadata):\\n directory, fname = os.path.split(self.fname)\\n fbase = os.path.splitext(fname)[0]\\n \\n # Test for presence and size of zip file\\n zip_file = fbase + '.zip'\\n zip_path = os.path.join(directory, zip_file)\\n \\n if os.path.isfile(zip_path):\\n location = 'on_disk'\\n data_file_size = os.path.getsize(zip_path)\\n else:\\n location = 'on_tape'\\n data_file_size = 0\\n \\n # Test for presence of quick look PNG file\\n quicklook_file = fbase + '.png'\\n quicklook_path = os.path.join(directory, quicklook_file)\\n \\n if not os.path.isfile(quicklook_path):\\n quicklook_file = ''\\n\\n # Add to metadata dictionary\\n item_map = {'directory': directory, 'metadata_file': fname,\\n 'data_file': zip_file, 'location': location, \\n 'data_file_size': data_file_size, 'quicklook_file': quicklook_file}\\n \\n for key, value in item_map.items():\\n metadata[key] = value\",\n \"def copy_metadata():\\n\\n common_root = os.path.join(os.path.dirname(__file__), \\\"wsdotroute\\\", \\\"esri\\\")\\n src = os.path.join(common_root, \\\"toolboxes\\\")\\n dest = os.path.join(common_root, \\\"help\\\", \\\"gp\\\", \\\"toolboxes\\\")\\n\\n if os.path.exists(dest):\\n shutil.rmtree(dest)\\n\\n shutil.copytree(src, dest, ignore=shutil.ignore_patterns(\\\"*.pyt\\\"))\\n\\n print(\\\"Completed copying metadata XML files\\\")\",\n \"def _add_filename_metadata(self, extra_metadata): \\n \\n # Make sure product_info section exists\\n extra_metadata.setdefault('product_info', {})\\n \\n file_name = os.path.basename(self.fname)\\n fn_comps = file_name.split(\\\"_\\\")\\n \\n if self.__class__ == SAFESentinel1:\\n component = fn_comps[2]\\n if len(component) < 4: \\n resolution = 'N/A'\\n else:\\n resolution = component[-1]\\n \\n extra_metadata['product_info']['Resolution'] = resolution\\n \\n # Add file/scan name \\n extra_metadata['product_info']['Name'] = os.path.splitext(file_name)[0]\\n \\n # Add Satellite and Mission from the file path\\n comp_1 = fn_comps[0].upper()\\n extra_metadata['platform']['Mission'] = \\\"Sentinel-%s\\\" % comp_1[1]\\n extra_metadata['platform']['Satellite'] = \\\"Sentinel-%s\\\" % comp_1[1:]\",\n \"def _add_redirects(self):\\n with open(REDIRECTS_FILE, encoding=\\\"utf-8\\\") as mapping_fd:\\n reader = csv.reader(mapping_fd)\\n for row in reader:\\n if not row or row[0].strip().startswith(\\\"#\\\"):\\n continue\\n\\n html_path = os.path.join(BUILD_PATH, \\\"html\\\")\\n path = os.path.join(html_path, *row[0].split(\\\"/\\\")) + \\\".html\\\"\\n\\n if not self.include_api and (\\n os.path.join(html_path, \\\"reference\\\") in path\\n or os.path.join(html_path, \\\"generated\\\") in path\\n ):\\n continue\\n\\n try:\\n title = self._get_page_title(row[1])\\n except Exception:\\n # the file can be an ipynb and not an rst, or docutils\\n # may not be able to read the rst because it has some\\n # sphinx specific stuff\\n title = \\\"this page\\\"\\n\\n with open(path, \\\"w\\\", encoding=\\\"utf-8\\\") as moved_page_fd:\\n html = f\\\"\\\"\\\"\\\\\\n<html>\\n <head>\\n <meta http-equiv=\\\"refresh\\\" content=\\\"0;URL={row[1]}.html\\\"/>\\n </head>\\n <body>\\n <p>\\n The page has been moved to <a href=\\\"{row[1]}.html\\\">{title}</a>\\n </p>\\n </body>\\n<html>\\\"\\\"\\\"\\n\\n moved_page_fd.write(html)\",\n \"def load_metadata(self):\\n handler = open('meta.xml').read()\\n soup = BeautifulSoup(handler, 'xml')\\n\\n for meta in soup.find_all(re.compile(\\\"^title\\\")):\\n if meta.string:\\n self.meta_title = unicode(meta.string)\\n\\n for meta in soup.find_all(re.compile(\\\"^initial.creator\\\")):\\n if meta.string:\\n self.meta_initial_creator = unicode(meta.string)\\n\\n for meta in soup.find_all(re.compile(\\\"^date\\\")):\\n if meta.string:\\n self.meta_date = unicode(meta.string)\",\n \"def _save_metadata(self, search_name):\\r\\n with open_(self.output_path / \\\"metadata\\\", \\\"a\\\") as f:\\r\\n f.write(\\r\\n f\\\"\\\"\\\"name={self.name}\\r\\n non_linear_search={search_name}\\r\\n \\\"\\\"\\\"\\r\\n )\",\n \"def set_local_path(self):\\n return HERE\",\n \"def generate_metadata(self):\\n if self.options.mbtiles:\\n return\\n if not os.path.exists(self.output):\\n os.makedirs(self.output)\\n\\n if self.options.profile == 'mercator':\\n\\n south, west = self.mercator.MetersToLatLon( self.ominx, self.ominy)\\n north, east = self.mercator.MetersToLatLon( self.omaxx, self.omaxy)\\n south, west = max(-85.05112878, south), max(-180.0, west)\\n north, east = min(85.05112878, north), min(180.0, east)\\n self.swne = (south, west, north, east)\\n\\n # Generate googlemaps.html\\n if self.options.webviewer in ('all','google') and self.options.profile == 'mercator':\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'googlemaps.html')):\\n f = open(os.path.join(self.output, 'googlemaps.html'), 'w')\\n f.write( self.generate_googlemaps() )\\n f.close()\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all','openlayers'):\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\\n f.write( self.generate_openlayers() )\\n f.close()\\n\\n elif self.options.profile == 'geodetic':\\n\\n west, south = self.ominx, self.ominy\\n east, north = self.omaxx, self.omaxy\\n south, west = max(-90.0, south), max(-180.0, west)\\n north, east = min(90.0, north), min(180.0, east)\\n self.swne = (south, west, north, east)\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all','openlayers'):\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\\n f.write( self.generate_openlayers() )\\n f.close()\\n\\n elif self.options.profile in ['raster','gearth','garmin']:\\n\\n west, south = self.ominx, self.ominy\\n east, north = self.omaxx, self.omaxy\\n\\n self.swne = (south, west, north, east)\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all','openlayers'):\\n if not self.options.resume or not os.path.exists(os.path.join(self.output, 'openlayers.html')):\\n f = open(os.path.join(self.output, 'openlayers.html'), 'w')\\n f.write( self.generate_openlayers() )\\n f.close()\\n\\n\\n # Generate tilemapresource.xml.\\n if (self.options.tile_format != 'hybrid' and self.options.profile != 'garmin'\\n and (not self.options.resume or not os.path.exists(os.path.join(self.output, 'tilemapresource.xml')))):\\n f = open(os.path.join(self.output, 'tilemapresource.xml'), 'w')\\n f.write( self.generate_tilemapresource())\\n f.close()\",\n \"def write_sitemap ( self ):\\n try:\\n self.output_fd = open ( file=dflt_cfg.DFLT_CFG[ OUTPUT_PATH ], mode='w' )\\n self.print_url_links ( self.root )\\n except (PermissionError, AttributeError) as err:\\n self.logger.error ( \\\"Error {0} occurred. Output file {1} cannot be created\\\".format ( err, \\\\\\n dflt_cfg.DFLT_CFG[\\n OUTPUT_PATH ] ) )\\n except Exception as err:\\n self.logger.error ( \\\"Error {0} occurred while writing sitemap in output file: {1}\\\".format ( err, \\\\\\n dflt_cfg.DFLT_CFG[ OUTPUT_PATH ] ) )\\n self.output_fd.close ( )\\n else:\\n print(\\\"Sitemap for {} is written in {}.\\\".format(dflt_cfg.DFLT_CFG[DOMAIN], dflt_cfg.DFLT_CFG[ OUTPUT_PATH ]))\\n print( \\\"Logs (Broken or dead URLs along with application logs) for domain {0} are available in {1} directory.\\\".format ( dflt_cfg.DFLT_CFG[DOMAIN], \\\"./logs\\\" ) )\\n self.output_fd.close ( )\",\n \"def save_master(master_directory):\\n global MASTER_SHELF\\n MASTER_SHELF = shelve.open(str(PurePath(SHELF_DIR / \\\"MASTER_SHELF\\\")))\\n MASTER_SHELF[\\\"master\\\"] = master_directory\\n MASTER_SHELF.close()\",\n \"def _add_redirects(self):\\n with open(REDIRECTS_FILE) as mapping_fd:\\n reader = csv.reader(mapping_fd)\\n for row in reader:\\n if not row or row[0].strip().startswith(\\\"#\\\"):\\n continue\\n\\n html_path = os.path.join(BUILD_PATH, \\\"html\\\")\\n path = os.path.join(html_path, *row[0].split(\\\"/\\\")) + \\\".html\\\"\\n\\n if not self.include_api and (\\n os.path.join(html_path, \\\"reference\\\") in path\\n or os.path.join(html_path, \\\"generated\\\") in path\\n ):\\n continue\\n\\n try:\\n title = self._get_page_title(row[1])\\n except Exception:\\n # the file can be an ipynb and not an rst, or docutils\\n # may not be able to read the rst because it has some\\n # sphinx specific stuff\\n title = \\\"this page\\\"\\n\\n with open(path, \\\"w\\\") as moved_page_fd:\\n html = f\\\"\\\"\\\"\\\\\\n<html>\\n <head>\\n <meta http-equiv=\\\"refresh\\\" content=\\\"0;URL={row[1]}.html\\\"/>\\n </head>\\n <body>\\n <p>\\n The page has been moved to <a href=\\\"{row[1]}.html\\\">{title}</a>\\n </p>\\n </body>\\n<html>\\\"\\\"\\\"\\n\\n moved_page_fd.write(html)\",\n \"def do_root(self, line):\\n self.root_directory = line\\n if self.source_file:\\n self.source_file = self.root_directory + \\\"/\\\" + self.source_file\\n print(f\\\"Root directory to read & write files is: {line}\\\")\",\n \"def addMasters(self,masterNames):\\n #--Load Masters\\n #--Master FileRefs\\n proItems = []\\n totSize = 0\\n for masterName in masterNames:\\n #--Don't have fileRef? FileRef out of date?\\n masterInfo = modInfos[masterName]\\n fileRefs = masterInfo.extras.get('FileRefs')\\n if not fileRefs:\\n fileRefs = masterInfo.extras['FileRefs'] = FileRefs(masterInfo,True,True)\\n fileRefs.setDebrisIds()\\n refreshSize = fileRefs.refreshSize()\\n if refreshSize:\\n proItems.append((fileRefs,refreshSize))\\n totSize += refreshSize\\n #--Refresh masters\\n cumSize = 0\\n for (fileRefs,size) in proItems:\\n self.progress.setBaseScale(1.0*cumSize/totSize, 1.0*size/totSize)\\n fileRefs.progress = self.progress\\n fileRefs.refresh()\\n cumSize += size\\n #--Do Mapping\\n del proItems[:]\\n totSize = 0\\n for masterName in masterNames:\\n size = len(modInfos[masterName].extras['FileRefs'].cells)\\n proItems.append((masterName,size))\\n totSize += size\\n cumSize = 0\\n for (masterName,size) in proItems:\\n if size: self.progress.setBaseScale(1.0*cumSize/totSize, 1.0*size/totSize)\\n self.addMaster(masterName)\\n cumSize += size\",\n \"def save_meta(self):\\n # jOut = os.path.join(self.meta[\\\"wdir\\\"], meta_file)\\n with open(self.meta_filepath, \\\"w\\\") as f:\\n json.dump(self.meta, f)\",\n \"def _newfile(counter):\\n name = '%s/sitemap-%s.xml.gz' % (settings.SITEMAPS_DIR,\\n counter)\\n fp = gzip.open(name, 'wb')\\n fp.write(\\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n<urlset xmlns=\\\"http://www.sitemaps.org/schemas/sitemap/0.9\\\">\\\\n\\\"\\\"\\\")\\n return fp\",\n \"def edited_file_locations(self):\",\n \"def test_existing_current_files(self):\\n\\n m = Mothur(**self.init_vars)\\n self.set_current_dirs(m)\\n m.summary.seqs(fasta='test_fasta_1.fasta')\\n m.summary.seqs()\\n\\n return\",\n \"def build_masters(opts):\\n logger.info(\\\"Reading designspace file...\\\")\\n ds = DesignSpaceDocument.fromfile(opts.dsPath)\\n validateDesignspaceDoc(ds)\\n master_paths = [s.path for s in ds.sources]\\n\\n logger.info(\\\"Building local OTFs for master font paths...\\\")\\n curDir = os.getcwd()\\n dsDir = os.path.dirname(opts.dsPath)\\n\\n for master_path in master_paths:\\n master_path = os.path.join(dsDir, master_path)\\n masterDir = os.path.dirname(master_path)\\n ufoName = os.path.basename(master_path)\\n otfName = os.path.splitext(ufoName)[0]\\n otfName = f\\\"{otfName}.otf\\\"\\n\\n if masterDir:\\n os.chdir(masterDir)\\n\\n makeotf(['-nshw', '-f', ufoName, '-o', otfName,\\n '-r', '-nS'] + opts.mkot)\\n logger.info(f\\\"Built OTF font for {master_path}\\\")\\n generalizeCFF(otfName)\\n os.chdir(curDir)\",\n \"def load_xml_files_erisk(local_dir, token_position=0):\\n users = {}\\n prep = Preprocessor()\\n c = 0\\n for dir_path, dir_names, filenames in os.walk(local_dir):\\n for name in filenames:\\n tok = name.split(\\\"_\\\")\\n if token_position > 0:\\n key = tok[0] + tok[token_position]\\n else:\\n key = tok[token_position]\\n key = key.strip(\\\".xml\\\")\\n full_file = os.path.abspath(os.path.join(dir_path, name))\\n dom = ET.parse(full_file, parser=ET.XMLParser(encoding=\\\"utf-8\\\"))\\n writing = dom.findall('WRITING')\\n for w in writing:\\n title = w.find('TITLE').text\\n text = w.find('TEXT').text\\n post = title + \\\" \\\" + text\\n # preprocess text\\n new_text = prep.tokenize_reddit(post)\\n\\n if key in users.keys():\\n users[key] += new_text + ' end_ '\\n else:\\n users[key] = new_text + ' end_ '\\n\\n c += 1\\n print(\\\"Preprocessed chunk: \\\", c)\\n\\n return users\",\n \"def add_file_metadata(self):\\n metadata = self.__file.require_group(METADATA)\\n self.__write_value(metadata, DATE_CREATED, date.today().strftime(\\\"%Y-%m-%d\\\"))\\n self.__write_value(metadata, SDK_VERSION, __version__)\",\n \"def run(self, info):\\n\\n # Write the metadata to the file's xattrs\\n self._downloader.to_screen('[metadata] Writing metadata to file\\\\'s xattrs')\\n\\n filename = info['filepath']\\n\\n try:\\n xattr_mapping = {\\n 'user.xdg.referrer.url': 'webpage_url',\\n # 'user.xdg.comment': 'description',\\n 'user.dublincore.title': 'title',\\n 'user.dublincore.date': 'upload_date',\\n 'user.dublincore.description': 'description',\\n 'user.dublincore.contributor': 'uploader',\\n 'user.dublincore.format': 'format',\\n }\\n\\n num_written = 0\\n for xattrname, infoname in xattr_mapping.items():\\n\\n value = info.get(infoname)\\n\\n if value:\\n if infoname == 'upload_date':\\n value = hyphenate_date(value)\\n\\n byte_value = value.encode('utf-8')\\n write_xattr(filename, xattrname, byte_value)\\n num_written += 1\\n\\n return [], info\\n\\n except XAttrUnavailableError as e:\\n self._downloader.report_error(str(e))\\n return [], info\\n\\n except XAttrMetadataError as e:\\n if e.reason == 'NO_SPACE':\\n self._downloader.report_warning(\\n 'There\\\\'s no disk space left, disk quota exceeded or filesystem xattr limit exceeded. '\\n + (('Some ' if num_written else '') + 'extended attributes are not written.').capitalize())\\n elif e.reason == 'VALUE_TOO_LONG':\\n self._downloader.report_warning(\\n 'Unable to write extended attributes due to too long values.')\\n else:\\n msg = 'This filesystem doesn\\\\'t support extended attributes. '\\n if compat_os_name == 'nt':\\n msg += 'You need to use NTFS.'\\n else:\\n msg += '(You may have to enable them in your /etc/fstab)'\\n self._downloader.report_error(msg)\\n return [], info\",\n \"def update_metadata(self):\\n parser = GenericParser(\\n fn_re='{}/(e\\\\d+s\\\\d+)_.*/Production.nc'.format(self.data_folder),\\n group_names=['sim'],\\n group_transforms=[lambda x: x],\\n top_fn='',\\n step_ps=self.timestep\\n )\\n meta = gather_metadata('{}/e*/*nc'.format(self.data_folder), parser)\\n meta['top_fn'] = sorted(glob('{}/e*/structure.prmtop'.format(self.input_folder)))\\n self.meta = meta\",\n \"def collect_outputs(self):\\n # collect submex output hdf urls and add them to top mex outputs section\\n top_mex = self.bqSession.fetchxml(self.options.mexURL, view='deep')\\n outputTag = top_mex.xpath('/mex/tag[@name=\\\"outputs\\\"]')\\n if not outputTag:\\n # no \\\"outputs\\\" tag in mex => add it now\\n etree.SubElement(top_mex, 'tag', name='outputs') \\n top_mex = self.bqSession.postxml(url=top_mex.get('uri'), xml=top_mex, view='deep')\\n outputTag = top_mex.xpath('/mex/tag[@name=\\\"outputs\\\"]')\\n outputTag = outputTag[0]\\n output_hdfs = top_mex.xpath('/mex/mex/tag[@name=\\\"outputs\\\"]/tag[@name=\\\"output_hdf\\\"]/@value')\\n etree.SubElement(outputTag, 'tag', name='all_outputs', value=';'.join([ohdf.split('/')[-1] for ohdf in output_hdfs]))\\n self.bqSession.postxml(url=outputTag.get('uri'), xml=outputTag)\",\n \"def toc_add_files(self, refnodes: list[dict[str, Any]]) -> None:\\n refnodes.insert(0, {\\n 'level': 1,\\n 'refuri': html.escape(self.config.root_doc + self.out_suffix),\\n 'text': ssp(html.escape(\\n self.env.titles[self.config.root_doc].astext())),\\n })\\n for file, text in reversed(self.config.epub_pre_files):\\n refnodes.insert(0, {\\n 'level': 1,\\n 'refuri': html.escape(file),\\n 'text': ssp(html.escape(text)),\\n })\\n for file, text in self.config.epub_post_files:\\n refnodes.append({\\n 'level': 1,\\n 'refuri': html.escape(file),\\n 'text': ssp(html.escape(text)),\\n })\",\n \"def maps():\\n flatmap_list = []\\n root_path = pathlib.Path(settings['FLATMAP_ROOT'])\\n if root_path.is_dir():\\n for flatmap_dir in root_path.iterdir():\\n index = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.json')\\n mbtiles = os.path.join(settings['FLATMAP_ROOT'], flatmap_dir, 'index.mbtiles')\\n if os.path.isdir(flatmap_dir) and os.path.exists(index) and os.path.exists(mbtiles):\\n with open(index) as fp:\\n index = json.loads(fp.read())\\n version = index.get('version', 1.0)\\n reader = MBTilesReader(mbtiles)\\n if version >= 1.3:\\n metadata = read_metadata(reader, 'metadata')\\n if (('id' not in metadata or flatmap_dir.name != metadata['id'])\\n and ('uuid' not in metadata or flatmap_dir.name != metadata['uuid'].split(':')[-1])):\\n app.logger.error(f'Flatmap id mismatch: {flatmap_dir}')\\n continue\\n flatmap = {\\n 'id': metadata['id'],\\n 'source': metadata['source'],\\n 'version': version\\n }\\n if 'created' in metadata:\\n flatmap['created'] = metadata['created']\\n if 'taxon' in metadata:\\n flatmap['taxon'] = normalise_identifier(metadata['taxon'])\\n flatmap['describes'] = metadata['describes'] if 'describes' in metadata else flatmap['taxon']\\n elif 'describes' in metadata:\\n flatmap['taxon'] = normalise_identifier(metadata['describes'])\\n flatmap['describes'] = flatmap['taxon']\\n if 'biological-sex' in metadata:\\n flatmap['biologicalSex'] = metadata['biological-sex']\\n if 'uuid' in metadata:\\n flatmap['uuid'] = metadata['uuid']\\n if 'name' in metadata:\\n flatmap['name'] = metadata['name']\\n else:\\n try:\\n source_row = reader._query(\\\"SELECT value FROM metadata WHERE name='source'\\\").fetchone()\\n except (InvalidFormatError, sqlite3.OperationalError):\\n flask.abort(404, 'Cannot read tile database: {}'.format(mbtiles))\\n if source_row is None:\\n continue\\n flatmap = {\\n 'id': flatmap_dir.name,\\n 'source': source_row[0]\\n }\\n created = reader._query(\\\"SELECT value FROM metadata WHERE name='created'\\\").fetchone()\\n if created is not None:\\n flatmap['created'] = created[0]\\n describes = reader._query(\\\"SELECT value FROM metadata WHERE name='describes'\\\").fetchone()\\n if describes is not None and describes[0]:\\n flatmap['describes'] = normalise_identifier(describes[0])\\n flatmap_list.append(flatmap)\\n return flask.jsonify(flatmap_list)\",\n \"def test_history_import_relpath_in_metadata():\\n with HistoryArchive() as history_archive:\\n history_archive.write_metafiles(dataset_file_name='../outside.txt')\\n history_archive.write_file('datasets/Pasted_Entry_1.txt', 'foo')\\n history_archive.write_outside()\\n _run_jihaw_cleanup_check_secure(history_archive, 'Relative parent path in datasets_attrs.txt allowed')\",\n \"def writeMeta(outDir, metaData, fulltextData):\\n filename = join(outDir, 'articleMeta.tab')\\n logging.debug('Appending metadata to %s' % filename)\\n minId = pubConf.identifierStart['crawler']\\n metaData['articleId'] = str(minId + int(metaData['pmid']))\\n if 'main.html' in metaData:\\n metaData['fulltextUrl'] = metaData['main.html']['url']\\n elif 'landingUrl' in metaData:\\n metaData['fulltextUrl'] = metaData['landingUrl']\\n if not isfile(filename):\\n codecs.open(filename, 'w', encoding='utf8').write(u'\\\\t'.join(metaHeaders) + '\\\\n')\\n maxCommon.appendTsvDict(filename, metaData, metaHeaders)\\n row = []\\n for h in metaHeaders:\\n row.append(metaData.get(h, ''))\\n\\n dbFname = join(outDir, 'articles.db')\\n con, cur = maxTables.openSqliteCreateTable(dbFname, 'articles', metaHeaders, idxFields=['pmid', 'pmcId', 'doi'], intFields=['pmid', 'articleId', 'pmcId'], primKey='pmid', retries=100)\\n writeOk = False\\n tryCount = 100\\n logging.log(5, '%s' % row)\\n while not writeOk and tryCount > 0:\\n try:\\n try:\\n maxTables.insertSqliteRow(cur, con, 'articles', metaHeaders, row)\\n except sqlite3.IntegrityError:\\n logging.warn('Already present in meta info db')\\n\\n writeOk = True\\n except sqlite3.OperationalError:\\n logging.info('sqlite db is locked, waiting for 60 secs')\\n time.sleep(60)\\n tryCount -= 1\\n\\n if not writeOk:\\n raise Exception('Could not write to sqlite db')\",\n \"def set_master_table(filepath):\\n my_globals['master_table_path'] = filepath\\n my_globals['master_table_data'] = None\",\n \"def storeFilesNoZip(pmid, metaData, fulltextData, outDir):\\n warnMsgs = []\\n fileDir = join(outDir, 'files')\\n if not isdir(fileDir):\\n os.makedirs(fileDir)\\n suppFnames = []\\n suppUrls = []\\n pdfFound = False\\n for suffix, pageDict in fulltextData.iteritems():\\n if suffix in ('status', 'crawlerName'):\\n continue\\n if suffix == 'landingPage':\\n metaData['landingUrl'] = pageDict['url']\\n continue\\n filename = pmid + '.' + suffix\\n warnMinSize = 5000\\n if len(pageDict['data']) < warnMinSize:\\n warnMsgs.append('%s is smaller than %d bytes' % (suffix, warnMinSize))\\n if suffix == 'main.html':\\n if '<html' in pageDict['data']:\\n warnMsgs.append('main.html contains html tag')\\n metaData['mainHtmlFile'] = filename\\n metaData['mainHtmlUrl'] = pageDict['url']\\n elif suffix == 'main.pdf':\\n pdfFound = True\\n checkIfPdf(pageDict, metaData)\\n metaData['mainPdfFile'] = filename\\n metaData['mainPdfUrl'] = pageDict['url']\\n elif suffix.startswith('S'):\\n suppFnames.append(filename)\\n suppUrls.append(pageDict['url'])\\n fileData = pageDict['data']\\n filePath = join(fileDir, filename)\\n logging.debug('Writing file %s' % filePath)\\n fh = open(filePath, 'wb')\\n fh.write(fileData)\\n fh.close()\\n\\n if not pdfFound:\\n warnMsgs.append('No PDF file')\\n suppFnames = [ s.replace(',', '') for s in suppFnames ]\\n suppFnames = [ s.replace('\\\\t', '') for s in suppFnames ]\\n suppUrls = [ s.replace(',', '') for s in suppUrls ]\\n suppUrls = [ s.replace('\\\\t', '') for s in suppUrls ]\\n metaData['suppFiles'] = ','.join(suppFnames)\\n metaData['suppUrls'] = ','.join(suppUrls)\\n return (metaData, warnMsgs)\",\n \"def build_content(self) -> None:\\n logger.info(__('writing content.opf file...'))\\n metadata = self.content_metadata()\\n\\n # files\\n self.files: list[str] = []\\n self.ignored_files = ['.buildinfo', 'mimetype', 'content.opf',\\n 'toc.ncx', 'META-INF/container.xml',\\n 'Thumbs.db', 'ehthumbs.db', '.DS_Store',\\n 'nav.xhtml', self.config.epub_basename + '.epub'] + \\\\\\n self.config.epub_exclude_files\\n if not self.use_index:\\n self.ignored_files.append('genindex' + self.out_suffix)\\n for root, dirs, files in os.walk(self.outdir):\\n dirs.sort()\\n for fn in sorted(files):\\n filename = relpath(path.join(root, fn), self.outdir)\\n if filename in self.ignored_files:\\n continue\\n ext = path.splitext(filename)[-1]\\n if ext not in self.media_types:\\n # we always have JS and potentially OpenSearch files, don't\\n # always warn about them\\n if ext not in ('.js', '.xml'):\\n logger.warning(__('unknown mimetype for %s, ignoring'), filename,\\n type='epub', subtype='unknown_project_files')\\n continue\\n filename = filename.replace(os.sep, '/')\\n item = ManifestItem(html.escape(quote(filename)),\\n html.escape(self.make_id(filename)),\\n html.escape(self.media_types[ext]))\\n metadata['manifest_items'].append(item)\\n self.files.append(filename)\\n\\n # spine\\n spinefiles = set()\\n for refnode in self.refnodes:\\n if '#' in refnode['refuri']:\\n continue\\n if refnode['refuri'] in self.ignored_files:\\n continue\\n spine = Spine(html.escape(self.make_id(refnode['refuri'])), True)\\n metadata['spines'].append(spine)\\n spinefiles.add(refnode['refuri'])\\n for info in self.domain_indices:\\n spine = Spine(html.escape(self.make_id(info[0] + self.out_suffix)), True)\\n metadata['spines'].append(spine)\\n spinefiles.add(info[0] + self.out_suffix)\\n if self.use_index:\\n spine = Spine(html.escape(self.make_id('genindex' + self.out_suffix)), True)\\n metadata['spines'].append(spine)\\n spinefiles.add('genindex' + self.out_suffix)\\n # add auto generated files\\n for name in self.files:\\n if name not in spinefiles and name.endswith(self.out_suffix):\\n spine = Spine(html.escape(self.make_id(name)), False)\\n metadata['spines'].append(spine)\\n\\n # add the optional cover\\n html_tmpl = None\\n if self.config.epub_cover:\\n image, html_tmpl = self.config.epub_cover\\n image = image.replace(os.sep, '/')\\n metadata['cover'] = html.escape(self.make_id(image))\\n if html_tmpl:\\n spine = Spine(html.escape(self.make_id(self.coverpage_name)), True)\\n metadata['spines'].insert(0, spine)\\n if self.coverpage_name not in self.files:\\n ext = path.splitext(self.coverpage_name)[-1]\\n self.files.append(self.coverpage_name)\\n item = ManifestItem(html.escape(self.coverpage_name),\\n html.escape(self.make_id(self.coverpage_name)),\\n html.escape(self.media_types[ext]))\\n metadata['manifest_items'].append(item)\\n ctx = {'image': html.escape(image), 'title': self.config.project}\\n self.handle_page(\\n path.splitext(self.coverpage_name)[0], ctx, html_tmpl)\\n spinefiles.add(self.coverpage_name)\\n\\n auto_add_cover = True\\n auto_add_toc = True\\n if self.config.epub_guide:\\n for type, uri, title in self.config.epub_guide:\\n file = uri.split('#')[0]\\n if file not in self.files:\\n self.files.append(file)\\n if type == 'cover':\\n auto_add_cover = False\\n if type == 'toc':\\n auto_add_toc = False\\n metadata['guides'].append(Guide(html.escape(type),\\n html.escape(title),\\n html.escape(uri)))\\n if auto_add_cover and html_tmpl:\\n metadata['guides'].append(Guide('cover',\\n self.guide_titles['cover'],\\n html.escape(self.coverpage_name)))\\n if auto_add_toc and self.refnodes:\\n metadata['guides'].append(Guide('toc',\\n self.guide_titles['toc'],\\n html.escape(self.refnodes[0]['refuri'])))\\n\\n # write the project file\\n copy_asset_file(path.join(self.template_dir, 'content.opf_t'), self.outdir, metadata)\",\n \"def _save_target_info(self):\\n \\n #make sure the file exists\\n path = self.communicator.image_store.project_path + \\\\\\n self.target_file_name\\n fout = open(path, 'w')\\n\\n print str(1)\\n print str(len(self.target_list)-1)\\n for i in range(1, len(self.target_list)):\\n fout.write(self.target_list[i].format_info())\\n fout.write(\\\"\\\\n\\\\n\\\")\\n fout.close()\",\n \"def generate_metadata(self):\\n\\n if not os.path.exists(self.output_folder):\\n os.makedirs(self.output_folder)\\n\\n if self.options.profile == 'mercator':\\n\\n south, west = self.mercator.MetersToLatLon(self.ominx, self.ominy)\\n north, east = self.mercator.MetersToLatLon(self.omaxx, self.omaxy)\\n south, west = max(-85.05112878, south), max(-180.0, west)\\n north, east = min(85.05112878, north), min(180.0, east)\\n self.swne = (south, west, north, east)\\n\\n # Generate googlemaps.html\\n if self.options.webviewer in ('all', 'google') and self.options.profile == 'mercator':\\n if (not self.options.resume or not\\n os.path.exists(os.path.join(self.output_folder, 'googlemaps.html'))):\\n with open(os.path.join(self.output_folder, 'googlemaps.html'), 'wb') as f:\\n f.write(self.generate_googlemaps().encode('utf-8'))\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all', 'openlayers'):\\n if (not self.options.resume or not\\n os.path.exists(os.path.join(self.output_folder, 'openlayers.html'))):\\n with open(os.path.join(self.output_folder, 'openlayers.html'), 'wb') as f:\\n f.write(self.generate_openlayers().encode('utf-8'))\\n\\n # Generate leaflet.html\\n if self.options.webviewer in ('all', 'leaflet'):\\n if (not self.options.resume or not\\n os.path.exists(os.path.join(self.output_folder, 'leaflet.html'))):\\n with open(os.path.join(self.output_folder, 'leaflet.html'), 'wb') as f:\\n f.write(self.generate_leaflet().encode('utf-8'))\\n\\n elif self.options.profile == 'geodetic':\\n\\n west, south = self.ominx, self.ominy\\n east, north = self.omaxx, self.omaxy\\n south, west = max(-90.0, south), max(-180.0, west)\\n north, east = min(90.0, north), min(180.0, east)\\n self.swne = (south, west, north, east)\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all', 'openlayers'):\\n if (not self.options.resume or not\\n os.path.exists(os.path.join(self.output_folder, 'openlayers.html'))):\\n with open(os.path.join(self.output_folder, 'openlayers.html'), 'wb') as f:\\n f.write(self.generate_openlayers().encode('utf-8'))\\n\\n elif self.options.profile == 'raster':\\n\\n west, south = self.ominx, self.ominy\\n east, north = self.omaxx, self.omaxy\\n\\n self.swne = (south, west, north, east)\\n\\n # Generate openlayers.html\\n if self.options.webviewer in ('all', 'openlayers'):\\n if (not self.options.resume or not\\n os.path.exists(os.path.join(self.output_folder, 'openlayers.html'))):\\n with open(os.path.join(self.output_folder, 'openlayers.html'), 'wb') as f:\\n f.write(self.generate_openlayers().encode('utf-8'))\\n\\n # Generate tilemapresource.xml.\\n if not self.options.resume or not os.path.exists(os.path.join(self.output_folder, 'tilemapresource.xml')):\\n with open(os.path.join(self.output_folder, 'tilemapresource.xml'), 'wb') as f:\\n f.write(self.generate_tilemapresource().encode('utf-8'))\\n\\n if self.kml:\\n # TODO: Maybe problem for not automatically generated tminz\\n # The root KML should contain links to all tiles in the tminz level\\n children = []\\n xmin, ymin, xmax, ymax = self.tminmax[self.tminz]\\n for x in range(xmin, xmax+1):\\n for y in range(ymin, ymax+1):\\n children.append([x, y, self.tminz])\\n # Generate Root KML\\n if self.kml:\\n if (not self.options.resume or not\\n os.path.exists(os.path.join(self.output_folder, 'doc.kml'))):\\n with open(os.path.join(self.output_folder, 'doc.kml'), 'wb') as f:\\n f.write(generate_kml(\\n None, None, None, self.tileext, self.tilesize, self.tileswne,\\n self.options, children\\n ).encode('utf-8'))\",\n \"def save(self):\\n for page in self.pages.get_published_pages():\\n site_path = page.path_to_page.replace('.md', '').replace(\\n self.source_path, '').strip('/')\\n save_path = self.output_path\\n\\n # ensure we are not creating a directory for the index file that\\n # that lives at the source_path\\n if page.full_path() != f'{self.source_path}{os.sep}index.md':\\n site_path = slugify_path(site_path)\\n save_path = os.path.join('', self.output_path, site_path)\\n\\n try:\\n os.makedirs(save_path, exist_ok=True)\\n except Exception as e:\\n log((f'unable to create directories: {save_path}'\\n f' because: {e}'), True)\\n continue\\n\\n try:\\n save_file = os.path.join(save_path, 'index.html')\\n log(f'saving {save_file}')\\n\\n published = self.pages.get_published_pages()\\n prev_page = self.pages.get_previous_page(page)\\n next_page = self.pages.get_next_page(page)\\n content = page.render(published_pages=published,\\n previous_page=prev_page, next_page=next_page)\\n write(save_file, content)\\n except Exception as e:\\n log(f'unable to save file: {save_file} -- {e}', True)\\n\\n unpublished = self.pages.get_unpublished_pages()\\n if len(unpublished):\\n log('')\\n log('these pages were unpublished and not rendered:', True)\\n for up in unpublished:\\n log(up.path_to_page, True)\\n log('')\\n\\n # build the _tags pages\\n for tag, pages in self.tags.pages.items():\\n content = self.tags.render(tag, pages)\\n tag_index_dir = f'{self.tag_dir}/{slugify(tag)}'\\n tag_index = f'{tag_index_dir}/index.html'\\n os.makedirs(tag_index_dir, exist_ok=True)\\n write(tag_index, content)\\n\\n log('finished builidng site')\",\n \"def run(self):\\n for filepage in self.generator:\\n print (filepage)\\n filepage.touch()\",\n \"def generate_all(self, incremental=False):\\n logger.info(\\\"Reading site contents\\\")\\n self.load_template_if_needed()\\n self.template.clear_caches()\\n self.initialize()\\n self.load_site_if_needed()\\n self.events.begin_site()\\n logger.info(\\\"Generating site to [%s]\\\" %\\n self.site.config.deploy_root_path)\\n self.__generate_node__(self.site.content, incremental)\\n self.events.site_complete()\\n self.finalize()\\n self.generated_once = True\",\n \"def generate_pages(self, writer):\\r\\n write = partial(writer.write_file,\\r\\n relative_urls=self.settings['RELATIVE_URLS'])\\r\\n\\r\\n # to minimize the number of relative path stuff modification\\r\\n # in writer, articles pass first\\r\\n self.generate_articles(write)\\r\\n self.generate_period_archives(write)\\r\\n self.generate_direct_templates(write)\\r\\n\\r\\n # and subfolders after that\\r\\n self.generate_tags(write)\\r\\n self.generate_categories(write)\\r\\n self.generate_authors(write)\\r\\n self.generate_drafts(write)\",\n \"def on_files(self, files, config, **kwargs):\\n linked_md_file = File(\\n path=self.config[\\\"path_to_file\\\"],\\n src_dir=self.config[\\\"path_to_src_dir\\\"],\\n dest_dir=config[\\\"site_dir\\\"],\\n use_directory_urls=config[\\\"use_directory_urls\\\"]\\n )\\n files.append(linked_md_file)\\n return files\",\n \"def _local_dir(self):\\n return []\",\n \"def save_all_files_locally(file_list, path):\\n for file in file_list:\\n home = os.getenv(\\\"HOME\\\")\\n save_single_file_locally(path + file, home + \\\"/regulations-data/\\\")\",\n \"def write_master_file( manga_plate_master, manga_fiberID_master,\\n nsa_plate_master, nsa_fiberID_master, nsa_mjd_master,\\n nsa_gal_idx_master, nsa_ra_master, nsa_dec_master,\\n nsa_axes_ratio_master, nsa_phi_master, nsa_z_master,\\n nsa_mStar_master,\\n LOCAL_PATH):\\n ###########################################################################\\n # Convert the master data arrays into Column objects to add to the master\\n # data table.\\n #--------------------------------------------------------------------------\\n manga_plate_col = Column( manga_plate_master)\\n manga_fiberID_col = Column( manga_fiberID_master)\\n nsa_plate_col = Column( nsa_plate_master)\\n nsa_fiberID_col = Column( nsa_fiberID_master)\\n nsa_mjd_col = Column( nsa_mjd_master)\\n nsa_gal_idx_col = Column( nsa_gal_idx_master)\\n nsa_ra_col = Column( nsa_ra_master)\\n nsa_dec_col = Column( nsa_dec_master)\\n nsa_axes_ratio_col = Column( nsa_axes_ratio_master)\\n nsa_phi_col = Column( nsa_phi_master)\\n nsa_z_col = Column( nsa_z_master)\\n nsa_mStar_col = Column( nsa_mStar_master)\\n ###########################################################################\\n\\n\\n ###########################################################################\\n # Add the column objects to an astropy QTable.\\n #--------------------------------------------------------------------------\\n master_table = QTable([ manga_plate_col,\\n manga_fiberID_col,\\n nsa_plate_col,\\n nsa_fiberID_col,\\n nsa_mjd_col,\\n nsa_gal_idx_col,\\n nsa_ra_col * u.degree,\\n nsa_dec_col * u.degree,\\n nsa_axes_ratio_col,\\n nsa_phi_col * u.degree,\\n nsa_z_col,\\n nsa_mStar_col],\\n names = ['MaNGA_plate',\\n 'MaNGA_fiberID',\\n 'NSA_plate',\\n 'NSA_fiberID',\\n 'NSA_MJD',\\n 'NSA_index',\\n 'NSA_RA',\\n 'NSA_DEC',\\n 'NSA_b/a',\\n 'NSA_phi',\\n 'NSA_redshift',\\n 'NSA_mStar'])\\n ###########################################################################\\n\\n\\n ###########################################################################\\n # Write the master data file in ecsv format.\\n #--------------------------------------------------------------------------\\n ascii.write( master_table, LOCAL_PATH + '/master_file.txt',\\n format = 'ecsv',\\n overwrite = True)\\n ###########################################################################\",\n \"def copy_unmanaged_files(self, reader):\\n for entry in reader.index:\\n if (\\n entry.path == \\\"l10n.toml\\\"\\n or entry.path.startswith(\\\"templates/\\\")\\n or entry.path.startswith(\\\"locales/\\\")\\n ):\\n continue\\n\\n self.index.add(entry)\",\n \"def add_metadata(self, infos: Dict[str, Any]) -> None:\\n if self.output is None:\\n raise RuntimeError(ERR_CLOSED_WRITER)\\n self.output.add_metadata(infos)\",\n \"def print_local_output_files_stats():\\n print \\\"\\\\n\\\\nFILES CREATED:\\\"\\n for filename in os.listdir('../output'):\\n filesize = os.path.getsize('../output/' + filename)\\n print str(filesize) + \\\"\\\\t\\\" + filename\\n print \\\"\\\\n\\\"\",\n \"def _load_files(self):\\n for filedoc in self._docset.get_files():\\n path = filedoc.get_path()\\n if not path:\\n # In case of only partially loaded file information,\\n # the path information is not set for unloaded files.\\n continue\\n if not os.path.isabs(path):\\n path = os.path.join(self._source_root, path)\\n extension = os.path.splitext(path)[1]\\n # We don't care about Markdown files that only produce pages\\n # (and fail the directory check below).\\n if extension == '.md':\\n continue\\n dirdoc = filedoc.get_directory()\\n if not dirdoc:\\n self._reporter.xml_assert(filedoc.get_xml_path(),\\n \\\"file is not in any directory in Doxygen\\\")\\n continue\\n relpath = self._get_rel_path(path)\\n fileobj = self._files.get(relpath)\\n if not fileobj:\\n fileobj = File(path, relpath, self._docmap[dirdoc])\\n self._files[relpath] = fileobj\\n fileobj.set_doc_xml(filedoc, self)\\n self._docmap[filedoc] = fileobj\",\n \"def saveMetadata(self):\\n pickle.dump(self.metadata, open(self.metadataFile, 'w+b'))\",\n \"def set_location(self):\\n if self.has_non_empty_attribute(\\\"localitate\\\"):\\n loc_item = None\\n if utils.count_wikilinks(self.localitate) > 0:\\n loc_link = utils.get_wikilinks(self.localitate)[0]\\n loc_item = utils.q_from_wikipedia(\\\"ro\\\", loc_link.title)\\n adm_item = self.get_statement_values(\\\"located_adm\\\")\\n if loc_item and loc_item != adm_item[0]:\\n self.add_statement(\\\"location\\\", loc_item)\\n\\n if not loc_item:\\n self.add_to_report(\\\"localitate\\\", self.localitate, \\\"location\\\")\",\n \"def download_meta(self):\\n for f in self._manager.remote.list_contents(\\\".yml\\\"):\\n self._manager.remote.download(f)\",\n \"def test_maff(self):\\n index_file = os.path.join(self.test_input, 'folder1#中文', 'mypage.maff')\\n os.makedirs(os.path.dirname(index_file), exist_ok=True)\\n with zipfile.ZipFile(index_file, 'w') as zh:\\n zh.writestr('20200101000000000/index.html', \\\"\\\"\\\"\\\\\\n<!DOCTYPE html>\\n<html\\n data-scrapbook-create=\\\"20200101000000000\\\"\\n data-scrapbook-modify=\\\"20200101000000000\\\"\\n data-scrapbook-source=\\\"http://example.com\\\">\\n<head>\\n<meta charset=\\\"UTF-8\\\">\\n<title>MyTitle 中文</title>\\n</head>\\n<body>\\npage content\\n</body>\\n</html>\\n\\\"\\\"\\\")\\n\\n for _info in file2wsb.run(self.test_input, self.test_output):\\n pass\\n\\n book = Host(self.test_output).books['']\\n book.load_meta_files()\\n book.load_toc_files()\\n\\n id_folder1, id_item = book.meta.keys()\\n self.assertDictEqual(book.meta, {\\n id_folder1: {\\n 'title': 'folder1#中文',\\n 'type': 'folder',\\n 'create': id_folder1,\\n 'modify': id_folder1,\\n },\\n id_item: {\\n 'title': 'MyTitle 中文',\\n 'type': '',\\n 'index': f'{id_item}.maff',\\n 'create': '20200101000000000',\\n 'modify': '20200101000000000',\\n 'source': 'http://example.com',\\n 'icon': '',\\n 'comment': '',\\n },\\n })\\n self.assertDictEqual(book.toc, {\\n 'root': [\\n id_folder1,\\n ],\\n id_folder1: [\\n id_item,\\n ],\\n })\\n self.assertEqual(set(glob.iglob(os.path.join(self.test_output, '**'), recursive=True)), {\\n os.path.join(self.test_output, ''),\\n os.path.join(self.test_output, f'{id_item}.maff'),\\n })\",\n \"def writeXml(self):\\n curdir = os.getcwd()\\n os.chdir(self.Imagedir)\\n allImageLists = [self.sciImlist, self.ctxImlist, self.wgtImlist, self.rmsImlist]\\n \\n for imlist in allImageLists:\\n for im in imlist:\\n file = xmlUtil.markupImage(im,dataset=self.obsName)\\n \\n # Don't write these images as output of this module, which\\n # really doesn't have any.\\n \\n #if file not in self.outputList.keys():\\n # self.outputList[file] = [im]\\n \\n os.chdir(curdir)\\n return\",\n \"def setup_local_site(self):\\n raise NotImplementedError\",\n \"def metadata_path(self):\\n return os.path.join(self.path, 'metadata.txt')\",\n \"def save_complete(self):\\n self.save_assets(reset_html=False)\\n # new_file(self.url_obj.file_path, content=tostring(self.lxml, encoding=self.encoding))\\n self.lxml.getroottree().write(self.url_obj.file_path, method=\\\"html\\\")\\n\\n self._lxml = None # reset the tree\",\n \"def sitemap():\\n pages = []\\n pages.append(['http://mattcarter.co/', '2018-07-21'])\\n pages.append(['http://mattcarter.co/blog', '2018-07-21'])\\n\\n content_path = os.path.join(app.root_path, 'content')\\n for file in os.listdir(content_path):\\n if not file.endswith('.md'):\\n continue\\n full_path = os.path.join(content_path, file)\\n post_obj = parse_markdown_post(full_path)\\n url = 'http://mattcarter.co/blog/%s' % file.replace('.md', '')\\n last_mod = post_obj.date\\n pages.append([url, last_mod])\\n\\n response= make_response(render_template(\\\"sitemap.xml\\\", pages=pages))\\n response.headers['Content-Type'] = 'application/xml'\\n return response\",\n \"def write_homepage(self, status_info):\\n self.logger.info('writing homepage')\\n with tempfile.NamedTemporaryFile(mode='w', dir=str(self.output_path),\\n encoding='utf-8',\\n delete=False) as index:\\n try:\\n index.file.write(self.homepage_template.format(**status_info))\\n except BaseException:\\n index.delete = True\\n raise\\n else:\\n os.fchmod(index.file.fileno(), 0o664)\\n os.replace(index.name, str(self.output_path / 'index.html'))\",\n \"def registerDirMetaData(self, lfn, meta_dict):\\n filename = os.path.basename(lfn)\\n lpn = lfn.split(filename)[0].rstrip('/')\\n res = self.fc.setMetadata(lpn, meta_dict)\\n if not res['OK']:\\n gLogger.error('Setting Meta Data from file (%s) on dir (%s) failed with message (%s)' %(filename, lpn, res['Message']))\\n else:\\n gLogger.info('Setting meta data on lpn (%s) succeeded' %lpn)\\n ### res is either S_OK or S_ERROR\\n return res\",\n \"def prepare_info(self, infoxml_file):\\n\\n self.info = InfoXML(infoxml_file)\\n\\n if self.info.name:\\n self.LOGGER << f\\\"Mod Name from info.xml: {self.info.name}\\\"\\n\\n self._install_dirname = self.info.name.lower()\",\n \"def index_all_files(self, root_dir):\\n pass\",\n \"def create_master(asciitest_out_dir):\\n # path join uses backslash under windows which is not cmake compatible\\n filename_out = os.path.join(asciitest_out_dir, \\\"asciitest-master.cmake\\\").replace(\\\"\\\\\\\\\\\",\\\"/\\\")\\n # path join uses backslash under windows which is not cmake compatible\\n filename_in = os.path.join(asciitest_out_dir, \\\"asciitest-all_input_files.txt\\\").replace(\\\"\\\\\\\\\\\",\\\"/\\\")\\n\\n with open(filename_out + \\\".temp\\\", 'w') as f_out:\\n for line in open(filename_in).readlines():\\n f_out.write(\\\"# %s\\\" % line)\\n # path join uses backslash win32 which is not cmake compatible\\n cmake_include_filename = os.path.join(\\n asciitest_out_dir,\\n save_cmake_filename(line)).replace(\\\"\\\\\\\\\\\", \\\"/\\\")\\n #print(\\\"create entry '%s'\\\" %cmake_include_filename)\\n f_out.write(\\\"include(%s)\\\\n\\\" % cmake_include_filename )\\n open(cmake_include_filename, 'a').close()\\n\\n update_if_different(filename_out + \\\".temp\\\", filename_out)\",\n \"def write_manifests( file_lists, target_dir, output_dir ):\\n for i, lst in enumerate( file_lists ):\\n with open( os.path.join( output_dir, \\\"manifest-{}.txt\\\".format( i ) ), \\\"w\\\" ) as fout:\\n for r in lst:\\n fout.write( insert_rsync_marker( r, target_dir ) + \\\"\\\\n\\\" )\",\n \"def writeContent(self):\\n self.content = [(int(x.size), x.name) for x in self.tarfile.getmembers()]\",\n \"def set_content(self):\\n should_process = False # whether wiki page need to be updated\\n soup = BeautifulSoup(self.body, \\\"html.parser\\\")\\n\\n try:\\n # Test Cluster Wiki Page\\n tag = soup.find(text=self.server_name).find_next('span').find(text=re.compile('4.[0-9].[0-9].[0-9](.[0-9]b[0-9]{1,4})?|UNKNOWN')).find_parent()\\n print(str(tag))\\n except Exception as e:\\n print('No server name Found')\\n print('Now Looking for IP address instead\\\\n')\\n try:\\n tag = soup.find(text=self.ip_addr).find_next('span').find(text=re.compile('4.[0-9].[0-9].[0-9](.[0-9]b[0-9]{1,4})?')).find_parent()\\n print(str(tag))\\n except:\\n print('No IP address Found')\\n print('Now Looking for alias name instead\\\\n')\\n try:\\n tag = soup.find_all(text=re.compile(self.alias_name+'.*'))[-1].find_next('span').find(text=re.compile('4.[0-9].[0-9].[0-9](.[0-9]b[0-9]{1,4})?|UNKNOWN')).find_parent()\\n print(str(tag))\\n except:\\n print('No alias name Found')\\n return should_process\\n\\n # compare unravel version in wiki page with local\\n if tag.string and tag.string != self.unravel_version:\\n tag.string = self.unravel_version\\n should_process = True\\n elif not tag.string and self.unravel_version:\\n tag.string = self.unravel_version\\n should_process = True\\n\\n # Create new wiki page content for update\\n self.new_content = str(soup)\\n return should_process\",\n \"def __gen_pointing_file(self, top_level_layer):\\n paula_id = '{}.{}.{}_{}_pointing'.format(top_level_layer,\\n self.corpus_name, self.name,\\n top_level_layer)\\n self.paulamap['pointing'][top_level_layer] = paula_id\\n E, tree = gen_paula_etree(paula_id)\\n\\n pointing_edges = select_edges_by(self.dg, layer=top_level_layer,\\n edge_type=EdgeTypes.pointing_relation,\\n data=True)\\n pointing_dict = defaultdict(lambda: defaultdict(str))\\n for source_id, target_id, edge_attrs in pointing_edges:\\n pointing_dict[source_id][target_id] = edge_attrs\\n\\n # NOTE: we don't add a base file here, because the nodes could be\\n # tokens or structural nodes\\n rlist = E('relList')\\n for source_id in pointing_dict:\\n for target_id in pointing_dict[source_id]:\\n source_href = self.__gen_node_href(top_level_layer, source_id)\\n target_href = self.__gen_node_href(top_level_layer, target_id)\\n rel = E('rel',\\n {'id': 'rel_{}_{}'.format(source_id, target_id),\\n XLINKHREF: source_href,\\n 'target': target_href})\\n\\n # adds source/target node labels as a <!-- comment -->\\n if self.human_readable:\\n source_label = self.dg.node[source_id].get('label')\\n target_label = self.dg.node[target_id].get('label')\\n rel.append(Comment(u'{} - {}'.format(source_label,\\n target_label)))\\n rlist.append(rel)\\n tree.append(rlist)\\n self.files[paula_id] = tree\\n self.file2dtd[paula_id] = PaulaDTDs.rel\\n return paula_id\",\n \"def create_master_turnstile_file(filenames, output_file):\\n with open(output_file, 'w') as master_file:\\n master_file.write('C/A,UNIT,SCP,DATEn,TIMEn,DESCn,ENTRIESn,EXITSn\\\\n')\\n writer = csv.writer(master_file, delimiter=',')\\n for filename in filenames:\\n with open(filename, 'rb') as f:\\n reader = csv.reader(f)\\n for row in reader:\\n writer.writerow(row)\",\n \"def gather_documents(self):\\n self.document_gatherer.gather_and_save_everything(Constants.path_cord, \\n Constants.path_metadata, \\n Constants.path_linked_documents,\\n Constants.path_unlinked_documents,\\n Constants.path_parsed_documents,\\n Constants.path_all_documents)\\n \\n print(\\\"Done gathering documents.\\\")\",\n \"def prepend_file(self, file_hex):\\n new_file_byte_length = int(len(file_hex)/2)\\n self._local_file_headers = f'{file_hex}{self._local_file_headers}'\\n\\n for header in self.get_central_dir_list():\\n header.shift_relative_local_header_offset(new_file_byte_length)\\n\\n self._end_central_dir.shift_start_central_dir_start_offset(\\n new_file_byte_length)\",\n \"def write_map( file_lists, target_dir, output_dir ):\\n tld_to_volumes = {}\\n for i, group in enumerate( file_lists ):\\n for node in group:\\n tld = toplevel_subdir( node, target_dir )\\n tld_to_volumes.setdefault( tld, set() ).add( i )\\n with open( os.path.join( output_dir, \\\"map.txt\\\" ), \\\"w\\\" ) as fout:\\n for tld, volumes in tld_to_volumes.items():\\n fout.write( \\\"{:24s}: {}\\\\n\\\".format( tld, \\\" \\\".join( [ str( x ) for x in volumes ] ) ) )\",\n \"def write(self):\\n\\n mr = MakoRenderer(self._TEMPLATE, StaticFlowEnvironment.rootTemplatePath, {'sitemap':self})\\n result = mr.render()\\n\\n if not mr.success:\\n self.site.writeLogError(unicode(mr.errorMessage))\\n return False\\n\\n if not FileUtils.putContents(result, self.targetPath):\\n self.site.writeLogError(u'Unable to save sitemap file at: \\\"%s\\\"' % self.targetPath)\\n return False\\n\\n self.site.writeLogSuccess(u'SITEMAP', u'Created sitemap at: \\\"%s\\\"' % self.targetPath)\\n return True\",\n \"def process_master(\\n session: Session, output_path: Path, service_names: List[ServiceName]\\n) -> MasterPackage:\\n logger.debug(f\\\"Parsing master\\\")\\n master_package = parse_master_package(session, service_names)\\n logger.debug(f\\\"Writing master to {NicePath(output_path)}\\\")\\n\\n modified_paths = write_master_package(master_package, output_path)\\n for modified_path in modified_paths:\\n logger.debug(f\\\"Updated {NicePath(modified_path)}\\\")\\n\\n return master_package\",\n \"def add_masters_to_writer(ufos, regular, axes, writer):\\n for font in ufos:\\n family, style = font.info.familyName, font.info.styleName\\n # MutatorMath.DesignSpaceDocumentWriter iterates over the location\\n # dictionary, which is non-deterministic so it can cause test failures.\\n # We therefore use an OrderedDict to which we insert in axis order.\\n # Since glyphsLib will switch to DesignSpaceDocument once that is\\n # integrated into fonttools, it's not worth fixing upstream.\\n # https://github.com/googlei18n/glyphsLib/issues/165\\n location = OrderedDict()\\n for axis in axes:\\n location[axis] = font.lib.get(\\n GLYPHS_PREFIX + axis + 'Value', DEFAULT_LOCS[axis])\\n is_regular = (font is regular)\\n writer.addSource(\\n path=font.path, name='%s %s' % (family, style),\\n familyName=family, styleName=style, location=location,\\n copyFeatures=is_regular, copyGroups=is_regular, copyInfo=is_regular,\\n copyLib=is_regular)\",\n \"def updateFrontPages(self):\\n nTmessage(\\\"Starting %s\\\" % getCallerName())\\n htmlDir = os.path.join(self.results_dir, \\\"HTML\\\")\\n if os.path.isdir(htmlDir):\\n# nTdebug(\\\"Removing original html directory for NRG-CING.\\\")\\n rmdir(htmlDir)\\n # end if\\n nTmessage(\\\"Creating HTML directory for %s.\\\" % self.results_base)\\n mkdirs(htmlDir)\\n# srcHtmlPath = os.path.join(cingRoot, cingPaths.html) \\n data_dir = os.path.join (self.base_dir, \\\"data\\\" )\\n base_data_dir = os.path.join (data_dir, self.results_base )\\n # Most crud can come in from the traditional method.\\n copyCingHtmlJsAndCssToDirectory(htmlDir)\\n \\n nTmessage(\\\"Adding frontpage-specific html.\\\")\\n fnList = \\\"\\\"\\\"\\n about.html \\n contact.html \\n credits.html \\n help.html \\n helpCing.html \\n helpPlot.html \\n helpTutorials.html\\n glossary.html \\n index.html\\n download.html \\n plot.html \\n cing.png \\n icon_email.gif\\n icon_reference.gif\\n icon_website.png\\n icon_youtube.jpeg\\n icon_download.gif\\n NRG-CING_circle.png\\n \\\"\\\"\\\".split()\\n for fn in fnList:\\n srcFile = os.path.join(base_data_dir, fn)\\n dstFile = os.path.join(htmlDir, fn)\\n if not fn.endswith('.html'):\\n copyfile(srcFile, dstFile)\\n# nTdebug(\\\"-1- Added extra file %s.\\\" % dstFile)\\n continue\\n # end if\\n file_content = open(srcFile, 'r').read() \\n old_string = r\\\"<!-- INSERT NEW FOOTER HERE -->\\\"\\n file_content = string.replace(file_content, old_string, self.htmlFooter)\\n old_string = r\\\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE) \\n old_string = r\\\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE) \\n if fn != 'index.html':\\n writeTextToFile(dstFile, file_content)\\n# nTdebug(\\\"-2- Added extra file %s.\\\" % dstFile)\\n continue\\n # end if\\n # Get framework input\\n file_content = self._format_html(file_content) \\n htmlfile = os.path.join(htmlDir, 'index.html')\\n writeTextToFile(htmlfile, file_content)\\n# nTdebug(\\\"-3- Written HTML index file: %s\\\" % htmlfile) \\n # end for\\n nTmessage(\\\"Copy the overall index\\\")\\n org_file = os.path.join(data_dir, 'redirect.html')\\n new_file = os.path.join(self.results_dir, 'index.html')\\n shutil.copy(org_file, new_file)\\n \\n nTmessage(\\\"Copy the python cgi server for TableTools\\\\n\\\")\\n cgi_file_name = 'DataTablesServer.py'\\n if not os.path.exists(self.cgi_dir):\\n nTerror(\\\"Please first create the server directory as expected at: %s\\\" % self.cgi_dir)\\n return True\\n # end if\\n org_file = os.path.join(self.base_dir, 'server', cgi_file_name)\\n new_file = os.path.join(self.cgi_dir, cgi_file_name)\\n if os.path.exists(new_file): # remove because if it's a hard link the copy will fail.\\n os.unlink(new_file)\\n # end if\\n shutil.copy(org_file, new_file)\",\n \"def write_shortfile_table(self):\\n\\n # KMEL actually removes duplicate short filenames from this\\n # table.\\n\\n start_of_shortfiles = self.db_file.tell()\\n\\n shortfiles = {}\\n for miEntry in self.mainIndex:\\n short_filename = miEntry.encodedShortfile\\n if short_filename in shortfiles:\\n miEntry.set_shortfile_offset(\\n shortfiles[short_filename])\\n else:\\n shortfiles[short_filename] = \\\\\\n self.db_file.tell() - start_of_shortfiles\\n\\n miEntry.set_shortfile_offset(\\n shortfiles[short_filename])\\n self.db_file.write(short_filename)\",\n \"def write_downloaded_links():\\n global downloaded_links_fn\\n text_file = open(downloaded_links_fn,\\\"w\\\")\\n for link in downloaded_links.items():\\n text_file.write(link[0] + \\\"\\\\n\\\")\\n text_file.close()\",\n \"def test_path04(self):\\n index_file = os.path.join(self.test_input, 'index.html')\\n with open(index_file, 'w', encoding='UTF-8') as fh:\\n fh.write(\\\"\\\"\\\"\\\\\\n<!DOCTYPE html>\\n<html\\n data-scrapbook-create=\\\"20200101000000000\\\"\\n data-scrapbook-modify=\\\"20200101000000000\\\"\\n data-scrapbook-source=\\\"http://example.com\\\">\\n<head>\\n<meta charset=\\\"UTF-8\\\">\\n<title>MyTitle 中文</title>\\n</head>\\n<body>\\npage content\\n</body>\\n</html>\\n\\\"\\\"\\\")\\n\\n for _info in file2wsb.run(self.test_input, self.test_output):\\n pass\\n\\n book = Host(self.test_output).books['']\\n book.load_meta_files()\\n book.load_toc_files()\\n\\n id_item, = book.meta.keys()\\n self.assertDictEqual(book.meta, {\\n id_item: {\\n 'title': 'MyTitle 中文',\\n 'type': '',\\n 'index': f'{id_item}/index.html',\\n 'create': '20200101000000000',\\n 'modify': '20200101000000000',\\n 'source': 'http://example.com',\\n 'icon': '',\\n 'comment': '',\\n },\\n })\\n self.assertDictEqual(book.toc, {\\n 'root': [\\n id_item,\\n ],\\n })\\n self.assertEqual(set(glob.iglob(os.path.join(self.test_output, '**'), recursive=True)), {\\n os.path.join(self.test_output, ''),\\n os.path.join(self.test_output, id_item),\\n os.path.join(self.test_output, id_item, 'index.html'),\\n })\",\n \"def test_path05(self):\\n index_file = os.path.join(self.test_input, 'index.html')\\n with open(index_file, 'w', encoding='UTF-8') as fh:\\n fh.write(\\\"\\\"\\\"\\\\\\n<!DOCTYPE html>\\n<html\\n data-scrapbook-create=\\\"20200101000000000\\\"\\n data-scrapbook-modify=\\\"20200101000000000\\\"\\n data-scrapbook-source=\\\"http://example.com\\\">\\n<head>\\n<meta charset=\\\"UTF-8\\\">\\n<title>MyTitle 中文</title>\\n</head>\\n<body>\\npage content\\n</body>\\n</html>\\n\\\"\\\"\\\")\\n\\n for _info in file2wsb.run(self.test_input, self.test_output, no_preserve_filename=True):\\n pass\\n\\n book = Host(self.test_output).books['']\\n book.load_meta_files()\\n book.load_toc_files()\\n\\n id_item, = book.meta.keys()\\n self.assertDictEqual(book.meta, {\\n id_item: {\\n 'title': 'MyTitle 中文',\\n 'type': '',\\n 'index': f'{id_item}.html',\\n 'create': '20200101000000000',\\n 'modify': '20200101000000000',\\n 'source': 'http://example.com',\\n 'icon': '',\\n 'comment': '',\\n },\\n })\\n self.assertDictEqual(book.toc, {\\n 'root': [\\n id_item,\\n ],\\n })\\n self.assertEqual(set(glob.iglob(os.path.join(self.test_output, '**'), recursive=True)), {\\n os.path.join(self.test_output, ''),\\n os.path.join(self.test_output, f'{id_item}.html'),\\n })\",\n \"def test_history_import_abspath_in_metadata():\\n with HistoryArchive() as history_archive:\\n history_archive.write_metafiles(\\n dataset_file_name=os.path.join(history_archive.temp_directory, 'outside.txt'))\\n history_archive.write_file('datasets/Pasted_Entry_1.txt', 'foo')\\n history_archive.write_outside()\\n _run_jihaw_cleanup_check_secure(history_archive, 'Absolute path in datasets_attrs.txt allowed')\",\n \"def writeOutServers(self):\\n # we'll be writing out to the server tracker file, overwriting\\n # anything that may exist in it\\n global server_tracker_file\\n \\n with open(server_tracker_file, 'wb') as outfile:\\n # let's leverage the printStatus method we have\\n outfile.write(self.printStatus())\\n \\n return\",\n \"def export_at_once(export_dir, page_names):\\r\\n\\r\\n print 'Getting export with full list of pages'\\r\\n pages_param = '\\\\n'.join(page_names)\\r\\n export_filename = os.path.join(export_dir, 'wiki_export.xml')\\r\\n get_export(pages_param, export_filename)\\r\\n\\r\\n return [export_filename]\",\n \"def savemetadata(self, newmeta):\\n with open(self.outputMetadata, 'w') as f:\\n json.dump(newmeta, f)\",\n \"def writeDomainFile():\\n writeTemplate(localTemplate)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5722937","0.5389413","0.5272536","0.5261582","0.52335477","0.5231832","0.5230986","0.5189005","0.5180332","0.5165523","0.5151534","0.5123532","0.51147246","0.50322574","0.50167596","0.4984998","0.49717563","0.49513733","0.49408144","0.4935451","0.49319112","0.49303827","0.49271578","0.4896115","0.48918986","0.48744488","0.48697358","0.4868548","0.48656517","0.4854198","0.48473814","0.48418844","0.4838045","0.48358455","0.48204824","0.4789926","0.4787706","0.4784116","0.47756597","0.4765658","0.4761053","0.4754044","0.47519344","0.47409356","0.4730714","0.4727177","0.4727091","0.4723258","0.4717099","0.47143584","0.47070375","0.4698115","0.46975088","0.46973026","0.46942127","0.46870416","0.46863914","0.4683318","0.4680531","0.46800894","0.46701255","0.46659052","0.46629858","0.46612754","0.4660451","0.46593463","0.46565247","0.46484023","0.46451345","0.4642251","0.46403632","0.46384352","0.46382582","0.46373236","0.463516","0.46338272","0.46320805","0.46100095","0.460666","0.46060038","0.4595085","0.45919418","0.45911977","0.45888796","0.4584554","0.45828804","0.45797497","0.4575768","0.45740622","0.4573949","0.45609638","0.45608753","0.4554471","0.45517606","0.4547611","0.45458013","0.4540808","0.45312518","0.45311075","0.45257506"],"string":"[\n \"0.5722937\",\n \"0.5389413\",\n \"0.5272536\",\n \"0.5261582\",\n \"0.52335477\",\n \"0.5231832\",\n \"0.5230986\",\n \"0.5189005\",\n \"0.5180332\",\n \"0.5165523\",\n \"0.5151534\",\n \"0.5123532\",\n \"0.51147246\",\n \"0.50322574\",\n \"0.50167596\",\n \"0.4984998\",\n \"0.49717563\",\n \"0.49513733\",\n \"0.49408144\",\n \"0.4935451\",\n \"0.49319112\",\n \"0.49303827\",\n \"0.49271578\",\n \"0.4896115\",\n \"0.48918986\",\n \"0.48744488\",\n \"0.48697358\",\n \"0.4868548\",\n \"0.48656517\",\n \"0.4854198\",\n \"0.48473814\",\n \"0.48418844\",\n \"0.4838045\",\n \"0.48358455\",\n \"0.48204824\",\n \"0.4789926\",\n \"0.4787706\",\n \"0.4784116\",\n \"0.47756597\",\n \"0.4765658\",\n \"0.4761053\",\n \"0.4754044\",\n \"0.47519344\",\n \"0.47409356\",\n \"0.4730714\",\n \"0.4727177\",\n \"0.4727091\",\n \"0.4723258\",\n \"0.4717099\",\n \"0.47143584\",\n \"0.47070375\",\n \"0.4698115\",\n \"0.46975088\",\n \"0.46973026\",\n \"0.46942127\",\n \"0.46870416\",\n \"0.46863914\",\n \"0.4683318\",\n \"0.4680531\",\n \"0.46800894\",\n \"0.46701255\",\n \"0.46659052\",\n \"0.46629858\",\n \"0.46612754\",\n \"0.4660451\",\n \"0.46593463\",\n \"0.46565247\",\n \"0.46484023\",\n \"0.46451345\",\n \"0.4642251\",\n \"0.46403632\",\n \"0.46384352\",\n \"0.46382582\",\n \"0.46373236\",\n \"0.463516\",\n \"0.46338272\",\n \"0.46320805\",\n \"0.46100095\",\n \"0.460666\",\n \"0.46060038\",\n \"0.4595085\",\n \"0.45919418\",\n \"0.45911977\",\n \"0.45888796\",\n \"0.4584554\",\n \"0.45828804\",\n \"0.45797497\",\n \"0.4575768\",\n \"0.45740622\",\n \"0.4573949\",\n \"0.45609638\",\n \"0.45608753\",\n \"0.4554471\",\n \"0.45517606\",\n \"0.4547611\",\n \"0.45458013\",\n \"0.4540808\",\n \"0.45312518\",\n \"0.45311075\",\n \"0.45257506\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4666643"},"document_rank":{"kind":"string","value":"61"}}},{"rowIdx":90597,"cells":{"query":{"kind":"string","value":"Returns full text extracted from cdm compound object pages."},"document":{"kind":"string","value":"def extract_text(self, record):\n # type: (Element) -> str\n cdm_struc = Fields.cdm_structural_elements\n structure_el = record.find(cdm_struc['compound_object_container'])\n pages_el = structure_el.iterfind('.//' + cdm_struc['compound_object_page'])\n fulltext = ''\n for page in pages_el:\n page_el = page.find(cdm_struc['compound_object_page_text'])\n if page_el is not None:\n if page_el.text is not None:\n page_text = Utils.correct_text_encoding(page_el.text)\n fulltext += page_text\n return fulltext"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def raw_text(self):\n\t\t\n\t\t #eliminating more headers\n\t\traw_text = re.sub(r\".*OPERATIONS O[PF].*\",r\"\",self.doc)\n\t\traw_text = re.sub(r\"Page \\d+\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*B[lL]OCK.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*WEST GULF.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*NAVAL FORCES ON.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\"\\s\",r\" \", raw_text) #eliminating tabs etc. \t \t \n\t\treturn raw_text","def textify(read_pdf,spage,epage):\n\n page_text = \"\"\n for page in range(spage, epage):\n page_content = read_pdf.getPage(page)\n page_text += page_content.extractText()\n\n full_text = page_text #.encode('utf-8')\n return full_text","def extract_page_text(self, bs_object):\n\n # kill all script and style elements\n for script in bs_object([\"script\", \"style\", \"head\"]):\n script.extract() # rip it out\n\n # get text\n text = bs_object.get_text()\n\n # break into lines and remove leading and trailing space on each\n lines = (line.strip() for line in text.splitlines())\n # break multi-headlines into a line each\n chunks = (phrase.strip() for line in lines for phrase in line.split(\" \"))\n # drop blank lines\n text_list_gen = (chunk for chunk in chunks if chunk)\n text_list = list(text_list_gen)\n # print \"TEXT LIST >>>\\n\", text_list\n \n return text_list","def full_text(self):\n return self.lxml.text_content()","def extract(self):\n\n self.decode(CMS_object.extract(self))\n return self.get_content()","def page_text(tree, level=\"region\", index=\"0\"):\n\n nsmap = {'page': page_namespace(tree)}\n\n def region_text(region, index=\"0\"):\n try:\n reg = region.find('./page:TextEquiv/page:Unicode', namespaces=nsmap)\n if reg is not None and reg.getparent().attrib.get('index','-1') in ['-1', index]:\n return region.find('./page:TextEquiv/page:Unicode', namespaces=nsmap).text\n else:\n return None\n except AttributeError:\n return None\n\n def line_text(region, index=\"0\"):\n try:\n return \"\\n\".join([line.text for line in (region.findall('./page:TextLine/page:TextEquiv/page:Unicode', namespaces=nsmap))\n if line is not None and line.getparent().attrib.get('index','-1') in ['-1', index]])\n except AttributeError:\n return None\n\n def word_text(region, index=\"0\"):\n try:\n text = []\n textlines = []\n lines = region.findall('./page:TextLine/', namespaces=nsmap)\n for line in lines:\n words = line.findall('./page:TextEquiv/page:Unicode', namespaces=nsmap)\n if words:\n for word in words:\n if word.getparent().attrib.get('index','-1') in ['-1', index]:\n text.append(word.text)\n elif text != []:\n textlines.append(\" \".join(text))\n text = []\n return \"\\n\".join(textlines)\n except AttributeError:\n return None\n\n region_texts = []\n reading_order = tree.find('.//page:ReadingOrder', namespaces=nsmap)\n if reading_order is not None:\n for group in reading_order.iterfind('./*', namespaces=nsmap):\n if ET.QName(group.tag).localname == 'OrderedGroup':\n region_ref_indexeds = group.findall('./page:RegionRefIndexed', namespaces=nsmap)\n for region_ref_indexed in sorted(region_ref_indexeds, key=lambda r: int(r.attrib['index'])):\n region_id = region_ref_indexed.attrib['regionRef']\n region = tree.find('.//page:TextRegion[@id=\"%s\"]' % region_id, namespaces=nsmap)\n if region is not None and level == \"region\":\n region_texts.append(region_text(region, index))\n elif region is not None and level == \"line\":\n region_texts.append(line_text(region, index))\n elif region is not None and level == \"word\":\n region_texts.append(word_text(region, index))\n else:\n warn('Not a TextRegion: \"%s\"' % region_id)\n else:\n raise NotImplementedError\n else:\n for region in tree.iterfind('.//page:TextRegion', namespaces=nsmap):\n if region is not None and level == \"region\":\n region_texts.append(region_text(region, index))\n elif region is not None and level == \"line\":\n region_texts.append(line_text(region, index))\n elif region is not None and level == \"word\":\n region_texts.append(word_text(region, index))\n\n # XXX Does a file have to have regions etc.? region vs lines etc.\n # Filter empty region texts\n region_texts = (t for t in region_texts if t)\n\n text_ = '\\n'.join(region_texts)\n\n return text_","def digital_text(file_path):\n doc = fitz.open(file_path)\n page_count = doc.pageCount\n print(\"\\n number of pages : \",page_count)\n total_text = \"\"\n try:\n for page_num in range(page_count):\n p = doc.loadPage(page_num)\n page_text = p.getText()\n total_text += page_text\n print(\"\\n number of pages extracted : \", (page_count))\n except Exception as e:\n print(\"\\n Error in digital_text : \", traceback.format_exc(()))\n return total_text","def get_text(self):","def get_text(adm, obj):\n return adm['data'][slice(*extent(obj))]","def readFile(self):\n with pdfplumber.open(self.path) as pdf:\n first_page = pdf.pages[0]\n text = first_page.extract_text()\n text = text.split('\\n')\n return processText(text)","def get_text(self):\n return self.text[:500]","def extract_text(url, sem):\n with (yield from sem):\n page = yield from get(url)\n\n tree = etree.HTML(page)\n paragraphs = tree.findall('.//*/div[@class=\"entry-content\"]/p')[1:-1]\n return url, b'\\n'.join(map(etree.tostring, paragraphs))","def extract_text(filename):\n\tpdfFileObj = open(filename, \"rb\")\n\tpdfReader = PyPDF2.PdfFileReader(pdfFileObj)\n\n\tmytext = \"\"\n\n\tfor pageNum in range(pdfReader.numPages):\n\t\tpageObj = pdfReader.getPage(pageNum)\n\t\tmytext += pageObj.extractText()\n\n\tpdfFileObj.close()\n\n\treturn mytext","def fulltext(self):\n child_contents = ''\n for c in self.children:\n child_contents += c.fulltext\n return self.text + child_contents","def extract_page_text(html):\n soup = bs4.BeautifulSoup(html)\n\n # Remove <script/> and <style/> content\n for script in soup([\"script\", \"style\"]):\n script.extract()\n\n text = soup.get_text()\n\n # Strip leading and trailing whitespace from each line, then join all the\n # non-empty lines together.\n lines = (line.strip() for line in text.splitlines())\n text = '\\n'.join(line for line in lines if line)\n\n return text","def get_complete_text(doc_list):\n complete_text = \"\"\n for doc in doc_list:\n text = read_file( doc, mode='rb', ignore_comments= False).decode('utf-8')\n complete_text = complete_text + text\n return complete_text","def text(self):\n return self.full_text","def get_data_from_pdf(self, regex):\n match = re.search(regex, self.page_text)\n return match.group(0).replace(\" \", \"\").replace(\"\\n\", \"\")","def obtain_text():\n pass","def extract_paragraph(file_name, url_text = None, show_property = False, database = None, extract_all_property=False, \n return_documenTM = False, cut_off = True, unit_dict = None, special_unit_dictionary = None):\n if not url_text:\n url_text = file_name\n \n if not database: \n database = {}\n \n if not isinstance(unit_dict, dict):\n unit_dict = unit_dict_default\n \n keyword_dict = make_keyword_dict(unit_dict)\n \n Q = DocumentTM(file_name, **database)\n Q.doc()\n Q.find_strange()\n chemical_type_dict = {}\n database = Q.database()\n \n if special_unit_dictionary:\n Q.set_special_unit(special_unit_dictionary)\n \n \n data_collection = []\n json_list = []\n \n for Para in Q.Para:\n new_split, unit = Q.tokenize_paragraph(Para, lemma = False, Strange = True, cut_off=cut_off)\n \n if not new_split:\n continue\n \n #print (new_split)\n \n before_represent_chem = False\n \n for sent in cut_paragraph(new_split):\n new_sent, unit_dictionary, next_represent_chem = matching_algorithm(sent, database, chemical_type_dict, before_represent_chem)\n\n if extract_all_property:\n #iters = chain.from_iterable(unit_dictionary.values())\n iters = chain.from_iterable([dics.values() for dics in unit_dictionary.values()])\n else:\n iters = unit_dictionary['Character'].values()\n \n \n #print (unit_dictionary['Character'])\n #if unit_dictionary['Character'] or unit_dictionary['Reaction']:\n #data_collection.append([sent, unit_dictionary])\n \n if show_property and (unit_dictionary['Character'] or unit_dictionary['Reaction']):\n \n print (\"\\n\\n------------------------------------\")\n print (file_name)\n print (\" \".join([str(t) for t in new_sent]))\n print (\"\\n\")\n #print (Para)\n #print (\" \".join(new_split))\n print (\"------------------------------------\")\n \n for T in chain.from_iterable(iters):\n #for T in t:\n dictionary_chemical = {'Material':T.target, 'Value':T.value, 'Unit':T.unit, 'Condition':T.condition, 'Property':T.prop,\n 'Reference':str(file_name)}\n \n json_list.append(dictionary_chemical)\n\n if show_property:\n print (\"value:\", T, \"condition:\", T.condition, \"chemical:\", T.target)\n \n if isinstance(next_represent_chem, Chemical) or not next_represent_chem:\n before_represent_chem = next_represent_chem \n \n if return_documenTM:\n return json_list, Q\n \n return json_list","def pdf_to_txt(full_path):\n file = open(full_path,'rb')\n extracted_text = parser.from_buffer(file)\n return extracted_text['content']","def get_corpus(self):\n rsrcmgr = PDFResourceManager()\n retstr = StringIO()\n codec = 'utf-8'\n laparams = LAParams()\n device = TextConverter(\n rsrcmgr, retstr, codec=codec, laparams=laparams)\n interpreter = PDFPageInterpreter(rsrcmgr, device)\n maxpages = 0\n caching = True\n pagenos = set()\n pages = PDFPage.get_pages(\n self.stream_in,\n pagenos,\n maxpages=maxpages,\n password=\"\",\n caching=caching,\n check_extractable=True\n )\n for page in pages:\n interpreter.process_page(page)\n device.close()\n text = retstr.getvalue()\n retstr.close()\n return text","def parse_docs_from_page(self, page_url: str, page_text: str) -> Iterable[Document]:\n # parse html response\n url = \"https://www.med.navy.mil/directives/Pages/Publications.aspx\"\n base_url = 'https://www.med.navy.mil'\n parsed_docs = []\n doc_name_list = []\n if (page_url.find(\"Publications\") != -1):\n doc_type = \"NAVMED\"\n elif (page_url.find(\"BUMEDNotes\") != -1):\n doc_type = \"BUMEDNOTE\"\n elif (page_url.find(\"BUMEDInstructions\") != -1):\n doc_type = \"BUMEDINST\"\n cac_required = ['CAC', 'PKI certificate required', 'placeholder', 'FOUO']\n page = requests.get(page_url, verify=CERTIFICATE_DIR + '/cat3.pem')\n soup = bs4.BeautifulSoup(page.content, 'html.parser')\n webpart = soup.find(id=\"onetidDoclibViewTbl0\")\n items = webpart.find_all('a')\n meta = webpart.find_all(lambda tag: tag.name == 'td' and tag.get('class') == ['ms-vb2'])\n meta_list = list(meta)\n meta_list = [remove_html_tags(str(t)) for t in meta_list]\n meta_list = [str(t).encode('ascii', 'ignore').decode('ascii') for t in meta_list]\n meta_list = [x.replace(\"\\r\\n\", \" \") for x in meta_list]\n if (doc_type == \"NAVMED\"):\n n = 3\n elif (doc_type == \"BUMEDINST\" or doc_type == \"BUMEDNOTE\"):\n n = 4\n meta_ = [meta_list[i:i + n] for i in range(0, len(meta_list), n)]\n if (doc_type == \"NAVMED\"):\n subject = webpart.find_all(lambda tag: tag.name == 'td' and tag.get('class') == ['ms-vb-title'])\n name_list = list(subject)\n name_list = [remove_html_tags(str(t)) for t in name_list]\n name_list = [str(t).encode('ascii', 'ignore').decode('ascii') for t in name_list]\n subnum = [str(t[1]).split()[:2] for t in meta_]\n title_ = [str(t[1]).split()[2:] for t in meta_]\n title = [' '.join(t) for t in title_]\n title = [str(t).replace(',', '') for t in title]\n date = [t[0] for t in meta_]\n metadata = zip(subnum, title, date, name_list)\n metadata = [list(a) for a in metadata]\n elif (doc_type == \"BUMEDINST\"):\n subject = webpart.find_all(lambda tag: tag.name == 'td' and tag.get('class') == ['ms-vb-title'])\n name_list = list(subject)\n name_list = [remove_html_tags(str(t)) for t in name_list]\n name_list = [str(t).encode('ascii', 'ignore').decode('ascii') for t in name_list]\n metadata = list(zip(name_list, meta_))\n elif (doc_type == \"BUMEDNOTE\"):\n metadata = meta_\n item_list = list(items)\n pdf_links = [link['href'] for link in item_list if link['href'].endswith(('pdf', 'html'))]\n pdf_links = [\"https://www.med.navy.mil\" + a for a in pdf_links]\n pdf_links = [str(a).replace(' ', '%20') for a in pdf_links]\n if (doc_type == \"BUMEDINST\" or doc_type == \"BUMEDNOTE\"):\n metadata = [list(ele) for ele in metadata]\n for i in range(0, len(metadata)):\n metadata[i].append(pdf_links[i])\n for item in metadata:\n if (doc_type == \"NAVMED\"):\n pdf_di = DownloadableItem(doc_type='pdf', web_url=item[4])\n if (str(item[3])[0].isdigit()):\n doc_name = \"NAVMED P-\" + str(item[3]).split()[0]\n doc_num = \"P-\" + str(item[3]).split()[0]\n if (doc_name in doc_name_list):\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\n doc_name = doc_type + \" \" + doc_num + \"-\" + str(number_of_times)\n doc_num = doc_num + \"-\" + str(number_of_times)\n else:\n doc_name = \"NAVMED \" + str(item[0][1]) + \" \" + ' '.join(str(item[3]).split()[:3])\n doc_num == str(item[0][1]) + \" \" + ' '.join(str(item[3]).split()[:3])\n if (doc_name in doc_name_list):\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\n doc_name = doc_type + \" \" + doc_num + \"-\" + str(number_of_times)\n doc_num = doc_num + \"-\" + str(number_of_times)\n doc_title = str(item[1])\n publication_date = str(item[2])\n cac_login_required = False\n crawler_used = \"navy_med_pubs\"\n source_page_url = page_url\n downloadable_items = [pdf_di]\n version_hash_fields = {\n \"item_currency\": str(item[3]).split('/')[-1], # version metadata found on pdf links\n \"pub_date\": publication_date.strip(),\n \"document_title\": doc_title.strip(),\n \"document_number\": doc_num.strip()\n }\n\n elif (doc_type == \"BUMEDINST\"):\n pdf_di = DownloadableItem(doc_type='pdf', web_url=item[2])\n doc_num = str(item[0]).split()[0]\n doc_name = doc_type + \" \" + doc_num\n doc_title = str(item[1][1])\n publication_date = str(item[1][0])\n if (str(item[2]).endswith('html')):\n cac_login_required = True\n elif (str(item[2]).endswith('pdf')):\n cac_login_required = False\n if (doc_name in doc_name_list):\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\n doc_name = doc_type + \" \" + doc_num + \"-\" + str(number_of_times)\n doc_num = doc_num + \"-\" + str(number_of_times)\n doc_name_list.append(doc_name)\n elif (doc_type == \"BUMEDNOTE\"):\n pdf_di = DownloadableItem(doc_type='pdf', web_url=item[4])\n doc_num = str(item[0]).split()[1]\n doc_name = doc_type + \" \" + doc_num\n doc_title = str(item[2])\n publication_date = str(item[1])\n cac_login_required = False\n if (doc_name in doc_name_list):\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\n doc_name = doc_type + \" \" + doc_num + \"-\" + str(number_of_times)\n doc_num = doc_num + \"-\" + str(number_of_times)\n doc_name_list.append(doc_name)\n version_hash_fields = {\n \"doc_name\": doc_name, # version metadata found on pdf links\n \"pub_date\": publication_date.strip(),\n \"document_title\": doc_title.strip(),\n \"document_number\": doc_num.strip()\n }\n version_hash_raw_data = version_hash_fields\n doc = Document(\n doc_name=re.sub(',', '', doc_name.strip()),\n doc_title=re.sub('\\\\\"', '', doc_title),\n doc_num=re.sub(',', '', doc_num.strip()),\n doc_type=re.sub(',', '', doc_type.strip()),\n publication_date=publication_date,\n cac_login_required=cac_login_required,\n crawler_used=\"navy_med_pubs\",\n source_page_url=page_url.strip(),\n version_hash_raw_data=version_hash_fields,\n downloadable_items=[pdf_di]\n )\n parsed_docs.append(doc)\n return parsed_docs","def extract_text(path, pages):\n out = []\n with open(path, 'rb') as file:\n pdftotext_string = pdftotext.PDF(file)\n\n for i in pages:\n out.append(pdftotext_string[i - 1])\n\n return out","def get_text_from_page(page_content: str) -> str:\n\n soup = BeautifulSoup(page_content, 'lxml')\n\n for tag in soup.findAll([\"script\", \"style\"]):\n tag.extract()\n\n lines = (line.strip() for line in soup.get_text().splitlines())\n\n return '\\n'.join(line for line in lines if line) # remove empty lines","def getCorpus(self, link, p):\n # Initialize list to hold links to articles\n article_links = []\n # Get links to all articles\n for page in range(p):\n articles = requests.get(link + \"page/\" + str(page + 1) + \"/\").text\n article_links += re.findall('<a href=\"(.+)\"><img width', articles)\n # Instantiate string to hold all text\n all_text = \"\"\n # Get each article\n for link in article_links:\n article = requests.get(link).text\n # Get article text\n article_text = re.findall('<div class=\"entry-content\">\\n([\\s\\S]+)' + \"\\n<p id='tagline'>\", article)[0]\n # Clean article text\n article_text = re.sub(\"<.+?>\", \"\", article_text)\n article_text = re.sub(\"â..\", \"'\", article_text)\n article_text = re.sub(\"Â\", \"\", article_text)\n article_text = re.sub(\"–\", \"\", article_text)\n article_text = re.sub(\"\\xa0\", \"\", article_text)\n # Append article text to string\n all_text += \"\\n\\n\" + article_text\n return all_text.strip()","def extract_paragraph_test(file_name, url_text = None, show_property = False, database = None, extract_all_property=False, \n return_documenTM = False, cut_off = True, unit_dict = None):\n if not url_text:\n url_text = file_name\n \n if not database: \n database = {}\n \n if not isinstance(unit_dict, dict):\n unit_dict = unit_dict_default\n \n keyword_dict = make_keyword_dict(unit_dict)\n \n Q = DocumentTM(file_name, **database)\n Q.doc(parser = 'cde_parser')\n Q.find_strange()\n chemical_type_dict = {}\n database = Q.database()\n \n data_collection = []\n json_list = []\n \n for Para in Q.Para:\n new_split, unit = Q.tokenize_test(Para, lemma = False, Strange = True, cut_off=cut_off)\n \n if not new_split:\n continue\n \n #print (new_split)\n \n before_represent_chem = False\n \n for sent in cut_paragraph(new_split):\n new_sent, unit_dictionary, next_represent_chem = matching_algorithm(sent, database, chemical_type_dict, before_represent_chem)\n\n if extract_all_property:\n #iters = chain.from_iterable(unit_dictionary.values())\n iters = chain.from_iterable([dics.values() for dics in unit_dictionary.values()])\n else:\n iters = unit_dictionary['Character'].values()\n \n \n #print (unit_dictionary['Character'])\n #if unit_dictionary['Character'] or unit_dictionary['Reaction']:\n #data_collection.append([sent, unit_dictionary])\n \n if show_property and (unit_dictionary['Character'] or unit_dictionary['Reaction']):\n \n print (\"\\n\\n------------------------------------\")\n print (file_name)\n print (\" \".join([str(t) for t in new_sent]))\n print (\"\\n\")\n #print (Para)\n #print (\" \".join(new_split))\n print (\"------------------------------------\")\n \n for T in chain.from_iterable(iters):\n #for T in t:\n dictionary_chemical = {'Material':T.target, 'Value':T.value, 'Unit':T.unit, 'Condition':T.condition, 'Property':T.prop,\n 'Reference':str(file_name)}\n \n json_list.append(dictionary_chemical)\n\n if show_property:\n print (\"value:\", T, \"condition:\", T.condition, \"chemical:\", T.target)\n \n if isinstance(next_represent_chem, Chemical) or not next_represent_chem:\n before_represent_chem = next_represent_chem \n \n if return_documenTM:\n return json_list, Q\n \n return json_list","def get_full_text_from_source(self):\n extension = self.get_doc_file_extension()\n\n if extension in ('txt', ''):\n # string = unicode(string)\n return self.doc_file.read().decode(\"utf-8\")\n elif extension == 'docx':\n docx_document = Docx(BytesIO(self.doc_file.read()))\n return \"\\n\".join(p.text for p in docx_document.paragraphs)\n elif extension == 'pdf':\n raise NotImplementedError()\n else:\n raise ValueError(\"file_format not supported\")","def page_extract(tree, *, textequiv_level=\"region\"):\n\n # Internally, this is just parsing the Reading Order (if it exists) and\n # and leaves reading the TextRegions to ExtractedText.from_text_segment().\n\n nsmap = {\"page\": page_namespace(tree)}\n\n regions = []\n reading_order = tree.find(\".//page:ReadingOrder\", namespaces=nsmap)\n if reading_order is not None:\n for group in reading_order.iterfind(\"./*\", namespaces=nsmap):\n regions.extend(\n extract_texts_from_reading_order_group(\n group, tree, nsmap, textequiv_level\n )\n )\n else:\n for region in tree.iterfind(\".//page:TextRegion\", namespaces=nsmap):\n regions.append(\n ExtractedText.from_text_segment(\n region, nsmap, textequiv_level=textequiv_level\n )\n )\n\n # Filter empty region texts\n regions = [r for r in regions if r.text != \"\"]\n\n return ExtractedText(None, regions, \"\\n\", None)","def extractText(text):\n soup = BeautifulSoup(text, 'html.parser')\n for code in soup.find_all('code'):\n code.decompose()\n return soup.get_text()","def get_text(downgrade_titles=False):","def get_text_hook(raw):\n soup = bs4.BeautifulSoup(quopri.decodestring(raw), features=\"lxml\")\n return soup.text","def get_text(doc_element: dict, document: dict):\n response = \"\"\n # If a text segment spans several lines, it will\n # be stored in different text segments.\n for segment in doc_element.text_anchor.text_segments:\n start_index = (\n int(segment.start_index)\n if segment in doc_element.text_anchor.text_segments\n else 0\n )\n end_index = int(segment.end_index)\n response += document.text[start_index:end_index]\n return response","def get_chapter_text(location):\n chapter_output_dictionary = {}\n chapter_contents_list = []\n\n soup = Ripper(location, parser=\"html5lib\", save_path=save_path).soup\n text = soup.find(\"table\", class_=\"texttable\")\n\n for each in text.find_all(\"p\"):\n attributes = each.attrs\n if attributes:\n if \"desc\" in attributes[\"class\"]:\n pass\n elif \"note\" in attributes[\"class\"]:\n pass\n else:\n new_cont = each.contents\n chapter_contents_list.extend(new_cont)\n return join_chapter_text(chapter_contents_list)","def get_text(self):\n text_complet = \"\"\n rez_dict = self.__results\n for i in range(0, len(rez_dict[\"text\"])):\n text = rez_dict[\"text\"][i]\n conf = int(rez_dict[\"conf\"][i])\n if conf > self.__min_confidence:\n text_complet += text + \" \"\n return text_complet","def get_article_body(url):\n headers = {'User-Agent': 'Codeup Data Science'}\n response = get(url, headers=headers)\n soup = BeautifulSoup(response.content, \"html.parser\") \n return soup.find('div', itemprop='text').text","def extract_compounds(text):\n comp_idx = 0\n compound = []\n compound_nps = []\n tok_idx = 0\n for idx, tok in enumerate(nlp(text)):\n if tok.dep_ == \"compound\":\n\n # capture hyphenated compounds\n children = \"\".join([c.text for c in tok.children])\n if \"-\" in children:\n compound.append(\"\".join([children, tok.text]))\n else:\n compound.append(tok.text)\n\n # remember starting index of first child in compound or word\n try:\n tok_idx = [c for c in tok.children][0].idx\n except IndexError:\n if len(compound) == 1:\n tok_idx = tok.idx\n comp_idx = tok.i\n\n # append the last word in a compound phrase\n if tok.i - comp_idx == 1:\n compound.append(tok.text)\n if len(compound) > 1:\n compound = \" \".join(compound)\n compound_nps.append(\n (compound, tok_idx, tok_idx + len(compound), \"COMPOUND\")\n )\n\n # reset parameters\n tok_idx = 0\n compound = []\n\n if len(compound_nps) != 0:\n return compound_nps[0][0]\n else:\n return \"\"","def text(self):\n return self.content","def extractText(html_code):\n html_tree = html.fromstring(html_code)\n chapter_list = html_tree.find_class(\"chapter\")\n chapter_text = chapter_list[0].text_content()\n return chapter_text","def extractText(postSoup):\n for tag in postSoup.findAll(True):\n if tag.name in (\"code\"):\n tag.extract()\n else:\n tag.hidden=True\n\n return postSoup.renderContents()","def get_text_only(self, soup):\n val = soup.string\n # see if we have a text element\n if val is None:\n conts = soup.contents\n resulttext = ''\n # not text so continue recursing through the tags\n for tag in conts:\n subtext = self.get_text_only(tag)\n resulttext += subtext + '\\n'\n return resulttext\n return val.strip()","def get_parsed_text(blob):\n return blob.parse()","def _compute_fulltext(self):\n return ''","def alchemy_page_text(url):\n # import AlchemyAPI\n try:\n # Create an AlchemyAPI object.\n alchemyObj = AlchemyAPI.AlchemyAPI()\n\n # Load the API key from disk.\n alchemyObj.loadAPIKey(\"api_key.txt\")\n\n # Extract page text from a web URL (ignoring navigation links, ads, etc.).\n result = alchemyObj.URLGetText(url)\n\n # Result returned in xml format with node 'text' containing the text\n text = xml_to_text(result)\n # remove new lines, tabs, and whitespace\n text = clean_text(text)\n\n return text\n\n except TypeError:\n return \"There is a TypeError in alchemy_page_text\"","def _get_plain_text(self, url, soup, site):\n print('Get plaint text: ' + url)\n title = str(soup.find(class_=self._title_tags[site]))\n content = str(soup.find(class_=self._content_tags[site]))\n # h = html2text.HTML2Text() # uncomment this segment of code\n # h.ignore_links = True # if you want to get plain text\n # h.ignore_images = True\n # title = h.handle(title)\n # content = h.handle(content)\n if title == None or content == None:\n print('Different website structure: ' + url)\n return ''\n return self._clean(title + content, no_punc=True) # with symbols\n # return title + content # without symbols","def get_full_text(self, item):\n photoset_content = self.db.plugin_photoset_content(\n item_id=item.unique_id)\n output = self.response.render(\n 'plugin_photoset/full_text.txt',\n dict(photoset_content=photoset_content, item=item))\n return unicode(output.decode('utf-8'))","def get_wiki_content(self):\n url = \"https://fr.wikipedia.org/w/api.php?action=query&prop=extracts&exsentences=4&explaintext=&pageids={}&format=json\".format(self.page_id)\n self.page = str(self.page_id)\n self.response = requests.get(url)\n self.data = self.response.json()\n self.wiki_data = (self.data['query']['pages'][self.page]['extract'])\n return (self.wiki_data)","def _get_text(raw_html):\n bs = BeautifulSoup(raw_html)\n text_nodes = bs.find_all(_is_text_tag)\n text_elements = [_get_child_text(node) for node in text_nodes]\n return ' '.join(chain(*chain(*text_elements)))","def get_text(api, obj_type):\n\n if obj_type == \"comments\":\n search_function = api.search_comments\n filters = [\"author\", \"body\"]\n check_attr = \"body\"\n else: # type == \"submissions\"\n search_function = api.search_submissions\n filters = [\"author\", \"title\", \"selftext\"]\n check_attr = \"selftext\"\n\n text = list(\n search_function(\n after=YESTERDAY, before=TODAY, subreddit=\"wallstreetbets\", filter=filters\n )\n )\n\n # prevent errors caused by removed/deleted posts\n text[:] = [\n x for x in text if getattr(x, check_attr) not in (\"[removed]\", \"[deleted]\")\n ]\n\n return text","def text_getter(target_url):\n response = requests.get(target_url)\n # response.encoding = \"utf-8\"\n decoded_text = response.text\n\n return book_title(decoded_text), get_text_tokens(decoded_text)","def text(filename, level=\"region\", index=\"0\"):\n\n try:\n tree = ET.parse(filename)\n except XMLSyntaxError:\n with open(filename, 'r') as f:\n return f.read()\n try:\n return page_text(tree, level=level, index=index)\n except ValueError:\n return alto_text(tree)","def get(self, docid):\n file = os.path.join(self.dirname, docid)\n with open(file,'r',encoding='utf-8') as f:\n text = f.read()\n return text","def get_corpus_text(nr_files=199):\n fileids = nltk.corpus.treebank_raw.fileids()[:nr_files]\n corpus_text = nltk.corpus.treebank_raw.raw(fileids)\n corpus_text = corpus_text.replace(\".START\", \"\")\n return corpus_text","def get_abs_text(record):\n\n result = []\n\n try:\n for item in record['MedlineCitation']['Article']['Abstract']['AbstractText']:\n result.append(item)\n except KeyError:\n pass\n\n if len(result) == 0:\n return '*Abstract Unavailable*'\n else:\n return ' '.join(result)","def get_bibtex(self):\n url=\"http://www.biomedcentral.com/download/citation\"\n parameters={'citation':'on', \n 'result-selection':'THIS_PAGE',\n 'suplements': 'false',\n 'citationType':'BIBTEX_WITH_ABSTRACT',\n 'articleIdThisPage':self.article_ids\n }\n data=urllib.urlencode(parameters)\n self.bibtex=urllib2.urlopen(url,data)","def getText(self):\n return(' '.join(map(lambda x:x.text,self.getNested())))","def __get_page(self):\n params = {'query': self.query,\n 'corpname': self.subcorpus,\n 'start': self.__pagenum}\n s = get('http://korpus.juls.savba.sk:8080/manatee.ks/do_query', params=params)\n return s.text","def get_txt(url):\n soup = make_soup(url)\n\n # remove scripts and styling\n for script in soup([\"script\", \"style\"]):\n script.extract() # rip it out\n text = soup.get_text()\n\n # clean data\n lines = (line.strip() for line in text.splitlines())\n chunks = (phrase.strip() for line in lines for phrase in line.split(\" \"))\n text = '\\n'.join(chunk for chunk in chunks if chunk)\n\n return text","def parse_text(self, page):\n text = page.find(self.tag_prefix + self.revision_tag).find(self.tag_prefix + self.text_tag).text\n title = page.find(self.tag_prefix + self.title_tag).text\n categories = []\n #\n text = self.parse_archivo(text)\n text = self.parse_foto(text)\n text = self.parse_by_line(text)\n text = self.parse_link(text)\n text = self.parse_url(text)\n text = self.parse_fecha(text)\n text = self.parse_bracketed_word(text)\n #\n if text:\n categories = re.findall(self.category_finder_regex, text)\n #\n text = self.parse_category(text)\n text = self.parse_other_language(text)\n text = self.parse_table_regex(text)\n text = self.parse_ver_fuente(text)\n text = self.remove_extra_text(text)\n text = self.remove_extra_characters(text)\n\n categorias = []\n for cat in categories:\n categorias.append(cat[6])\n\n if text:\n if 'REDIRECT' in text or 'redirect' in text:\n return None\n\n return Article(title=title, content=text, categories=categorias)","def get_book(url):\n text = requests.get(url).text\n time.sleep(5) # Delay for 5 seconds\n\n # Transform \\r\\n with \\n newline\n subtext = re.sub(r'\\r\\n', '\\n', text) \n\n # Extract content from START to END\n pat = '\\*\\*\\* START OF THIS PROJECT GUTENBERG EBOOK .* \\*\\*\\*([\\S\\s]*)\\*\\*\\* END OF THIS PROJECT GUTENBERG EBOOK'\n content = re.search(pat, subtext).group(1)\n return content","def full_text(self):\n\n if self._full_text == []:\n for sentence in self.title():\n self._full_text.append(sentence)\n for sentence in self.abstract():\n self._full_text.append(sentence)\n for sentence in self.body():\n self._full_text.append(sentence)\n\n return self._full_text","def get_docx_text(path):\n document = zipfile.ZipFile(path)\n xml_content = document.read('word/document.xml')\n document.close()\n tree = XML(xml_content)\n \n paragraphs = []\n for paragraph in tree.getiterator(PARA):\n texts = [node.text\n for node in paragraph.getiterator(TEXT)\n if node.text]\n if texts:\n paragraphs.append(''.join(texts))\n \n return '\\n\\n'.join(paragraphs)","def get_contenu(self):\n return self.objets","def parsepdf(intext): # type: (str) -> str\n\n pdfbinarydata = base64.b64decode(intext.strip())\n pdfFileObj = io.BytesIO()\n pdfFileObj.write(pdfbinarydata)\n pdfReader = PyPDF2.PdfFileReader(pdfFileObj)\n extractedText = ''\n for i in range(0, pdfReader.numPages):\n pageObj = pdfReader.getPage(i)\n extractedText = extractedText + pageObj.extractText()\n\n return extractedText.strip()","def scrape_description(main_soup):\n rich_text = main_soup.find('div', {'class': 'rich-text'})\n description = rich_text.find('p').text\n\n return description","def getText():","def getText():","def getText():","def getText():","def getText():","def _get_text(self, remove_newlines=True):\n if not self.text:\n url = self.url\n try:\n self.log.debug(\"Try to get content from page {}\".format(url))\n r = requests.get(url)\n except requests.exceptions.RequestException as e:\n self.log.warn(\"Unable to get page content of the url: {url}. \"\n \"The reason: {exc!r}\".format(url=url, exc=e))\n raise ParsingError(e.strerror)\n\n ud = UnicodeDammit(r.content, is_html=True)\n\n enc = ud.original_encoding.lower()\n declared_enc = ud.declared_html_encoding\n if declared_enc:\n declared_enc = declared_enc.lower()\n # possible misregocnition of an encoding\n if (declared_enc and enc != declared_enc):\n detect_dict = chardet.detect(r.content)\n det_conf = detect_dict[\"confidence\"]\n det_enc = detect_dict[\"encoding\"].lower()\n if enc == det_enc and det_conf < THRESHOLD_OF_CHARDETECT:\n enc = declared_enc\n # if page contains any characters that differ from the main\n # encoding we will ignore them\n content = r.content.decode(enc, \"ignore\").encode(enc)\n htmlparser = etree.HTMLParser(encoding=enc)\n root = etree.HTML(content, parser=htmlparser)\n etree.strip_elements(root, html.etree.Comment, \"script\", \"style\")\n text = html.tostring(root, method=\"text\", encoding=\"unicode\")\n\n if remove_newlines:\n self.log.debug(str(type(text)))\n text = re.sub('\\s+', ' ', text)\n self.text = text\n\n return self.text","def test_text_resource(self):\n Repository = CTSCapitainsLocalResolver([\"./tests/testing_data/farsiLit\"])\n text, metadata = Repository.__getText__(\"urn:cts:farsiLit:hafez.divan.perseus-eng1\")\n self.assertEqual(\n len(text.citation), 4,\n \"Object has a citation property of length 4\"\n )\n self.assertEqual(\n text.getTextualNode(Reference(\"1.1.1.1\")).export(output=Mimetypes.PLAINTEXT),\n \"Ho ! Saki, pass around and offer the bowl (of love for God) : ### \",\n \"It should be possible to retrieve text\"\n )","def get_text(bucket, key):\n s3 = boto3.resource(\"s3\")\n\n ocr_obj = s3.Object(bucket, key)\n response = ocr_obj.get()\n data = response[\"Body\"].read()\n\n return data","def _generateCurrentLineText(self, obj, **args ):\n result = self._generateSubstring(obj, **args)\n if result:\n return result\n\n [text, caretOffset, startOffset] = self._script.getTextLineAtCaret(obj)\n if text and not self._script.EMBEDDED_OBJECT_CHARACTER in text:\n return [text]\n\n return []","def extract_text(fname):\n\n laparams = pdfminer.layout.LAParams()\n for param in ('all_texts', 'detect_vertical', 'word_margin', 'char_margin', 'line_margin', 'boxes_flow'):\n paramv = locals().get(param, None)\n if paramv is not None:\n setattr(laparams, param, paramv)\n\n # send output to a string stream\n outfp = io.StringIO()\n\n with open(fname, 'rb') as fp:\n pdfminer.high_level.extract_text_to_fp(fp, outfp=outfp, codec='utf-8',\n laparams=laparams, pages=0)\n\n return outfp.getvalue()","def get_10k_text(url):\n\n\trawdoc = BeautifulSoup(requests.get(url).content, 'html.parser')\n\n\theaders = []\n\ttext = []\n\tstart_recording = False # record headers between business & risk factors section\n\tfor data in rawdoc.html.body:\n\t\ttry:\n\t\t\tattributes = convert_attr_to_dict(data.find('font')['style'])\n\t\t\tis_header = attributes.get('font-weight') == 'bold' # recognize bold text as header\n\t\t\tif is_header:\n\t\t\t\tif 'business' in data.text.lower(): # start of relevant section\n\t\t\t\t\tstart_recording = True\n\t\t\t\tif 'risk factors' in data.text.lower(): # end of relevant section\n\t\t\t\t\tbreak\n\t\t\t\tif start_recording:\n\t\t\t\t\theaders.append(data.text)\n\t\t\telse: # assume text is paragraph section\n\t\t\t\tif start_recording: # record text\n\t\t\t\t\ttext.append(data.text)\n\t\texcept: # cheeky too broad catch all -> we are going to filter out poorly scraped data later\n\t\t\tcontinue\n\n\treturn headers, text","def get_article_body(url):\n G.go(url)\n text = G.doc.select('////div[@class=\"StandardArticleBody_body\"]').text()\n return text","def parse_content(self, api):\n abstract = ''\n for tag in api.next_siblings:\n if tag.name == 'hr' or tag.name == 'blockquote':\n break\n elif tag.name == 'div':\n continue\n else:\n abstract+=(str(tag))\n return abstract.strip('\\n')","def get_text(self):\n return self.output.getvalue()","def getdoc(object):\r\n try:\r\n doc = object.__doc__\r\n except AttributeError:\r\n return None\r\n if not isinstance(doc, types.StringTypes):\r\n return None\r\n return cleandoc(doc)","def raw_text(self):\n return self._raw_text","def parse(text):\n md = markdown.Markdown(['codehilite', 'tables', ])\n\n for iref in re.findall(img_ref_re, text):\n img_id = iref[7]\n try:\n image = FlatPageImage.objects.get(pk=int(img_id))\n md.references[img_id] = (image.image_path.url, '')\n except ObjectDoesNotExist:\n pass\n\n for lref in re.findall(reference_re, text):\n doc_name = lref[7]\n try:\n doc = File.objects.get(name=doc_name)\n md.references[doc_name]= (doc.url, doc.name)\n except ObjectDoesNotExist:\n pass\n\n return md.convert(text)","def fetch_doc_text_body(self, document_level, find_query_mixin={}):\n find_query = {'subreddit': self.subreddit, 'postwise.text':{'$exists':True}}\n find_query.update(find_query_mixin)\n\n if document_level != 'postwise':\n raise NotImplementedError('document_level:%s' % document_level)\n\n print 'found %i matching the query for text body docs' % self.posts_read.find(find_query).count()\n\n for doc in self.posts_read.find(find_query):\n yield doc['_id'], doc[document_level]['text']","def 取所有项目文本(self): # real signature unknown; restored from __doc__\n return self.GetStrings()","def extract_raw_text(soup, url):\n \n title_class = \"nom-notice\"\n title = soup.find(class_=title_class)\n raw_infos = {}\n raw_infos['name'] = title.contents[0].replace(u'\\xa0', ' ')\n \n notice = soup.find(class_=\"notice\")\n \n summary = notice.find(class_=\"chapo\")\n if summary is not None:\n first_para = summary.find_all('p', recursive=False)[-1]\n first_para.tag = 'div'\n first_para['class'] = 'summary'\n raw_infos['summary'] = unicode(first_para)\n \n else:\n raw_infos['summary'] = unicode('')\n\n article = notice.find(class_='texte')\n if article is not None:\n article['class'] = 'article'\n raw_infos['article'] = unicode(article)\n \n sources = notice.find(class_='sources')\n raw_infos['sources'] = unicode(sources)\n \n works = notice.find(class_='oeuvres')\n if works is not None:\n works['class'] = 'works'\n raw_infos['works'] = unicode(works)\n \n # In function that writes, encode everything to bytes! .encode('utf-8')\n return raw_infos","def get_text(self):\n return self.text","def contents(self, n, m):\n str = \"\"\n subset = self.getlines(n, m)\n for line in subset:\n str = str + line + \"\\n\"\n return str.rstrip(\"\\n\")","def get_texts(json_object):\n texts = list()\n texts.append(json_object.get(FIELD_NAMES_CITIES['text_field']))\n return texts","def extract_documents():\n client = MongoClient()\n conn = client.data\n coll = conn.germanwings\n\n query = {'text': {'$exists': 1}, 'exc': {'$exists': 0}}\n selection = {'text': 1, 'short_url': 1}\n for i, doc in enumerate(coll.find(query, selection)):\n short_url, text = tuple(doc[x] for x in (\"short_url\", \"text\"))\n print(\"Extracting {0} {1}\".format(i, short_url), file=stderr)\n filename = os.path.join(RAW_DIR, short_url)\n with open(filename, \"w\") as f:\n ascii = text.encode('ascii', 'ignore')\n f.write(ascii)","def get_text(self):\n\n return self.output['text']","def text_of(soup):\n return ''.join([str(x) for x in soup.findAll(text=True)])","def text():\n return {\n \"@context\": \"http://www.w3.org/ns/anno.jsonld\",\n \"type\": \"Annotation\",\n \"body\": {\n \"creator\": \"user\",\n \"type\": \"TextualBody\",\n \"value\": \"string\"\n },\n \"generator\": {\n \"homepage\": \"http://mnemosyne.ml\",\n \"id\": \"string\",\n \"name\": \"Mnemosyne\",\n \"type\": \"Mnemosyne\"\n },\n \"target\": {\n \"id\": \"string\",\n \"type\": \"TextQuoteSelector\",\n \"exact\": \"string\",\n \"format\": \"string\",\n \"source\": \"string\",\n \"prefix\": 0,\n \"suffix\": 0,\n \"refinedBy\": {\n \"type\": \"TextPositionSelector\",\n \"start\": \"/div[2]\",\n \"end\": \"/div[2]\"\n },\n },\n }","def getText(self):","def pages_split(text: str, document: dict, uri, gcs_output_uri : str, gcs_output_uri_prefix :str ):\n for i, entity in enumerate(document.entities):\n confidence = entity.confidence\n text_entity = ''\n for segment in entity.text_anchor.text_segments:\n start = segment.start_index\n end = segment.end_index\n text_entity += text[start:end]\n \n pages = [p.page for p in entity.page_anchor.page_refs]\n print(f\"*** Entity number: {i}, Split Confidence: {confidence} ***\")\n print(f\"*** Pages numbers: {[p for p in pages]} ***\\nText snippet: {text_entity[:100]}\")\n print(\"type: \" + entity.type_)\n start_page= pages[0]\n end_page = pages[len(pages)-1]\n print(start_page)\n print(end_page)\n \n storage_client = storage.Client()\n bucket = storage_client.get_bucket(uri.hostname)\n blob = bucket.get_blob(uri.path[1:])\n\n inputpdf= PdfFileReader(\n io.BytesIO(blob.download_as_bytes())\n ,strict=False) \n \n split_pdf(inputpdf, start_page, end_page, uri,gcs_output_uri, gcs_output_uri_prefix + \"/\" + entity.type_)","def extract(content):\n parser = MyHTMLParser()\n parser.textBody = []\n parser.feed(content)\n textBody = parser.textBody\n textBody = \" \".join(textBody)\n textBody = textBody.replace('\\xa0', \" \")\n return textBody.strip()","def extract_text_from_pdf(file):\n\n return RegexpTokenizer(r'\\w+').tokenize(parser.from_file(file)['content'])","def extract(key, path_pdf):\n\n path_tmp_pdf = extract_first_page(path_pdf)\n\n # extract all text from first page\n raw_text = extract_text(path_tmp_pdf)\n\n # extract abstract from whole page and replace hyphens etc.\n abstract = extract_abstract(raw_text)\n\n # something went wrong when abstract is longer than 1500 chars\n if len(abstract) > MAX_LEN:\n print('{}: Abstract is too long.'.format(path_pdf))\n\n if not abstract:\n print('{}: Could not extract abstract.'.format(path_pdf))\n\n # clean up temp file\n os.unlink(path_tmp_pdf)\n\n # TODO: Fix this return object\n out = {'@key': key, 'abstract': abstract}\n\n return out","def pdf_to_text(file_object):\n pdfData = file_object.read()\n tf = tempfile.NamedTemporaryFile()\n tf.write(pdfData)\n tf.seek(0)\n outputTf = tempfile.NamedTemporaryFile()\n\n if len(pdfData) > 0:\n out, err = subprocess.Popen([\"pdftotext\", \"-layout\", tf.name, outputTf.name ]).communicate()\n return outputTf.read()\n else:\n return None","def full_text(self) -> str:\n return self._full_text","def format_ocr_text(self, page):\n \n #read out of the text file that tesseract made\n ocr_text = open(self.ocr_text, 'r')\n \n # write into this file\n djvu_text = open( self.djvu_text, 'w' )\n \n text = \"(page 0 0 1 1\\n\"\n \n self.out_text.write('\\n## Page %d ###\\n\\n' % page )\n \n for line in ocr_text:\n \n #write to the human readable file\n self.out_text.write(line)\n \n # add each line of text\n # escaping \" to \\\" as we go\n text += '(line 0 0 1 1 \"%s\")\\n' % line.replace('\"', r'\\\"').strip()\n \n text += \")\\n\"\n \n djvu_text.write( text )\n \n ocr_text.close()\n djvu_text.close()"],"string":"[\n \"def raw_text(self):\\n\\t\\t\\n\\t\\t #eliminating more headers\\n\\t\\traw_text = re.sub(r\\\".*OPERATIONS O[PF].*\\\",r\\\"\\\",self.doc)\\n\\t\\traw_text = re.sub(r\\\"Page \\\\d+\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*B[lL]OCK.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*WEST GULF.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*NAVAL FORCES ON.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\"\\\\s\\\",r\\\" \\\", raw_text) #eliminating tabs etc. \\t \\t \\n\\t\\treturn raw_text\",\n \"def textify(read_pdf,spage,epage):\\n\\n page_text = \\\"\\\"\\n for page in range(spage, epage):\\n page_content = read_pdf.getPage(page)\\n page_text += page_content.extractText()\\n\\n full_text = page_text #.encode('utf-8')\\n return full_text\",\n \"def extract_page_text(self, bs_object):\\n\\n # kill all script and style elements\\n for script in bs_object([\\\"script\\\", \\\"style\\\", \\\"head\\\"]):\\n script.extract() # rip it out\\n\\n # get text\\n text = bs_object.get_text()\\n\\n # break into lines and remove leading and trailing space on each\\n lines = (line.strip() for line in text.splitlines())\\n # break multi-headlines into a line each\\n chunks = (phrase.strip() for line in lines for phrase in line.split(\\\" \\\"))\\n # drop blank lines\\n text_list_gen = (chunk for chunk in chunks if chunk)\\n text_list = list(text_list_gen)\\n # print \\\"TEXT LIST >>>\\\\n\\\", text_list\\n \\n return text_list\",\n \"def full_text(self):\\n return self.lxml.text_content()\",\n \"def extract(self):\\n\\n self.decode(CMS_object.extract(self))\\n return self.get_content()\",\n \"def page_text(tree, level=\\\"region\\\", index=\\\"0\\\"):\\n\\n nsmap = {'page': page_namespace(tree)}\\n\\n def region_text(region, index=\\\"0\\\"):\\n try:\\n reg = region.find('./page:TextEquiv/page:Unicode', namespaces=nsmap)\\n if reg is not None and reg.getparent().attrib.get('index','-1') in ['-1', index]:\\n return region.find('./page:TextEquiv/page:Unicode', namespaces=nsmap).text\\n else:\\n return None\\n except AttributeError:\\n return None\\n\\n def line_text(region, index=\\\"0\\\"):\\n try:\\n return \\\"\\\\n\\\".join([line.text for line in (region.findall('./page:TextLine/page:TextEquiv/page:Unicode', namespaces=nsmap))\\n if line is not None and line.getparent().attrib.get('index','-1') in ['-1', index]])\\n except AttributeError:\\n return None\\n\\n def word_text(region, index=\\\"0\\\"):\\n try:\\n text = []\\n textlines = []\\n lines = region.findall('./page:TextLine/', namespaces=nsmap)\\n for line in lines:\\n words = line.findall('./page:TextEquiv/page:Unicode', namespaces=nsmap)\\n if words:\\n for word in words:\\n if word.getparent().attrib.get('index','-1') in ['-1', index]:\\n text.append(word.text)\\n elif text != []:\\n textlines.append(\\\" \\\".join(text))\\n text = []\\n return \\\"\\\\n\\\".join(textlines)\\n except AttributeError:\\n return None\\n\\n region_texts = []\\n reading_order = tree.find('.//page:ReadingOrder', namespaces=nsmap)\\n if reading_order is not None:\\n for group in reading_order.iterfind('./*', namespaces=nsmap):\\n if ET.QName(group.tag).localname == 'OrderedGroup':\\n region_ref_indexeds = group.findall('./page:RegionRefIndexed', namespaces=nsmap)\\n for region_ref_indexed in sorted(region_ref_indexeds, key=lambda r: int(r.attrib['index'])):\\n region_id = region_ref_indexed.attrib['regionRef']\\n region = tree.find('.//page:TextRegion[@id=\\\"%s\\\"]' % region_id, namespaces=nsmap)\\n if region is not None and level == \\\"region\\\":\\n region_texts.append(region_text(region, index))\\n elif region is not None and level == \\\"line\\\":\\n region_texts.append(line_text(region, index))\\n elif region is not None and level == \\\"word\\\":\\n region_texts.append(word_text(region, index))\\n else:\\n warn('Not a TextRegion: \\\"%s\\\"' % region_id)\\n else:\\n raise NotImplementedError\\n else:\\n for region in tree.iterfind('.//page:TextRegion', namespaces=nsmap):\\n if region is not None and level == \\\"region\\\":\\n region_texts.append(region_text(region, index))\\n elif region is not None and level == \\\"line\\\":\\n region_texts.append(line_text(region, index))\\n elif region is not None and level == \\\"word\\\":\\n region_texts.append(word_text(region, index))\\n\\n # XXX Does a file have to have regions etc.? region vs lines etc.\\n # Filter empty region texts\\n region_texts = (t for t in region_texts if t)\\n\\n text_ = '\\\\n'.join(region_texts)\\n\\n return text_\",\n \"def digital_text(file_path):\\n doc = fitz.open(file_path)\\n page_count = doc.pageCount\\n print(\\\"\\\\n number of pages : \\\",page_count)\\n total_text = \\\"\\\"\\n try:\\n for page_num in range(page_count):\\n p = doc.loadPage(page_num)\\n page_text = p.getText()\\n total_text += page_text\\n print(\\\"\\\\n number of pages extracted : \\\", (page_count))\\n except Exception as e:\\n print(\\\"\\\\n Error in digital_text : \\\", traceback.format_exc(()))\\n return total_text\",\n \"def get_text(self):\",\n \"def get_text(adm, obj):\\n return adm['data'][slice(*extent(obj))]\",\n \"def readFile(self):\\n with pdfplumber.open(self.path) as pdf:\\n first_page = pdf.pages[0]\\n text = first_page.extract_text()\\n text = text.split('\\\\n')\\n return processText(text)\",\n \"def get_text(self):\\n return self.text[:500]\",\n \"def extract_text(url, sem):\\n with (yield from sem):\\n page = yield from get(url)\\n\\n tree = etree.HTML(page)\\n paragraphs = tree.findall('.//*/div[@class=\\\"entry-content\\\"]/p')[1:-1]\\n return url, b'\\\\n'.join(map(etree.tostring, paragraphs))\",\n \"def extract_text(filename):\\n\\tpdfFileObj = open(filename, \\\"rb\\\")\\n\\tpdfReader = PyPDF2.PdfFileReader(pdfFileObj)\\n\\n\\tmytext = \\\"\\\"\\n\\n\\tfor pageNum in range(pdfReader.numPages):\\n\\t\\tpageObj = pdfReader.getPage(pageNum)\\n\\t\\tmytext += pageObj.extractText()\\n\\n\\tpdfFileObj.close()\\n\\n\\treturn mytext\",\n \"def fulltext(self):\\n child_contents = ''\\n for c in self.children:\\n child_contents += c.fulltext\\n return self.text + child_contents\",\n \"def extract_page_text(html):\\n soup = bs4.BeautifulSoup(html)\\n\\n # Remove <script/> and <style/> content\\n for script in soup([\\\"script\\\", \\\"style\\\"]):\\n script.extract()\\n\\n text = soup.get_text()\\n\\n # Strip leading and trailing whitespace from each line, then join all the\\n # non-empty lines together.\\n lines = (line.strip() for line in text.splitlines())\\n text = '\\\\n'.join(line for line in lines if line)\\n\\n return text\",\n \"def get_complete_text(doc_list):\\n complete_text = \\\"\\\"\\n for doc in doc_list:\\n text = read_file( doc, mode='rb', ignore_comments= False).decode('utf-8')\\n complete_text = complete_text + text\\n return complete_text\",\n \"def text(self):\\n return self.full_text\",\n \"def get_data_from_pdf(self, regex):\\n match = re.search(regex, self.page_text)\\n return match.group(0).replace(\\\" \\\", \\\"\\\").replace(\\\"\\\\n\\\", \\\"\\\")\",\n \"def obtain_text():\\n pass\",\n \"def extract_paragraph(file_name, url_text = None, show_property = False, database = None, extract_all_property=False, \\n return_documenTM = False, cut_off = True, unit_dict = None, special_unit_dictionary = None):\\n if not url_text:\\n url_text = file_name\\n \\n if not database: \\n database = {}\\n \\n if not isinstance(unit_dict, dict):\\n unit_dict = unit_dict_default\\n \\n keyword_dict = make_keyword_dict(unit_dict)\\n \\n Q = DocumentTM(file_name, **database)\\n Q.doc()\\n Q.find_strange()\\n chemical_type_dict = {}\\n database = Q.database()\\n \\n if special_unit_dictionary:\\n Q.set_special_unit(special_unit_dictionary)\\n \\n \\n data_collection = []\\n json_list = []\\n \\n for Para in Q.Para:\\n new_split, unit = Q.tokenize_paragraph(Para, lemma = False, Strange = True, cut_off=cut_off)\\n \\n if not new_split:\\n continue\\n \\n #print (new_split)\\n \\n before_represent_chem = False\\n \\n for sent in cut_paragraph(new_split):\\n new_sent, unit_dictionary, next_represent_chem = matching_algorithm(sent, database, chemical_type_dict, before_represent_chem)\\n\\n if extract_all_property:\\n #iters = chain.from_iterable(unit_dictionary.values())\\n iters = chain.from_iterable([dics.values() for dics in unit_dictionary.values()])\\n else:\\n iters = unit_dictionary['Character'].values()\\n \\n \\n #print (unit_dictionary['Character'])\\n #if unit_dictionary['Character'] or unit_dictionary['Reaction']:\\n #data_collection.append([sent, unit_dictionary])\\n \\n if show_property and (unit_dictionary['Character'] or unit_dictionary['Reaction']):\\n \\n print (\\\"\\\\n\\\\n------------------------------------\\\")\\n print (file_name)\\n print (\\\" \\\".join([str(t) for t in new_sent]))\\n print (\\\"\\\\n\\\")\\n #print (Para)\\n #print (\\\" \\\".join(new_split))\\n print (\\\"------------------------------------\\\")\\n \\n for T in chain.from_iterable(iters):\\n #for T in t:\\n dictionary_chemical = {'Material':T.target, 'Value':T.value, 'Unit':T.unit, 'Condition':T.condition, 'Property':T.prop,\\n 'Reference':str(file_name)}\\n \\n json_list.append(dictionary_chemical)\\n\\n if show_property:\\n print (\\\"value:\\\", T, \\\"condition:\\\", T.condition, \\\"chemical:\\\", T.target)\\n \\n if isinstance(next_represent_chem, Chemical) or not next_represent_chem:\\n before_represent_chem = next_represent_chem \\n \\n if return_documenTM:\\n return json_list, Q\\n \\n return json_list\",\n \"def pdf_to_txt(full_path):\\n file = open(full_path,'rb')\\n extracted_text = parser.from_buffer(file)\\n return extracted_text['content']\",\n \"def get_corpus(self):\\n rsrcmgr = PDFResourceManager()\\n retstr = StringIO()\\n codec = 'utf-8'\\n laparams = LAParams()\\n device = TextConverter(\\n rsrcmgr, retstr, codec=codec, laparams=laparams)\\n interpreter = PDFPageInterpreter(rsrcmgr, device)\\n maxpages = 0\\n caching = True\\n pagenos = set()\\n pages = PDFPage.get_pages(\\n self.stream_in,\\n pagenos,\\n maxpages=maxpages,\\n password=\\\"\\\",\\n caching=caching,\\n check_extractable=True\\n )\\n for page in pages:\\n interpreter.process_page(page)\\n device.close()\\n text = retstr.getvalue()\\n retstr.close()\\n return text\",\n \"def parse_docs_from_page(self, page_url: str, page_text: str) -> Iterable[Document]:\\n # parse html response\\n url = \\\"https://www.med.navy.mil/directives/Pages/Publications.aspx\\\"\\n base_url = 'https://www.med.navy.mil'\\n parsed_docs = []\\n doc_name_list = []\\n if (page_url.find(\\\"Publications\\\") != -1):\\n doc_type = \\\"NAVMED\\\"\\n elif (page_url.find(\\\"BUMEDNotes\\\") != -1):\\n doc_type = \\\"BUMEDNOTE\\\"\\n elif (page_url.find(\\\"BUMEDInstructions\\\") != -1):\\n doc_type = \\\"BUMEDINST\\\"\\n cac_required = ['CAC', 'PKI certificate required', 'placeholder', 'FOUO']\\n page = requests.get(page_url, verify=CERTIFICATE_DIR + '/cat3.pem')\\n soup = bs4.BeautifulSoup(page.content, 'html.parser')\\n webpart = soup.find(id=\\\"onetidDoclibViewTbl0\\\")\\n items = webpart.find_all('a')\\n meta = webpart.find_all(lambda tag: tag.name == 'td' and tag.get('class') == ['ms-vb2'])\\n meta_list = list(meta)\\n meta_list = [remove_html_tags(str(t)) for t in meta_list]\\n meta_list = [str(t).encode('ascii', 'ignore').decode('ascii') for t in meta_list]\\n meta_list = [x.replace(\\\"\\\\r\\\\n\\\", \\\" \\\") for x in meta_list]\\n if (doc_type == \\\"NAVMED\\\"):\\n n = 3\\n elif (doc_type == \\\"BUMEDINST\\\" or doc_type == \\\"BUMEDNOTE\\\"):\\n n = 4\\n meta_ = [meta_list[i:i + n] for i in range(0, len(meta_list), n)]\\n if (doc_type == \\\"NAVMED\\\"):\\n subject = webpart.find_all(lambda tag: tag.name == 'td' and tag.get('class') == ['ms-vb-title'])\\n name_list = list(subject)\\n name_list = [remove_html_tags(str(t)) for t in name_list]\\n name_list = [str(t).encode('ascii', 'ignore').decode('ascii') for t in name_list]\\n subnum = [str(t[1]).split()[:2] for t in meta_]\\n title_ = [str(t[1]).split()[2:] for t in meta_]\\n title = [' '.join(t) for t in title_]\\n title = [str(t).replace(',', '') for t in title]\\n date = [t[0] for t in meta_]\\n metadata = zip(subnum, title, date, name_list)\\n metadata = [list(a) for a in metadata]\\n elif (doc_type == \\\"BUMEDINST\\\"):\\n subject = webpart.find_all(lambda tag: tag.name == 'td' and tag.get('class') == ['ms-vb-title'])\\n name_list = list(subject)\\n name_list = [remove_html_tags(str(t)) for t in name_list]\\n name_list = [str(t).encode('ascii', 'ignore').decode('ascii') for t in name_list]\\n metadata = list(zip(name_list, meta_))\\n elif (doc_type == \\\"BUMEDNOTE\\\"):\\n metadata = meta_\\n item_list = list(items)\\n pdf_links = [link['href'] for link in item_list if link['href'].endswith(('pdf', 'html'))]\\n pdf_links = [\\\"https://www.med.navy.mil\\\" + a for a in pdf_links]\\n pdf_links = [str(a).replace(' ', '%20') for a in pdf_links]\\n if (doc_type == \\\"BUMEDINST\\\" or doc_type == \\\"BUMEDNOTE\\\"):\\n metadata = [list(ele) for ele in metadata]\\n for i in range(0, len(metadata)):\\n metadata[i].append(pdf_links[i])\\n for item in metadata:\\n if (doc_type == \\\"NAVMED\\\"):\\n pdf_di = DownloadableItem(doc_type='pdf', web_url=item[4])\\n if (str(item[3])[0].isdigit()):\\n doc_name = \\\"NAVMED P-\\\" + str(item[3]).split()[0]\\n doc_num = \\\"P-\\\" + str(item[3]).split()[0]\\n if (doc_name in doc_name_list):\\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\\n doc_name = doc_type + \\\" \\\" + doc_num + \\\"-\\\" + str(number_of_times)\\n doc_num = doc_num + \\\"-\\\" + str(number_of_times)\\n else:\\n doc_name = \\\"NAVMED \\\" + str(item[0][1]) + \\\" \\\" + ' '.join(str(item[3]).split()[:3])\\n doc_num == str(item[0][1]) + \\\" \\\" + ' '.join(str(item[3]).split()[:3])\\n if (doc_name in doc_name_list):\\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\\n doc_name = doc_type + \\\" \\\" + doc_num + \\\"-\\\" + str(number_of_times)\\n doc_num = doc_num + \\\"-\\\" + str(number_of_times)\\n doc_title = str(item[1])\\n publication_date = str(item[2])\\n cac_login_required = False\\n crawler_used = \\\"navy_med_pubs\\\"\\n source_page_url = page_url\\n downloadable_items = [pdf_di]\\n version_hash_fields = {\\n \\\"item_currency\\\": str(item[3]).split('/')[-1], # version metadata found on pdf links\\n \\\"pub_date\\\": publication_date.strip(),\\n \\\"document_title\\\": doc_title.strip(),\\n \\\"document_number\\\": doc_num.strip()\\n }\\n\\n elif (doc_type == \\\"BUMEDINST\\\"):\\n pdf_di = DownloadableItem(doc_type='pdf', web_url=item[2])\\n doc_num = str(item[0]).split()[0]\\n doc_name = doc_type + \\\" \\\" + doc_num\\n doc_title = str(item[1][1])\\n publication_date = str(item[1][0])\\n if (str(item[2]).endswith('html')):\\n cac_login_required = True\\n elif (str(item[2]).endswith('pdf')):\\n cac_login_required = False\\n if (doc_name in doc_name_list):\\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\\n doc_name = doc_type + \\\" \\\" + doc_num + \\\"-\\\" + str(number_of_times)\\n doc_num = doc_num + \\\"-\\\" + str(number_of_times)\\n doc_name_list.append(doc_name)\\n elif (doc_type == \\\"BUMEDNOTE\\\"):\\n pdf_di = DownloadableItem(doc_type='pdf', web_url=item[4])\\n doc_num = str(item[0]).split()[1]\\n doc_name = doc_type + \\\" \\\" + doc_num\\n doc_title = str(item[2])\\n publication_date = str(item[1])\\n cac_login_required = False\\n if (doc_name in doc_name_list):\\n number_of_times = sum(1 for s in doc_name_list if doc_name in s)\\n doc_name = doc_type + \\\" \\\" + doc_num + \\\"-\\\" + str(number_of_times)\\n doc_num = doc_num + \\\"-\\\" + str(number_of_times)\\n doc_name_list.append(doc_name)\\n version_hash_fields = {\\n \\\"doc_name\\\": doc_name, # version metadata found on pdf links\\n \\\"pub_date\\\": publication_date.strip(),\\n \\\"document_title\\\": doc_title.strip(),\\n \\\"document_number\\\": doc_num.strip()\\n }\\n version_hash_raw_data = version_hash_fields\\n doc = Document(\\n doc_name=re.sub(',', '', doc_name.strip()),\\n doc_title=re.sub('\\\\\\\\\\\"', '', doc_title),\\n doc_num=re.sub(',', '', doc_num.strip()),\\n doc_type=re.sub(',', '', doc_type.strip()),\\n publication_date=publication_date,\\n cac_login_required=cac_login_required,\\n crawler_used=\\\"navy_med_pubs\\\",\\n source_page_url=page_url.strip(),\\n version_hash_raw_data=version_hash_fields,\\n downloadable_items=[pdf_di]\\n )\\n parsed_docs.append(doc)\\n return parsed_docs\",\n \"def extract_text(path, pages):\\n out = []\\n with open(path, 'rb') as file:\\n pdftotext_string = pdftotext.PDF(file)\\n\\n for i in pages:\\n out.append(pdftotext_string[i - 1])\\n\\n return out\",\n \"def get_text_from_page(page_content: str) -> str:\\n\\n soup = BeautifulSoup(page_content, 'lxml')\\n\\n for tag in soup.findAll([\\\"script\\\", \\\"style\\\"]):\\n tag.extract()\\n\\n lines = (line.strip() for line in soup.get_text().splitlines())\\n\\n return '\\\\n'.join(line for line in lines if line) # remove empty lines\",\n \"def getCorpus(self, link, p):\\n # Initialize list to hold links to articles\\n article_links = []\\n # Get links to all articles\\n for page in range(p):\\n articles = requests.get(link + \\\"page/\\\" + str(page + 1) + \\\"/\\\").text\\n article_links += re.findall('<a href=\\\"(.+)\\\"><img width', articles)\\n # Instantiate string to hold all text\\n all_text = \\\"\\\"\\n # Get each article\\n for link in article_links:\\n article = requests.get(link).text\\n # Get article text\\n article_text = re.findall('<div class=\\\"entry-content\\\">\\\\n([\\\\s\\\\S]+)' + \\\"\\\\n<p id='tagline'>\\\", article)[0]\\n # Clean article text\\n article_text = re.sub(\\\"<.+?>\\\", \\\"\\\", article_text)\\n article_text = re.sub(\\\"â..\\\", \\\"'\\\", article_text)\\n article_text = re.sub(\\\"Â\\\", \\\"\\\", article_text)\\n article_text = re.sub(\\\"–\\\", \\\"\\\", article_text)\\n article_text = re.sub(\\\"\\\\xa0\\\", \\\"\\\", article_text)\\n # Append article text to string\\n all_text += \\\"\\\\n\\\\n\\\" + article_text\\n return all_text.strip()\",\n \"def extract_paragraph_test(file_name, url_text = None, show_property = False, database = None, extract_all_property=False, \\n return_documenTM = False, cut_off = True, unit_dict = None):\\n if not url_text:\\n url_text = file_name\\n \\n if not database: \\n database = {}\\n \\n if not isinstance(unit_dict, dict):\\n unit_dict = unit_dict_default\\n \\n keyword_dict = make_keyword_dict(unit_dict)\\n \\n Q = DocumentTM(file_name, **database)\\n Q.doc(parser = 'cde_parser')\\n Q.find_strange()\\n chemical_type_dict = {}\\n database = Q.database()\\n \\n data_collection = []\\n json_list = []\\n \\n for Para in Q.Para:\\n new_split, unit = Q.tokenize_test(Para, lemma = False, Strange = True, cut_off=cut_off)\\n \\n if not new_split:\\n continue\\n \\n #print (new_split)\\n \\n before_represent_chem = False\\n \\n for sent in cut_paragraph(new_split):\\n new_sent, unit_dictionary, next_represent_chem = matching_algorithm(sent, database, chemical_type_dict, before_represent_chem)\\n\\n if extract_all_property:\\n #iters = chain.from_iterable(unit_dictionary.values())\\n iters = chain.from_iterable([dics.values() for dics in unit_dictionary.values()])\\n else:\\n iters = unit_dictionary['Character'].values()\\n \\n \\n #print (unit_dictionary['Character'])\\n #if unit_dictionary['Character'] or unit_dictionary['Reaction']:\\n #data_collection.append([sent, unit_dictionary])\\n \\n if show_property and (unit_dictionary['Character'] or unit_dictionary['Reaction']):\\n \\n print (\\\"\\\\n\\\\n------------------------------------\\\")\\n print (file_name)\\n print (\\\" \\\".join([str(t) for t in new_sent]))\\n print (\\\"\\\\n\\\")\\n #print (Para)\\n #print (\\\" \\\".join(new_split))\\n print (\\\"------------------------------------\\\")\\n \\n for T in chain.from_iterable(iters):\\n #for T in t:\\n dictionary_chemical = {'Material':T.target, 'Value':T.value, 'Unit':T.unit, 'Condition':T.condition, 'Property':T.prop,\\n 'Reference':str(file_name)}\\n \\n json_list.append(dictionary_chemical)\\n\\n if show_property:\\n print (\\\"value:\\\", T, \\\"condition:\\\", T.condition, \\\"chemical:\\\", T.target)\\n \\n if isinstance(next_represent_chem, Chemical) or not next_represent_chem:\\n before_represent_chem = next_represent_chem \\n \\n if return_documenTM:\\n return json_list, Q\\n \\n return json_list\",\n \"def get_full_text_from_source(self):\\n extension = self.get_doc_file_extension()\\n\\n if extension in ('txt', ''):\\n # string = unicode(string)\\n return self.doc_file.read().decode(\\\"utf-8\\\")\\n elif extension == 'docx':\\n docx_document = Docx(BytesIO(self.doc_file.read()))\\n return \\\"\\\\n\\\".join(p.text for p in docx_document.paragraphs)\\n elif extension == 'pdf':\\n raise NotImplementedError()\\n else:\\n raise ValueError(\\\"file_format not supported\\\")\",\n \"def page_extract(tree, *, textequiv_level=\\\"region\\\"):\\n\\n # Internally, this is just parsing the Reading Order (if it exists) and\\n # and leaves reading the TextRegions to ExtractedText.from_text_segment().\\n\\n nsmap = {\\\"page\\\": page_namespace(tree)}\\n\\n regions = []\\n reading_order = tree.find(\\\".//page:ReadingOrder\\\", namespaces=nsmap)\\n if reading_order is not None:\\n for group in reading_order.iterfind(\\\"./*\\\", namespaces=nsmap):\\n regions.extend(\\n extract_texts_from_reading_order_group(\\n group, tree, nsmap, textequiv_level\\n )\\n )\\n else:\\n for region in tree.iterfind(\\\".//page:TextRegion\\\", namespaces=nsmap):\\n regions.append(\\n ExtractedText.from_text_segment(\\n region, nsmap, textequiv_level=textequiv_level\\n )\\n )\\n\\n # Filter empty region texts\\n regions = [r for r in regions if r.text != \\\"\\\"]\\n\\n return ExtractedText(None, regions, \\\"\\\\n\\\", None)\",\n \"def extractText(text):\\n soup = BeautifulSoup(text, 'html.parser')\\n for code in soup.find_all('code'):\\n code.decompose()\\n return soup.get_text()\",\n \"def get_text(downgrade_titles=False):\",\n \"def get_text_hook(raw):\\n soup = bs4.BeautifulSoup(quopri.decodestring(raw), features=\\\"lxml\\\")\\n return soup.text\",\n \"def get_text(doc_element: dict, document: dict):\\n response = \\\"\\\"\\n # If a text segment spans several lines, it will\\n # be stored in different text segments.\\n for segment in doc_element.text_anchor.text_segments:\\n start_index = (\\n int(segment.start_index)\\n if segment in doc_element.text_anchor.text_segments\\n else 0\\n )\\n end_index = int(segment.end_index)\\n response += document.text[start_index:end_index]\\n return response\",\n \"def get_chapter_text(location):\\n chapter_output_dictionary = {}\\n chapter_contents_list = []\\n\\n soup = Ripper(location, parser=\\\"html5lib\\\", save_path=save_path).soup\\n text = soup.find(\\\"table\\\", class_=\\\"texttable\\\")\\n\\n for each in text.find_all(\\\"p\\\"):\\n attributes = each.attrs\\n if attributes:\\n if \\\"desc\\\" in attributes[\\\"class\\\"]:\\n pass\\n elif \\\"note\\\" in attributes[\\\"class\\\"]:\\n pass\\n else:\\n new_cont = each.contents\\n chapter_contents_list.extend(new_cont)\\n return join_chapter_text(chapter_contents_list)\",\n \"def get_text(self):\\n text_complet = \\\"\\\"\\n rez_dict = self.__results\\n for i in range(0, len(rez_dict[\\\"text\\\"])):\\n text = rez_dict[\\\"text\\\"][i]\\n conf = int(rez_dict[\\\"conf\\\"][i])\\n if conf > self.__min_confidence:\\n text_complet += text + \\\" \\\"\\n return text_complet\",\n \"def get_article_body(url):\\n headers = {'User-Agent': 'Codeup Data Science'}\\n response = get(url, headers=headers)\\n soup = BeautifulSoup(response.content, \\\"html.parser\\\") \\n return soup.find('div', itemprop='text').text\",\n \"def extract_compounds(text):\\n comp_idx = 0\\n compound = []\\n compound_nps = []\\n tok_idx = 0\\n for idx, tok in enumerate(nlp(text)):\\n if tok.dep_ == \\\"compound\\\":\\n\\n # capture hyphenated compounds\\n children = \\\"\\\".join([c.text for c in tok.children])\\n if \\\"-\\\" in children:\\n compound.append(\\\"\\\".join([children, tok.text]))\\n else:\\n compound.append(tok.text)\\n\\n # remember starting index of first child in compound or word\\n try:\\n tok_idx = [c for c in tok.children][0].idx\\n except IndexError:\\n if len(compound) == 1:\\n tok_idx = tok.idx\\n comp_idx = tok.i\\n\\n # append the last word in a compound phrase\\n if tok.i - comp_idx == 1:\\n compound.append(tok.text)\\n if len(compound) > 1:\\n compound = \\\" \\\".join(compound)\\n compound_nps.append(\\n (compound, tok_idx, tok_idx + len(compound), \\\"COMPOUND\\\")\\n )\\n\\n # reset parameters\\n tok_idx = 0\\n compound = []\\n\\n if len(compound_nps) != 0:\\n return compound_nps[0][0]\\n else:\\n return \\\"\\\"\",\n \"def text(self):\\n return self.content\",\n \"def extractText(html_code):\\n html_tree = html.fromstring(html_code)\\n chapter_list = html_tree.find_class(\\\"chapter\\\")\\n chapter_text = chapter_list[0].text_content()\\n return chapter_text\",\n \"def extractText(postSoup):\\n for tag in postSoup.findAll(True):\\n if tag.name in (\\\"code\\\"):\\n tag.extract()\\n else:\\n tag.hidden=True\\n\\n return postSoup.renderContents()\",\n \"def get_text_only(self, soup):\\n val = soup.string\\n # see if we have a text element\\n if val is None:\\n conts = soup.contents\\n resulttext = ''\\n # not text so continue recursing through the tags\\n for tag in conts:\\n subtext = self.get_text_only(tag)\\n resulttext += subtext + '\\\\n'\\n return resulttext\\n return val.strip()\",\n \"def get_parsed_text(blob):\\n return blob.parse()\",\n \"def _compute_fulltext(self):\\n return ''\",\n \"def alchemy_page_text(url):\\n # import AlchemyAPI\\n try:\\n # Create an AlchemyAPI object.\\n alchemyObj = AlchemyAPI.AlchemyAPI()\\n\\n # Load the API key from disk.\\n alchemyObj.loadAPIKey(\\\"api_key.txt\\\")\\n\\n # Extract page text from a web URL (ignoring navigation links, ads, etc.).\\n result = alchemyObj.URLGetText(url)\\n\\n # Result returned in xml format with node 'text' containing the text\\n text = xml_to_text(result)\\n # remove new lines, tabs, and whitespace\\n text = clean_text(text)\\n\\n return text\\n\\n except TypeError:\\n return \\\"There is a TypeError in alchemy_page_text\\\"\",\n \"def _get_plain_text(self, url, soup, site):\\n print('Get plaint text: ' + url)\\n title = str(soup.find(class_=self._title_tags[site]))\\n content = str(soup.find(class_=self._content_tags[site]))\\n # h = html2text.HTML2Text() # uncomment this segment of code\\n # h.ignore_links = True # if you want to get plain text\\n # h.ignore_images = True\\n # title = h.handle(title)\\n # content = h.handle(content)\\n if title == None or content == None:\\n print('Different website structure: ' + url)\\n return ''\\n return self._clean(title + content, no_punc=True) # with symbols\\n # return title + content # without symbols\",\n \"def get_full_text(self, item):\\n photoset_content = self.db.plugin_photoset_content(\\n item_id=item.unique_id)\\n output = self.response.render(\\n 'plugin_photoset/full_text.txt',\\n dict(photoset_content=photoset_content, item=item))\\n return unicode(output.decode('utf-8'))\",\n \"def get_wiki_content(self):\\n url = \\\"https://fr.wikipedia.org/w/api.php?action=query&prop=extracts&exsentences=4&explaintext=&pageids={}&format=json\\\".format(self.page_id)\\n self.page = str(self.page_id)\\n self.response = requests.get(url)\\n self.data = self.response.json()\\n self.wiki_data = (self.data['query']['pages'][self.page]['extract'])\\n return (self.wiki_data)\",\n \"def _get_text(raw_html):\\n bs = BeautifulSoup(raw_html)\\n text_nodes = bs.find_all(_is_text_tag)\\n text_elements = [_get_child_text(node) for node in text_nodes]\\n return ' '.join(chain(*chain(*text_elements)))\",\n \"def get_text(api, obj_type):\\n\\n if obj_type == \\\"comments\\\":\\n search_function = api.search_comments\\n filters = [\\\"author\\\", \\\"body\\\"]\\n check_attr = \\\"body\\\"\\n else: # type == \\\"submissions\\\"\\n search_function = api.search_submissions\\n filters = [\\\"author\\\", \\\"title\\\", \\\"selftext\\\"]\\n check_attr = \\\"selftext\\\"\\n\\n text = list(\\n search_function(\\n after=YESTERDAY, before=TODAY, subreddit=\\\"wallstreetbets\\\", filter=filters\\n )\\n )\\n\\n # prevent errors caused by removed/deleted posts\\n text[:] = [\\n x for x in text if getattr(x, check_attr) not in (\\\"[removed]\\\", \\\"[deleted]\\\")\\n ]\\n\\n return text\",\n \"def text_getter(target_url):\\n response = requests.get(target_url)\\n # response.encoding = \\\"utf-8\\\"\\n decoded_text = response.text\\n\\n return book_title(decoded_text), get_text_tokens(decoded_text)\",\n \"def text(filename, level=\\\"region\\\", index=\\\"0\\\"):\\n\\n try:\\n tree = ET.parse(filename)\\n except XMLSyntaxError:\\n with open(filename, 'r') as f:\\n return f.read()\\n try:\\n return page_text(tree, level=level, index=index)\\n except ValueError:\\n return alto_text(tree)\",\n \"def get(self, docid):\\n file = os.path.join(self.dirname, docid)\\n with open(file,'r',encoding='utf-8') as f:\\n text = f.read()\\n return text\",\n \"def get_corpus_text(nr_files=199):\\n fileids = nltk.corpus.treebank_raw.fileids()[:nr_files]\\n corpus_text = nltk.corpus.treebank_raw.raw(fileids)\\n corpus_text = corpus_text.replace(\\\".START\\\", \\\"\\\")\\n return corpus_text\",\n \"def get_abs_text(record):\\n\\n result = []\\n\\n try:\\n for item in record['MedlineCitation']['Article']['Abstract']['AbstractText']:\\n result.append(item)\\n except KeyError:\\n pass\\n\\n if len(result) == 0:\\n return '*Abstract Unavailable*'\\n else:\\n return ' '.join(result)\",\n \"def get_bibtex(self):\\n url=\\\"http://www.biomedcentral.com/download/citation\\\"\\n parameters={'citation':'on', \\n 'result-selection':'THIS_PAGE',\\n 'suplements': 'false',\\n 'citationType':'BIBTEX_WITH_ABSTRACT',\\n 'articleIdThisPage':self.article_ids\\n }\\n data=urllib.urlencode(parameters)\\n self.bibtex=urllib2.urlopen(url,data)\",\n \"def getText(self):\\n return(' '.join(map(lambda x:x.text,self.getNested())))\",\n \"def __get_page(self):\\n params = {'query': self.query,\\n 'corpname': self.subcorpus,\\n 'start': self.__pagenum}\\n s = get('http://korpus.juls.savba.sk:8080/manatee.ks/do_query', params=params)\\n return s.text\",\n \"def get_txt(url):\\n soup = make_soup(url)\\n\\n # remove scripts and styling\\n for script in soup([\\\"script\\\", \\\"style\\\"]):\\n script.extract() # rip it out\\n text = soup.get_text()\\n\\n # clean data\\n lines = (line.strip() for line in text.splitlines())\\n chunks = (phrase.strip() for line in lines for phrase in line.split(\\\" \\\"))\\n text = '\\\\n'.join(chunk for chunk in chunks if chunk)\\n\\n return text\",\n \"def parse_text(self, page):\\n text = page.find(self.tag_prefix + self.revision_tag).find(self.tag_prefix + self.text_tag).text\\n title = page.find(self.tag_prefix + self.title_tag).text\\n categories = []\\n #\\n text = self.parse_archivo(text)\\n text = self.parse_foto(text)\\n text = self.parse_by_line(text)\\n text = self.parse_link(text)\\n text = self.parse_url(text)\\n text = self.parse_fecha(text)\\n text = self.parse_bracketed_word(text)\\n #\\n if text:\\n categories = re.findall(self.category_finder_regex, text)\\n #\\n text = self.parse_category(text)\\n text = self.parse_other_language(text)\\n text = self.parse_table_regex(text)\\n text = self.parse_ver_fuente(text)\\n text = self.remove_extra_text(text)\\n text = self.remove_extra_characters(text)\\n\\n categorias = []\\n for cat in categories:\\n categorias.append(cat[6])\\n\\n if text:\\n if 'REDIRECT' in text or 'redirect' in text:\\n return None\\n\\n return Article(title=title, content=text, categories=categorias)\",\n \"def get_book(url):\\n text = requests.get(url).text\\n time.sleep(5) # Delay for 5 seconds\\n\\n # Transform \\\\r\\\\n with \\\\n newline\\n subtext = re.sub(r'\\\\r\\\\n', '\\\\n', text) \\n\\n # Extract content from START to END\\n pat = '\\\\*\\\\*\\\\* START OF THIS PROJECT GUTENBERG EBOOK .* \\\\*\\\\*\\\\*([\\\\S\\\\s]*)\\\\*\\\\*\\\\* END OF THIS PROJECT GUTENBERG EBOOK'\\n content = re.search(pat, subtext).group(1)\\n return content\",\n \"def full_text(self):\\n\\n if self._full_text == []:\\n for sentence in self.title():\\n self._full_text.append(sentence)\\n for sentence in self.abstract():\\n self._full_text.append(sentence)\\n for sentence in self.body():\\n self._full_text.append(sentence)\\n\\n return self._full_text\",\n \"def get_docx_text(path):\\n document = zipfile.ZipFile(path)\\n xml_content = document.read('word/document.xml')\\n document.close()\\n tree = XML(xml_content)\\n \\n paragraphs = []\\n for paragraph in tree.getiterator(PARA):\\n texts = [node.text\\n for node in paragraph.getiterator(TEXT)\\n if node.text]\\n if texts:\\n paragraphs.append(''.join(texts))\\n \\n return '\\\\n\\\\n'.join(paragraphs)\",\n \"def get_contenu(self):\\n return self.objets\",\n \"def parsepdf(intext): # type: (str) -> str\\n\\n pdfbinarydata = base64.b64decode(intext.strip())\\n pdfFileObj = io.BytesIO()\\n pdfFileObj.write(pdfbinarydata)\\n pdfReader = PyPDF2.PdfFileReader(pdfFileObj)\\n extractedText = ''\\n for i in range(0, pdfReader.numPages):\\n pageObj = pdfReader.getPage(i)\\n extractedText = extractedText + pageObj.extractText()\\n\\n return extractedText.strip()\",\n \"def scrape_description(main_soup):\\n rich_text = main_soup.find('div', {'class': 'rich-text'})\\n description = rich_text.find('p').text\\n\\n return description\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def _get_text(self, remove_newlines=True):\\n if not self.text:\\n url = self.url\\n try:\\n self.log.debug(\\\"Try to get content from page {}\\\".format(url))\\n r = requests.get(url)\\n except requests.exceptions.RequestException as e:\\n self.log.warn(\\\"Unable to get page content of the url: {url}. \\\"\\n \\\"The reason: {exc!r}\\\".format(url=url, exc=e))\\n raise ParsingError(e.strerror)\\n\\n ud = UnicodeDammit(r.content, is_html=True)\\n\\n enc = ud.original_encoding.lower()\\n declared_enc = ud.declared_html_encoding\\n if declared_enc:\\n declared_enc = declared_enc.lower()\\n # possible misregocnition of an encoding\\n if (declared_enc and enc != declared_enc):\\n detect_dict = chardet.detect(r.content)\\n det_conf = detect_dict[\\\"confidence\\\"]\\n det_enc = detect_dict[\\\"encoding\\\"].lower()\\n if enc == det_enc and det_conf < THRESHOLD_OF_CHARDETECT:\\n enc = declared_enc\\n # if page contains any characters that differ from the main\\n # encoding we will ignore them\\n content = r.content.decode(enc, \\\"ignore\\\").encode(enc)\\n htmlparser = etree.HTMLParser(encoding=enc)\\n root = etree.HTML(content, parser=htmlparser)\\n etree.strip_elements(root, html.etree.Comment, \\\"script\\\", \\\"style\\\")\\n text = html.tostring(root, method=\\\"text\\\", encoding=\\\"unicode\\\")\\n\\n if remove_newlines:\\n self.log.debug(str(type(text)))\\n text = re.sub('\\\\s+', ' ', text)\\n self.text = text\\n\\n return self.text\",\n \"def test_text_resource(self):\\n Repository = CTSCapitainsLocalResolver([\\\"./tests/testing_data/farsiLit\\\"])\\n text, metadata = Repository.__getText__(\\\"urn:cts:farsiLit:hafez.divan.perseus-eng1\\\")\\n self.assertEqual(\\n len(text.citation), 4,\\n \\\"Object has a citation property of length 4\\\"\\n )\\n self.assertEqual(\\n text.getTextualNode(Reference(\\\"1.1.1.1\\\")).export(output=Mimetypes.PLAINTEXT),\\n \\\"Ho ! Saki, pass around and offer the bowl (of love for God) : ### \\\",\\n \\\"It should be possible to retrieve text\\\"\\n )\",\n \"def get_text(bucket, key):\\n s3 = boto3.resource(\\\"s3\\\")\\n\\n ocr_obj = s3.Object(bucket, key)\\n response = ocr_obj.get()\\n data = response[\\\"Body\\\"].read()\\n\\n return data\",\n \"def _generateCurrentLineText(self, obj, **args ):\\n result = self._generateSubstring(obj, **args)\\n if result:\\n return result\\n\\n [text, caretOffset, startOffset] = self._script.getTextLineAtCaret(obj)\\n if text and not self._script.EMBEDDED_OBJECT_CHARACTER in text:\\n return [text]\\n\\n return []\",\n \"def extract_text(fname):\\n\\n laparams = pdfminer.layout.LAParams()\\n for param in ('all_texts', 'detect_vertical', 'word_margin', 'char_margin', 'line_margin', 'boxes_flow'):\\n paramv = locals().get(param, None)\\n if paramv is not None:\\n setattr(laparams, param, paramv)\\n\\n # send output to a string stream\\n outfp = io.StringIO()\\n\\n with open(fname, 'rb') as fp:\\n pdfminer.high_level.extract_text_to_fp(fp, outfp=outfp, codec='utf-8',\\n laparams=laparams, pages=0)\\n\\n return outfp.getvalue()\",\n \"def get_10k_text(url):\\n\\n\\trawdoc = BeautifulSoup(requests.get(url).content, 'html.parser')\\n\\n\\theaders = []\\n\\ttext = []\\n\\tstart_recording = False # record headers between business & risk factors section\\n\\tfor data in rawdoc.html.body:\\n\\t\\ttry:\\n\\t\\t\\tattributes = convert_attr_to_dict(data.find('font')['style'])\\n\\t\\t\\tis_header = attributes.get('font-weight') == 'bold' # recognize bold text as header\\n\\t\\t\\tif is_header:\\n\\t\\t\\t\\tif 'business' in data.text.lower(): # start of relevant section\\n\\t\\t\\t\\t\\tstart_recording = True\\n\\t\\t\\t\\tif 'risk factors' in data.text.lower(): # end of relevant section\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\tif start_recording:\\n\\t\\t\\t\\t\\theaders.append(data.text)\\n\\t\\t\\telse: # assume text is paragraph section\\n\\t\\t\\t\\tif start_recording: # record text\\n\\t\\t\\t\\t\\ttext.append(data.text)\\n\\t\\texcept: # cheeky too broad catch all -> we are going to filter out poorly scraped data later\\n\\t\\t\\tcontinue\\n\\n\\treturn headers, text\",\n \"def get_article_body(url):\\n G.go(url)\\n text = G.doc.select('////div[@class=\\\"StandardArticleBody_body\\\"]').text()\\n return text\",\n \"def parse_content(self, api):\\n abstract = ''\\n for tag in api.next_siblings:\\n if tag.name == 'hr' or tag.name == 'blockquote':\\n break\\n elif tag.name == 'div':\\n continue\\n else:\\n abstract+=(str(tag))\\n return abstract.strip('\\\\n')\",\n \"def get_text(self):\\n return self.output.getvalue()\",\n \"def getdoc(object):\\r\\n try:\\r\\n doc = object.__doc__\\r\\n except AttributeError:\\r\\n return None\\r\\n if not isinstance(doc, types.StringTypes):\\r\\n return None\\r\\n return cleandoc(doc)\",\n \"def raw_text(self):\\n return self._raw_text\",\n \"def parse(text):\\n md = markdown.Markdown(['codehilite', 'tables', ])\\n\\n for iref in re.findall(img_ref_re, text):\\n img_id = iref[7]\\n try:\\n image = FlatPageImage.objects.get(pk=int(img_id))\\n md.references[img_id] = (image.image_path.url, '')\\n except ObjectDoesNotExist:\\n pass\\n\\n for lref in re.findall(reference_re, text):\\n doc_name = lref[7]\\n try:\\n doc = File.objects.get(name=doc_name)\\n md.references[doc_name]= (doc.url, doc.name)\\n except ObjectDoesNotExist:\\n pass\\n\\n return md.convert(text)\",\n \"def fetch_doc_text_body(self, document_level, find_query_mixin={}):\\n find_query = {'subreddit': self.subreddit, 'postwise.text':{'$exists':True}}\\n find_query.update(find_query_mixin)\\n\\n if document_level != 'postwise':\\n raise NotImplementedError('document_level:%s' % document_level)\\n\\n print 'found %i matching the query for text body docs' % self.posts_read.find(find_query).count()\\n\\n for doc in self.posts_read.find(find_query):\\n yield doc['_id'], doc[document_level]['text']\",\n \"def 取所有项目文本(self): # real signature unknown; restored from __doc__\\n return self.GetStrings()\",\n \"def extract_raw_text(soup, url):\\n \\n title_class = \\\"nom-notice\\\"\\n title = soup.find(class_=title_class)\\n raw_infos = {}\\n raw_infos['name'] = title.contents[0].replace(u'\\\\xa0', ' ')\\n \\n notice = soup.find(class_=\\\"notice\\\")\\n \\n summary = notice.find(class_=\\\"chapo\\\")\\n if summary is not None:\\n first_para = summary.find_all('p', recursive=False)[-1]\\n first_para.tag = 'div'\\n first_para['class'] = 'summary'\\n raw_infos['summary'] = unicode(first_para)\\n \\n else:\\n raw_infos['summary'] = unicode('')\\n\\n article = notice.find(class_='texte')\\n if article is not None:\\n article['class'] = 'article'\\n raw_infos['article'] = unicode(article)\\n \\n sources = notice.find(class_='sources')\\n raw_infos['sources'] = unicode(sources)\\n \\n works = notice.find(class_='oeuvres')\\n if works is not None:\\n works['class'] = 'works'\\n raw_infos['works'] = unicode(works)\\n \\n # In function that writes, encode everything to bytes! .encode('utf-8')\\n return raw_infos\",\n \"def get_text(self):\\n return self.text\",\n \"def contents(self, n, m):\\n str = \\\"\\\"\\n subset = self.getlines(n, m)\\n for line in subset:\\n str = str + line + \\\"\\\\n\\\"\\n return str.rstrip(\\\"\\\\n\\\")\",\n \"def get_texts(json_object):\\n texts = list()\\n texts.append(json_object.get(FIELD_NAMES_CITIES['text_field']))\\n return texts\",\n \"def extract_documents():\\n client = MongoClient()\\n conn = client.data\\n coll = conn.germanwings\\n\\n query = {'text': {'$exists': 1}, 'exc': {'$exists': 0}}\\n selection = {'text': 1, 'short_url': 1}\\n for i, doc in enumerate(coll.find(query, selection)):\\n short_url, text = tuple(doc[x] for x in (\\\"short_url\\\", \\\"text\\\"))\\n print(\\\"Extracting {0} {1}\\\".format(i, short_url), file=stderr)\\n filename = os.path.join(RAW_DIR, short_url)\\n with open(filename, \\\"w\\\") as f:\\n ascii = text.encode('ascii', 'ignore')\\n f.write(ascii)\",\n \"def get_text(self):\\n\\n return self.output['text']\",\n \"def text_of(soup):\\n return ''.join([str(x) for x in soup.findAll(text=True)])\",\n \"def text():\\n return {\\n \\\"@context\\\": \\\"http://www.w3.org/ns/anno.jsonld\\\",\\n \\\"type\\\": \\\"Annotation\\\",\\n \\\"body\\\": {\\n \\\"creator\\\": \\\"user\\\",\\n \\\"type\\\": \\\"TextualBody\\\",\\n \\\"value\\\": \\\"string\\\"\\n },\\n \\\"generator\\\": {\\n \\\"homepage\\\": \\\"http://mnemosyne.ml\\\",\\n \\\"id\\\": \\\"string\\\",\\n \\\"name\\\": \\\"Mnemosyne\\\",\\n \\\"type\\\": \\\"Mnemosyne\\\"\\n },\\n \\\"target\\\": {\\n \\\"id\\\": \\\"string\\\",\\n \\\"type\\\": \\\"TextQuoteSelector\\\",\\n \\\"exact\\\": \\\"string\\\",\\n \\\"format\\\": \\\"string\\\",\\n \\\"source\\\": \\\"string\\\",\\n \\\"prefix\\\": 0,\\n \\\"suffix\\\": 0,\\n \\\"refinedBy\\\": {\\n \\\"type\\\": \\\"TextPositionSelector\\\",\\n \\\"start\\\": \\\"/div[2]\\\",\\n \\\"end\\\": \\\"/div[2]\\\"\\n },\\n },\\n }\",\n \"def getText(self):\",\n \"def pages_split(text: str, document: dict, uri, gcs_output_uri : str, gcs_output_uri_prefix :str ):\\n for i, entity in enumerate(document.entities):\\n confidence = entity.confidence\\n text_entity = ''\\n for segment in entity.text_anchor.text_segments:\\n start = segment.start_index\\n end = segment.end_index\\n text_entity += text[start:end]\\n \\n pages = [p.page for p in entity.page_anchor.page_refs]\\n print(f\\\"*** Entity number: {i}, Split Confidence: {confidence} ***\\\")\\n print(f\\\"*** Pages numbers: {[p for p in pages]} ***\\\\nText snippet: {text_entity[:100]}\\\")\\n print(\\\"type: \\\" + entity.type_)\\n start_page= pages[0]\\n end_page = pages[len(pages)-1]\\n print(start_page)\\n print(end_page)\\n \\n storage_client = storage.Client()\\n bucket = storage_client.get_bucket(uri.hostname)\\n blob = bucket.get_blob(uri.path[1:])\\n\\n inputpdf= PdfFileReader(\\n io.BytesIO(blob.download_as_bytes())\\n ,strict=False) \\n \\n split_pdf(inputpdf, start_page, end_page, uri,gcs_output_uri, gcs_output_uri_prefix + \\\"/\\\" + entity.type_)\",\n \"def extract(content):\\n parser = MyHTMLParser()\\n parser.textBody = []\\n parser.feed(content)\\n textBody = parser.textBody\\n textBody = \\\" \\\".join(textBody)\\n textBody = textBody.replace('\\\\xa0', \\\" \\\")\\n return textBody.strip()\",\n \"def extract_text_from_pdf(file):\\n\\n return RegexpTokenizer(r'\\\\w+').tokenize(parser.from_file(file)['content'])\",\n \"def extract(key, path_pdf):\\n\\n path_tmp_pdf = extract_first_page(path_pdf)\\n\\n # extract all text from first page\\n raw_text = extract_text(path_tmp_pdf)\\n\\n # extract abstract from whole page and replace hyphens etc.\\n abstract = extract_abstract(raw_text)\\n\\n # something went wrong when abstract is longer than 1500 chars\\n if len(abstract) > MAX_LEN:\\n print('{}: Abstract is too long.'.format(path_pdf))\\n\\n if not abstract:\\n print('{}: Could not extract abstract.'.format(path_pdf))\\n\\n # clean up temp file\\n os.unlink(path_tmp_pdf)\\n\\n # TODO: Fix this return object\\n out = {'@key': key, 'abstract': abstract}\\n\\n return out\",\n \"def pdf_to_text(file_object):\\n pdfData = file_object.read()\\n tf = tempfile.NamedTemporaryFile()\\n tf.write(pdfData)\\n tf.seek(0)\\n outputTf = tempfile.NamedTemporaryFile()\\n\\n if len(pdfData) > 0:\\n out, err = subprocess.Popen([\\\"pdftotext\\\", \\\"-layout\\\", tf.name, outputTf.name ]).communicate()\\n return outputTf.read()\\n else:\\n return None\",\n \"def full_text(self) -> str:\\n return self._full_text\",\n \"def format_ocr_text(self, page):\\n \\n #read out of the text file that tesseract made\\n ocr_text = open(self.ocr_text, 'r')\\n \\n # write into this file\\n djvu_text = open( self.djvu_text, 'w' )\\n \\n text = \\\"(page 0 0 1 1\\\\n\\\"\\n \\n self.out_text.write('\\\\n## Page %d ###\\\\n\\\\n' % page )\\n \\n for line in ocr_text:\\n \\n #write to the human readable file\\n self.out_text.write(line)\\n \\n # add each line of text\\n # escaping \\\" to \\\\\\\" as we go\\n text += '(line 0 0 1 1 \\\"%s\\\")\\\\n' % line.replace('\\\"', r'\\\\\\\"').strip()\\n \\n text += \\\")\\\\n\\\"\\n \\n djvu_text.write( text )\\n \\n ocr_text.close()\\n djvu_text.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6273365","0.62023115","0.6014343","0.59526193","0.5892059","0.5881646","0.5855388","0.58526736","0.58320683","0.58169097","0.5788491","0.5753858","0.57474256","0.5684555","0.56561995","0.5646933","0.5620174","0.5598048","0.55893654","0.5587107","0.5583094","0.55735785","0.55732536","0.5564463","0.54627925","0.5457531","0.5455523","0.54443777","0.5438583","0.54050857","0.53995556","0.5398667","0.5369934","0.53679574","0.5364644","0.53594524","0.53437877","0.53437245","0.5340347","0.5338974","0.53355634","0.5325625","0.5317854","0.5308102","0.5301067","0.529916","0.5288472","0.52790505","0.5275838","0.52686936","0.52547324","0.52546436","0.5250097","0.52368","0.52336705","0.5205088","0.52030504","0.52020764","0.520095","0.51879185","0.51695","0.5163308","0.5154045","0.51536036","0.51348764","0.5129008","0.5129008","0.5129008","0.5129008","0.5129008","0.5121912","0.5120236","0.5119425","0.5113338","0.51103896","0.51062405","0.51026076","0.51009804","0.5099939","0.50961894","0.50939715","0.50918233","0.50889134","0.5081424","0.5079024","0.5066725","0.5066142","0.5059455","0.5056376","0.50522274","0.5051378","0.5050889","0.5038616","0.5037642","0.50365794","0.5035428","0.50349927","0.50313604","0.5026366","0.5026289"],"string":"[\n \"0.6273365\",\n \"0.62023115\",\n \"0.6014343\",\n \"0.59526193\",\n \"0.5892059\",\n \"0.5881646\",\n \"0.5855388\",\n \"0.58526736\",\n \"0.58320683\",\n \"0.58169097\",\n \"0.5788491\",\n \"0.5753858\",\n \"0.57474256\",\n \"0.5684555\",\n \"0.56561995\",\n \"0.5646933\",\n \"0.5620174\",\n \"0.5598048\",\n \"0.55893654\",\n \"0.5587107\",\n \"0.5583094\",\n \"0.55735785\",\n \"0.55732536\",\n \"0.5564463\",\n \"0.54627925\",\n \"0.5457531\",\n \"0.5455523\",\n \"0.54443777\",\n \"0.5438583\",\n \"0.54050857\",\n \"0.53995556\",\n \"0.5398667\",\n \"0.5369934\",\n \"0.53679574\",\n \"0.5364644\",\n \"0.53594524\",\n \"0.53437877\",\n \"0.53437245\",\n \"0.5340347\",\n \"0.5338974\",\n \"0.53355634\",\n \"0.5325625\",\n \"0.5317854\",\n \"0.5308102\",\n \"0.5301067\",\n \"0.529916\",\n \"0.5288472\",\n \"0.52790505\",\n \"0.5275838\",\n \"0.52686936\",\n \"0.52547324\",\n \"0.52546436\",\n \"0.5250097\",\n \"0.52368\",\n \"0.52336705\",\n \"0.5205088\",\n \"0.52030504\",\n \"0.52020764\",\n \"0.520095\",\n \"0.51879185\",\n \"0.51695\",\n \"0.5163308\",\n \"0.5154045\",\n \"0.51536036\",\n \"0.51348764\",\n \"0.5129008\",\n \"0.5129008\",\n \"0.5129008\",\n \"0.5129008\",\n \"0.5129008\",\n \"0.5121912\",\n \"0.5120236\",\n \"0.5119425\",\n \"0.5113338\",\n \"0.51103896\",\n \"0.51062405\",\n \"0.51026076\",\n \"0.51009804\",\n \"0.5099939\",\n \"0.50961894\",\n \"0.50939715\",\n \"0.50918233\",\n \"0.50889134\",\n \"0.5081424\",\n \"0.5079024\",\n \"0.5066725\",\n \"0.5066142\",\n \"0.5059455\",\n \"0.5056376\",\n \"0.50522274\",\n \"0.5051378\",\n \"0.5050889\",\n \"0.5038616\",\n \"0.5037642\",\n \"0.50365794\",\n \"0.5035428\",\n \"0.50349927\",\n \"0.50313604\",\n \"0.5026366\",\n \"0.5026289\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7681376"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90598,"cells":{"query":{"kind":"string","value":"Get the list of chromosome names from a fasta file"},"document":{"kind":"string","value":"def _chrom_names(fasta_file):\n from pysam import FastaFile\n with FastaFile(fasta_file) as fa:\n chroms = list(fa.references)\n return chroms"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def readFasta(self, fastaFile):\t\n\t\tname, seq = None, []\n\t\tfor line in fastaFile:\n\t\t\tline = line.rstrip()\n\t\t\tif (line.startswith(\">\")):\n\t\t\t\tif name: yield (name, ''.join(seq))\n\t\t\t\tname, seq = line, []\n\t\t\telse:\n\t\t\t\tseq.append(line)\n\t\tif name: yield (name, ''.join(seq))","def fasta_seqs(file_name):\n list = []\n with open('../test_files/' + file_name, 'r') as infile:\n text = infile.read()\n seqs = text.split('>')\n for seq in seqs:\n try:\n x = seq.split('\\n', 1)\n # sequence will be stored in x[1], and i am removing nextline '\\n' characters that comes with it.\n list.append(x[1].replace('\\n', ''))\n except:\n pass\n return list","def full_chromosomes(reader):\n for line in reader.header.get_lines(\"contig\"):\n if line.id in CHROMS:\n name = line.id\n length = line.length or 1_000_000_000\n yield \"{}:{}-{}\".format(name, 1, length)","def read_fasta_file(path):\n with open(path) as data_file:\n output = {}\n sequence_name = None\n for line in data_file.readlines():\n if line.startswith(\">\"):\n sequence_name = line[1:].strip()\n else:\n output.setdefault(sequence_name, \"\")\n line = \"\".join(re.findall(\"[acgtACGT]+\", line))\n\n output[sequence_name]+=line.upper()\n return output","def load_fasta(filepath):\n chromosomes = {}\n\n seqs = SeqIO.parse(filepath, format='fasta', \n alphabet=IUPAC.ambiguous_dna)\n\n # iterate over seqs and add to chromosome dictionary\n for seq in seqs:\n # determine chromosome number\n match = re.search('\\d+', seq.name)\n chromosome_number = int(match.group())\n\n chromosomes[chromosome_number] = seq\n\n return chromosomes","def parse_fasta_use_bio(file_name):\n pro_id_list = []\n for seq_record in SeqIO.parse(file_name, \"fasta\"):\n tmp_list = seq_record.id.strip('\\n').split('|')\n pro_id_list.append(tmp_list[1])\n # break\n\n return pro_id_list","def readFastaFile(filename):\n if os.path.exists(filename)==False:return {}\n sequences={}\n fhr=open(filename,\"r\")\n for line in fhr:\n if line[0]==\">\":\n sequences[line.strip()[1:].split()[0]]=fhr.readline().strip()\n fhr.close()\n return sequences","def fasta_headers(file_name):\n list = []\n with open('../test_files/' + file_name, 'r') as infile:\n text = infile.read()\n seqs = text.split('>')\n for seq in seqs:\n try:\n x = seq.split('\\n', 1)\n if x[0] != '':\n #x[0] contains only headers\n list.append(x[0])\n except:\n pass\n return list","def get_genes(infile,outfile):\n gene_list = []\n with open(infile) as gene:\n tag = False\n for line in gene:\n if line.startswith('name'):\n tag = True\n continue\n if tag:\n items = line.split()\n if len(items) > 0:\n gene_list.append(items[0])\n gene_list = gene_list[1:-7]\n with open(outfile, 'w') as outfile:\n for i in gene_list:\n outfile.write(i+'\\n')\n return True","def extract_sequence(chrom,start,end,fasta_file):\n # extract the sequence from this region with pybedtools\n my_peak = '\\t'.join([chrom,str(start),str(end)])\n bedtool_peak = pybedtools.BedTool(my_peak, from_string=True)\n fasta = pybedtools.example_filename(fasta_file)\n a = a.sequence(fi=fasta)\n #print(open(a.seqfn).read()) ","def load_data() -> list:\n # trans_dict is used for changing the given names into standardized names.\n trans_dict = {\"chr1\": \"1\", \"chr2\": \"2\", \"chr3\": \"3\", \"chr4\": \"4\", \"chr5\": \"5\", \"chr6\": \"6\", \"chr7\": \"7\",\n \"chr8\": \"8\", \"chr9\": \"9\", \"chr10\": \"10\", \"chr11\": \"11\", \"chr12\": \"12\", \"chr13\": \"13\", \"chr14\": \"14\",\n \"chr15\": \"15\", \"chr16\": \"16\", \"chr17\": \"17\", \"chr18\": \"18\", \"chr19\": \"19\", \"chrx\": \"x\", \"chry\": \"y\"}\n # This try statement catches user error.\n try:\n with open(sys.argv[1]) as bed_file, open(sys.argv[2]) as fasta_file:\n fasta_records = []\n # Opens the bed file and splits into lists\n bed_file = list(csv.reader(bed_file, delimiter='\\t'))\n # Changes the names of the chromosomes in bed file, does some light rearranging and formatting.\n bed_file = [[trans_dict[record[0].lower()], record[1], record[3][0:record[3].index(\n '\\'')]] for record in bed_file]\n # Sorts the desired indices by chromosome, then by index in the chromosome.\n bed_file = sorted(bed_file, key=itemgetter(1))\n bed_file = sorted(bed_file, key=itemgetter(0))\n # This stores the desired indexes for each chromosome.\n indexable_bed_records = {'1': [], '2': [], '3': [], '4': [], '5': [], '6': [], '7': [], '8': [], '9': [],\n '10': [], '11': [], '12': [], '13': [], '14': [], '15': [], '16': [], '17': [],\n '18': [], '19': [], 'x': [], 'y': []}\n # Put each desired index into it's appropriate chromosome list.\n for record in bed_file:\n indexable_bed_records[record[0]].append([record[2], record[1]])\n # Loops over fasta records in the supplied fasta file\n for fasta_record in fasta_iter(fasta_file):\n # grabs the chromosome id\n chrom_id = fasta_record[\"header\"][:fasta_record[\"header\"].index(' ')].lower()\n # Some chromosomes are not desired, skip them.\n if chrom_id not in indexable_bed_records.keys():\n continue\n # Grabs the indexes we want to extract from the chromosome.\n indexes = indexable_bed_records[chrom_id]\n # Grabs each index+/-10 from the sequence\n for index in indexes:\n fasta_records.append([index[0], fasta_record[\"seq\"][int(index[1]) - 10:int(index[1]) + 10]])\n # Returns a list of lists of format [5'/3',splice site sequence]\n return fasta_records\n # Catches user error.\n except (FileNotFoundError, IndexError) as e:\n if type(e) is IndexError:\n sys.stderr.write(\"Usage: {} bed_file fasta_file\\n\\tbed_file: The appropriate bed file. \\n\\t\"\n \"fasta_file: The appropriate fasta file.\\n\".format(os.path.basename(__file__)))\n elif type(e) is FileNotFoundError:\n sys.stderr.write(\"One of the specified files was not found.\\n\")\n sys.exit(1)","def gene_names(filepath, complete=True):\n if complete:\n df_ucsc = pd.read_csv(filepath, sep='\\t', header=None)\n df_ucsc.columns = (\n ['number', 'gene_name', 'locus_link',\n 'ref_seq_num', 'genbank', 'uniprot', 'taxon']\n )\n gene_ucsc = set(\n [str(name).lower() for name in df_ucsc[\"gene_name\"]\n if len(str(name)) >1]\n )\n return gene_ucsc\n else:\n df_syn = pd.read_csv(filepath, sep='\\t', header=None)\n df_syn.columns = ['number', 'gene_name']\n gene_ucsc = set(\n [str(name).lower() for name in df_syn[\"gene_name\"]\n if len(str(name)) >1]\n )\n return gene_ucsc","def fetch_as_fasta(chrom,start,end,gindex,fname):\n \n # Print the sequence in fasta format.\n header = '>%s:%s-%s' % (chrom, start, end)\n fname.write('%s\\n%s\\n' % (header, gindex[chrom][start:end]))","def _chrom_sizes(fasta_file):\n from pysam import FastaFile\n fa = FastaFile(fasta_file)\n chrom_lens = OrderedDict([(name, l) for name, l in zip(fa.references, fa.lengths)])\n if len(chrom_lens) == 0:\n raise ValueError(f\"no chromosomes found in fasta file: {fasta_file}. \"\n \"Make sure the file path is correct and that the fasta index \"\n \"file {fasta_file}.fai is up to date\")\n fa.close()\n return chrom_lens","def read_file(infile_name):\n chr_list = [0]*13 \n for i in range(len(chr_list)):\n chr_list[i] = [] \n infile = open(infile_name)\n for line in infile:\n if line.startswith('SL2.40'):\n chr = int(line.strip().split()[0][-2:])\n loci = int(line.strip().split()[1])\n chr_list[chr] += [loci]\n else:\n pass\n infile.close()\n return chr_list","def fasta_reader(inp):\n #inp is hard coded as \"Sequence1/2.fasta in this script\".\n with open(inp) as in_file: \n for line in in_file.readlines():\n #Guarantees sequence is pulled from the FASTA file not the title \n if line[0].isalpha():\n seq = line.rstrip()\n return (seq)","def read_fasta(fp):\n name, seq = None, []\n for line in fp:\n line = line.rstrip()\n if line.startswith(\">\"):\n if name: yield (name, ''.join(seq))\n name, seq = line, []\n else:\n seq.append(line)\n if name: yield (name, ''.join(seq))","def read_fasta_file(fname):\n with open(fname, 'r') as f:\n AA = ''.join(f.read().splitlines()[1:])\n return AA","def read_file(infile_name):\n chr_list = [0]*13 \n for i in range(len(chr_list)):\n chr_list[i] = [] \n infile = open(infile_name)\n for line in infile:\n if line.startswith('SL2.40'):\n info = line.strip().split()\n chr = int(info[0][-2:])\n chr_list[chr].append(map(int,info[1:3])+[[info[-1]]])\n else:\n pass\n infile.close()\n return chr_list","def read_genome(genome_file):\r\n with open(genome_file, 'r') as fid:\r\n seq = [line.strip() for line in fid.readlines()]\r\n sequence = ''.join(seq[1:])\r\n return sequence","def get_seqs(in_fpath):\n f = open(in_fpath, 'r')\n csvread = csv.reader(f)\n seqs = [str(row) for row in csvread]\n seq1 = re.sub('[^A-Z]+', \"\", seqs[0])\n seq2 = re.sub('[^A-Z]+', \"\", seqs[1])\n return seq1, seq2","def pluck_contig(chromosome_name, genome_source):\n chromosome_name = '>' + chromosome_name\n print(\"Searching for\", chromosome_name)\n seq_collection = []\n printing = False\n with open(genome_source, 'r') as genome:\n for line in genome:\n if line.startswith('>'):\n # headers.append(line)\n line = line.rstrip()\n if line.upper() == chromosome_name.upper():\n printing = True\n print(\"Found\", line)\n elif printing:\n break # we've collected all sequence and reached the beginning of the next contig\n elif printing: # This MUST come after the check for a '>'\n line = line.rstrip()\n seq_collection.append(line.upper()) # always upper case so equality checks work\n if not len(seq_collection):\n # File contained these contigs:\\n\" + '\\n'.join(headers)\n raise IOError(\"Contig not found.\" + chromosome_name + \" inside \" + genome_source)\n return ''.join(seq_collection)","def read_fasta_file(fasta):\n\n ptn_list = []\n fasta_content = open(fasta, \"r\")\n new_ptn = None\n for line in fasta_content:\n if \">sp\" in line or \">tr\" in line:\n if new_ptn != None:\n new_ptn[\"seq\"] = sequence\n ptn_list.append(new_ptn)\n tokens = line.split()\n new_ptn = {\"id\": tokens[0] }\n sequence = \"\"\n else:\n sequence += line[:-1]\n new_ptn[\"seq\"] = sequence\n ptn_list.append(new_ptn)\n\n return ptn_list","def fasta(path):\n label = None\n sequence = None\n with open(path, 'r') as data:\n for line in data:\n line = line.strip()\n if line.startswith('>'):\n if label and sequence:\n yield (label, sequence)\n label = line[1:]\n sequence = \"\"\n else:\n sequence += line\n\n if label and sequence:\n yield (label, sequence)","def read_fasta(amplicon_file, minseqlen):\n with gzip.open(amplicon_file) as file:\n sequences = file.readlines()\n seqs = \"\"\n for sequence in sequences:\n #print(\"sequence\")\n seq = sequence.replace(b\"\\n\", b\"\")\n seq = seq.decode('utf8')\n #print(seq)\n for character in seq:\n if character not in \"TGAC\":\n if len(seqs)>=minseqlen:\n yield seqs\n #print(seqs)\n seq = \"\"\n seqs = \"\"\n break\n seqs += seq\n #print(seqs)\n yield seqs","def protein_name_collector():\n resL = []\n with open(\"bob/processed/bobprots_down.csv\", \"r\") as inpF:\n for inpLine in inpF:\n inpLine = inpLine.split(\",\")\n resL.append(inpLine[0].strip(\" \\n\"))\n return resL","def gene_finder(dna):\n threshold = longest_ORF_noncoding(dna, 1500)\n l = []\n for i in find_all_ORFs_both_strands(dna):\n \tif len(i)>=threshold:\n \t\tl.append(coding_strand_to_AA(i))\n print l\n return l","def gene_finder(dna):\n #use longest_ORF_noncoding to determine what the longest strand of DNA could be in a random sequence\n threshold = longest_ORF_noncoding(dna,1500)\n\n #find all of the orfs on both strand and the generate an empty list\n all_orfs = find_all_ORFs_both_strands(dna)\n all_orfs_long = []\n\n #this makes a list of strings of dna that are longer than the threshold\n\n for i in range (0, len(all_orfs)):\n if len(all_orfs[i]) > threshold:\n all_orfs_long.append(all_orfs[i])\n\n #this takes each dna string in a list and converts it to an amino acid sequence\n\n aa_list = []\n\n for i in range (0, len(all_orfs_long)):\n aa_strand = coding_strand_to_AA(all_orfs_long[i])\n aa_list.append(aa_strand)\n\n #returns strings of amino acids\n return aa_list","def process_all_leading_genes(f_path):\n with open(f_path, 'r') as f:\n contents = f.read()\n parts = contents.strip().split('\\t')\n genes = parts[2:]\n return genes","def get_fasta_identifiers(fasta_handle):\n fasta_handle.seek(0)\n current_identifiers = []\n for line in fasta_handle:\n if '>' in line:\n current_id = line.split('>')[1].strip()\n current_identifiers.append(current_id)\n return current_identifiers","def FASTA_iterator(filename):\n fasta_file=open(filename, \"r\")\n id_fasta=\"\"\n seq_fasta=\"\"\n\n for line in fasta_file:\n if line.startswith(\">\"):\n if id_fasta == \"\":\n id_fasta=line.strip()\n continue\n fasta = id_fasta , seq_fasta\n yield fasta\n seq_fasta=\"\"\n id_fasta=line.strip()\n\n else:\n seq_fasta += line.strip()\n\n if seq_fasta != \"\":\n yield id_fasta, seq_fasta","def get_names(lines): \n next = False \n names = []\n for line in lines:\n if next:\n if len(line) == 1:\n break\n else:\n tmp = line.split()\n names.append(tmp[1])\n if line.startswith('Sequences loaded ...'):\n next = True\n return names","def get_uniprot_gene_info(uniprot_result):\n gene_lines = [l for l in uniprot_result.split('\\n') if l.startswith('GN')]\n\n gene_names = []\n\n for gn_line in gene_lines:\n parts = gn_line[2:].split(';')\n for p in parts:\n p = p.strip()\n if p.startswith('Name='):\n gene_names.append(p[5:])\n elif p.startswith('Synonyms='):\n gene_names += [s.strip() for s in p[9:].split(',')]\n\n return gene_names","def parse_fasta_file(filename):\n if filename.endswith('.gz'):\n opener = lambda filename: gzip.open(filename, 'rt')\n else:\n opener = lambda filename: open(filename, 'r')\n\n with opener(filename) as f:\n fasta_iter = (it[1] for it in itertools.groupby(f, is_header))\n for name in fasta_iter:\n name = name.__next__()[1:].strip()\n sequences = ''.join(seq.strip() for seq in fasta_iter.__next__())\n yield name, sequences","def readFastaFile(filename):\n info={}\n fhr=open(filename,\"r\")\n while(True):\n line=fhr.readline()\n if not line: break\n if(\">\" in line):\n try:\n info[line.strip()[1:].split()[0]]=fhr.readline().strip()\n except ValueError:\n pass\n return info","def gene_finder(dna):\n threshold = longest_ORF_noncoding(dna, 1500)\n list_of_aminos = []\n list_of_ORFs = find_all_ORFs_both_strands(dna)\n for an_ORF in list_of_ORFs:\n if an_ORF > threshold:\n amino_acid_ORF = coding_strand_to_AA(an_ORF)\n list_of_aminos.append(amino_acid_ORF)\n return list_of_aminos","def huffman_letter_codes_from_file_contents(file_name):\r\n # Suggested strategy...\r\n freqs = file_character_frequencies(file_name)\r\n return huffman_codes_from_frequencies(freqs)","def get_seqs_to_keep_lookup_from_fasta_file(fasta_f):\r\n return (\r\n set([seq_id.split()[0] for seq_id, seq in parse_fasta(fasta_f)])\r\n )","def getSequence(ref, fasta):\n\n fasta_header = \"\"\n\n fh_fasta = open(fasta, \"r\")\n entry = (x[1] for x in groupby(fh_fasta, lambda line: line[0] == \">\"))\n\n for header in entry:\n headerStr = header.__next__()[1:].strip()\n\n seq = \"\".join(s.strip() for s in entry.__next__())\n\n if ref == headerStr.replace('>',''):\n filename = os.path.join(os.getcwd(), ref.replace('/','_').split('|')[0])\n fasta_header = replace_char(headerStr)\n\n with open(filename + '.fa', \"w\") as output_file:\n output_file.write(\">\" + fasta_header + \"\\\\n\" + seq.upper() + \"\\\\n\")\n\n fh_fasta.close()\n return fasta_header","def read_file(file_name):\n with open(file_name) as f:\n content = f.readlines()\n names = []\n dnas = []\n dna = \"\"\n name = \"\"\n for line in content:\n line = line.strip()\n if line[0] == \">\":\n names.append(name)\n dnas.append(dna)\n name = line[1:]\n dna = \"\"\n else:\n dna += line\n names.append(name)\n dnas.append(dna)\n\n return (names[1:], dnas[1:])","def ReadFASTA(fastafile):\n lines = open(fastafile).readlines()\n headers_seqs = []\n header = None\n seq = []\n for line in lines:\n if line[0] == '>':\n if (not header) and (not seq):\n pass # first sequence in file\n elif header and not seq:\n raise ValueError, \"Empty sequence for %s\" % header\n elif seq and not header:\n raise ValueError, \"File does not begin with header.\"\n else:\n seq = ''.join(seq)\n seq = seq.replace(' ', '')\n headers_seqs.append((header, seq))\n header = line.strip()[1 : ]\n seq = []\n else:\n seq.append(line.strip())\n if (not header) and (not seq):\n pass # first sequence in file\n elif header and not seq:\n raise ValueError, \"Empty sequence for %s\" % header\n elif seq and not header:\n raise ValueError, \"File does not begin with header.\"\n else:\n seq = ''.join(seq)\n seq = seq.replace(' ', '')\n headers_seqs.append((header, seq))\n return headers_seqs","def list_of_gene_IDs_and_symbols_from_file(input_seq_file):\n print(\"Find entrezgene IDs for reporter genes in RNAseq run\")\n lines = []\n with open(input_seq_file, 'U') as input_seq_file:\n next(input_seq_file)\n for line in input_seq_file:\n new_line = line.strip().split('\\t')[0]\n new_line = re.sub('\"', '', new_line) # inputs contained quotes\n lines.append(new_line)\n\n query_list = pd.Series(data=lines).tolist()\n\n print(\"length of query list: \", len(query_list))\n return query_list","def fasta(file_path):\n \n print(f\"Parsing fasta '{file_path}'\")\n data = {\n 'ur_up_': [], 'accession': [],\n 'entry_name': [], 'offset': [],\n 'taxonomy': [], 'sequence': []\n }\n\n with open(file_path, 'r') as f:\n for i, line in enumerate(f):\n line = line.strip()\n \n if line[0] == '>':\n key = line[1:]\n \n if i == 0:\n name, offset = key.split(\"/\")\n ur_up_, acc = None, None\n else:\n ur_up_, acc, name_offset = key.split(\"|\")\n name, offset = name_offset.split('/')\n \n data['ur_up_'].append(ur_up_)\n data['accession'].append(acc)\n data['entry_name'].append(name)\n data['offset'].append(offset)\n data['sequence'].append('')\n data['taxonomy'].append(name.split('_')[1])\n else:\n data['sequence'][-1] += line\n \n if i and (i % 50000 == 0):\n print(f\"Reached: {i}\")\n\n return pd.DataFrame(data=data)","def Parse_Fasta(filename):\n dic = {}\n name = None\n seq = ''\n with open(filename) as F:\n for line in F:\n if line.startswith('>'):\n if name is not None:\n dic[name] = seq\n seq = ''\n name = line.strip()\n else:\n seq += line\n if not name in dic:\n dic[name] = seq\n return dic","def read_drama_names(drama_file):\n with open(drama_file, 'rb') as f:\n drama_list = [d.decode('utf-8').strip() for d in f.readlines()]\n return drama_list","def find_GC_content(fasta_file_name):\n\twith open(fasta_file_name) as fasta:\n\t\tGC_content = {}\n\t\tfor line in fasta:\n\n\t\t\t# Each line (bar the last) ends with '\\n'\n\t\t\tloc_line = line.replace('\\n', '')\n\n\t\t\t# Finds '>' at opening of line (FASTA seq title)\n\t\t\tif re.match(r'^>', loc_line):\n\t\t\t\tGC_content[loc_line] = 0\n\t\t\t\tG_count = 0\n\t\t\t\tC_count = 0\n\t\t\t\tcount = 0\n\t\t\t\tcurrent = loc_line\n\t\t\telse:\n\t\t\t\tG_count += loc_line.count('G')\n\t\t\t\tC_count += loc_line.count('C')\n\t\t\t\tcount += len(loc_line)\n\t\t\t\tGC_content[current] = float((G_count + C_count)) / count\n\treturn GC_content","def parse_fasta(self, filename):\n id = ''\n desc = ''\n tempseq = []\n try:\n seqfile = open(filename,'r')\n for line in seqfile:\n if line.startswith('>'):\n if not id is '':\n yield { 'id': id.strip(), 'desc': desc.strip(), 'dna': ''.join(tempseq) }\n if ' ' in line:\n (id, desc) = line[1::].split(' ', 1)\n else:\n id = line[1::].strip()\n desc = ''\n tempseq = []\n elif not line.startswith('>'):\n tempseq.append(line.rstrip())\n if not id is '':\n yield { 'id': id.strip(), 'desc': desc.strip(), 'dna': ''.join(tempseq) }\n except OSError:\n raise PathError(''.join(['ERROR: cannot open', refseqpath]))","def read_genes(gene_file):\n genes = []\n with open(gene_file, 'rU') as genefile:\n for gene in genefile:\n gene = gene.strip()\n genes.append(gene)\n return(genes)","def get_chroms(chromfile):\n chroms = {}\n with open(chromfile) as c:\n for line in c:\n try:\n chrom, length = line.strip().split()\n chroms[chrom] = length\n except ValueError:\n chroms[line.strip()] = 1\n return chroms","def read_fasta(filename):\n with open(filename, \"r\") as f:\n s = \"\"\n for l in f.readlines()[1:]:\n s += l.strip()\n return s","def gene_finder(dna):\n viable_strings = []\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# intitialize empty list (for strings)\n viable_amino_acids = []\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# intitialize empty list (for amino acids)\n threshold = longest_ORF_noncoding(dna, 1500)\t\t\t\t\t\t\t\t\t\t\t# sets threshold to longest random dna string\n real_dna = list(find_all_ORFs_both_strands(dna))\t\t\t\t\t\t\t\t\t\t# sets real_dna equal to all the ORFs, both strands\n for i in range(len(real_dna)):\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# searches through all the elements in list real_dna\n \tif len(real_dna[i]) > len(threshold):\t\t\t\t\t\t\t\t\t\t\t\t# compares real string to random string\n \t\tviable_strings.append(real_dna[i])\t\t\t\t\t\t\t\t\t\t\t\t# if real string is longer, adds it to list\n for i in range(len(viable_strings)):\t\t\t\t\t\t\t\t\t\t\t\t\t# searches through all elements in viable_strings\n \ta = coding_strand_to_AA(viable_strings[i])\t\t\t\t\t\t\t\t\t\t\t# translates each string to amino acid sequence\n \tviable_amino_acids.append(a)\t\t\t\t\t\t\t\t\t\t\t\t\t\t# adds amino acids to list\n return viable_amino_acids\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# returns list","def readTheFile(path, gui):\n global names\n global SAMPLES_PARTS\n file = open(path, 'r')\n names = file.readline().split()\n names = names[5:]\n SAMPLES_PARTS = [0, 0]\n for name in names:\n if \"Acute\" in name:\n SAMPLES_PARTS[0] += 1\n elif \"Chall\" in name:\n SAMPLES_PARTS[1] += 1\n SAMPLES_PARTS[1] += SAMPLES_PARTS[0]\n line = file.readline()\n data = []\n counter = 1\n gui.write_to_output(\"\\n\")\n while line != '':\n if counter % 1000 == 0:\n gui.write_to_output(\"Done reading \" + str(counter) + \" lines\\n\", overwrite=True)\n counter += 1\n columns = line.split()\n reads = np.array([float(x) for x in columns[5:]])\n name = columns[0]\n chrm = columns[1]\n if chrm == \"chrM\":\n line = file.readline()\n continue\n start = int(columns[2])\n end = int(columns[3])\n if abs(end - start) > 500:\n line = file.readline()\n continue\n strand = columns[4]\n data.append(Gene(name, reads, np.array([start, end]).astype(np.int), strand, chrm))\n line = file.readline()\n gui.write_to_output(\"Done reading \" + str(counter) + \" lines...Now sorting...\\n\", overwrite=True)\n return list(sorted(data, key=lambda x: x.getName()))","def get_names_from_Seq_db(seq_db):\r\n names = []\r\n names_abudance_removed = []\r\n db = open(seq_db, \"r\")\r\n for seq_record in SeqIO.parse(db, \"fasta\"):\r\n if seq_record.id.endswith(\"_1\"):\r\n names.append(seq_record.id)\r\n names_abudance_removed.append((\"_\").join(\r\n seq_record.id.split(\"_\")[:-1]))\r\n else:\r\n names_abudance_removed.append(seq_record.id)\r\n names.append(seq_record.id + \"_1\")\r\n db.close()\r\n return names, names_abudance_removed","def get_chromosome_names(bam):\n\n # ref_tid = {str(name): int(bam.get_tid(name)) + 1 for name in bam.get_reference_name}\n\n ref_tid = {} # 'I' | 0, 'II' | 1, ...\n for i in range(bam.nreferences): #if bam.nreferences does not work, use range(17) #16 chromosomes and the mitochondrial chromosome\n ref_name = bam.get_reference_name(i)\n ref_tid[ref_name] = bam.get_tid(ref_name)\n\n return ref_tid","def fastaDictionary(inFile, chrName=None):\n\n d = {}\n for (title, seq) in FastaIterator(inFile):\n title = title.split()[0]\n if not chrName:\n d[title] = seq\n elif chrName == title:\n d[title] = seq\n return d\n\n if chrName:\n print \"NOT ABLE TO FIND!\", chrName\n return d","def get_pokemon_names():\n with open(POKEMON_FILE, 'r') as fh:\n pokemon = json.load(fh)\n return [name.lower() for name in pokemon]","def GetGeneName(arg):\n\n genbank = ChromUnzip(arg)\n \n p1=re.compile(r'(?:ACCESSION\\s+)(\\w+\\d+)')\n p6=re.compile(r'(?:/gene=\")(.+?)(?:\"\\s+)')\n\n gene_name_dict={}\n \n for entry in genbank:\n gene_list=[] \n gene_it_6=p6.finditer(entry)\n gene_it_1=p1.finditer(entry) \n for hit in gene_it_6:\n gene_list.append(hit.group(1))\n for item in gene_it_1:\n gene_name_dict[item.group(1)]=gene_list[0]\n \n return gene_name_dict","def get_cds_start_end_locations_genbank_file(filename):\n # Loop over the features\n genes = defaultdict(list)\n cds = 0\n for seq_record in SeqIO.parse(filename, \"genbank\"):\n print(f'Dealing with GenBank record {seq_record.id}')\n for seq_feature in seq_record.features:\n if seq_feature.type == \"CDS\" and 'protein_id' in seq_feature.qualifiers:\n cds += 1\n prot_id = seq_feature.qualifiers['protein_id'][0]\n start, end = int(seq_feature.location.start), int(seq_feature.location.end)\n genes[prot_id] = genes.get(prot_id, []) + [start, end]\n print(f'There are {cds} CDS and {len(genes)} genes annoted for this genbank record')\n return genes","def read_fasta(src, remove_gaps=False):\n file_obj = None\n if isinstance(src, str):\n try:\n file_obj = open(src, \"r\")\n except IOError:\n print((\"The file `%s` does not exist, exiting gracefully\" % src))\n elif isinstance(src, filetypes):\n file_obj = src\n else:\n raise TypeError('FASTA reader cannot recognize the source of %s, %s, %s' % (src,type(src),isinstance(src, filetypes)))\n name = None\n seq_list = list()\n for line_number, i in enumerate(file_obj):\n if i.startswith('>'):\n if name:\n if remove_gaps:\n yield name, ''.join(seq_list).replace('-', '')\n else:\n yield name, ''.join(seq_list)\n seq_list = list()\n name = i[1:].strip()\n else:\n #seq = ''.join(i.strip().upper().split())\n seq = ''.join(i.strip().split())\n #if not is_sequence_legal(seq):\n # raise Exception(\"Error: illegal characeters in sequence at line %d\" % line_number)\n seq_list.append(seq)\n if name:\n if remove_gaps:\n yield name, ''.join(seq_list).replace('-', '')\n else:\n yield name, ''.join(seq_list)\n if isinstance(src, str):\n file_obj.close()","def gene_finder(dna):\n threshold = longest_ORF_noncoding(dna, 1500)\n orfs = find_all_ORFs_both_strands(dna)\n list1 = []\n for orf in orfs:\n if len(orf) > threshold:\n list1.append(coding_strand_to_AA(orf))\n return list1","def readGenome(filename):\n\tgenome = ''\n\twith open(filename,'r') as f:\n\t\tfor line in f:\n\t\t\tif not line[0] == '>':\n\t\t\t\tgenome += line.rstrip()\n\treturn genome","def _getSeqName(header):\n seqNameList = []\n unMapped=''\n for sn in header['sq']:\n if (sn[0].startswith('GL')) or (sn[0].startswith('chrUn')):\n unMapped += \" %s\" % sn[0]\n else:\n seqNameList.append(sn[0]) # first column is seqName\n\n if unMapped != '': \n seqNameList.append(unMapped)\n\n return seqNameList","def parse_fasta(data):\n name, seq = None, []\n for line in data:\n line = line.rstrip()\n if line.startswith('>'):\n if name:\n yield (name, ''.join(seq))\n name, seq = line, []\n else:\n seq.append(line)\n if name:\n yield (name, ''.join(seq))","def readFastaFile(filename):","def getFile(filename):\n f = open(filename)\n lines = f.readlines()\n f.close()\n names = []\n names.append(\"\")\n for name in lines[0].split(','):\n \n names.append(name[1:-1])\n names = sorted(names)\n return names","def read_fasta(fasta_name):\n \n \"\"\"first open the file outside \"\"\"\n file_handler = open(fasta_name)\n\n # ditch the boolean (x[0]) and just keep the header or sequence since\n # we know they alternate.\n fasta_iter = (x[1] for x in groupby(file_handler, lambda line: line[0] == \">\"))\n\n for header in fasta_iter:\n # drop the \">\"\n headerStr = header.__next__()[1:].strip()\n\n # join all sequence lines to one.\n seq = \"\".join(s.strip() for s in fasta_iter.__next__())\n\n # yield (headerStr, seq)\n result_record = {'header':headerStr,'seqRecord':seq}\n return result_record","def get_fasta_labels(input_fasta_fp):\r\n\r\n fasta_labels = []\r\n\r\n fasta_f = open(input_fasta_fp, \"U\")\r\n\r\n for label, seq in parse_fasta(fasta_f):\r\n fasta_labels.append(label.split()[0])\r\n\r\n return fasta_labels","def fasta_read_generator(file_handler):\r\n seq = []\r\n name = ''\r\n for line in file_handler:\r\n if line[0] == '>':\r\n sequence = ''.join(seq)\r\n if name: # only yield when we already have all data for the first sequence\r\n yield name, sequence\r\n name = line.rstrip()[1:] # omitting the leading >\r\n seq = []\r\n else:\r\n seq += [line]#.rstrip()] # keep line breaks\r\n sequence = ''.join(seq)\r\n yield name, sequence # don't forget the last sequence\r","def _gene_ann(gene_ann_path):\n gene_ann = pd.read_csv(gene_ann_path)\n protein_gene = gene_ann[gene_ann.gene_type ==\n 'protein_coding'].gene_name.tolist()\n return(protein_gene)","def readfile(filename):\n infile = open(filename,\"r\")\n seq = infile.read()\n return re.sub('[^acgtACGT]', '', seq).upper()","def scan_full_pr(fastafile):\n n_full=0\n n=0\n\n with open(fastafile, \"r\") as f:\n lines=f.readlines()\n name=\"\"\n for line_n in lines:\n line=line_n.strip()\n if line[0]==\">\":\n name=line.replace(\">\",\"\")\n n+=1\n else:\n if line[0]==\"M\" and line[-1]==\"*\":\n n_full+=1\n sys.stdout.write(str(name)+\"\\n\")\n\n return n, n_full","def get_surnames(filename):\n result = []\n with open(filename, \"r\") as file:\n for line in file.readlines():\n surname = line.split('\\t')[1]\n result.append(surname)\n return result","def get_fasta_sequence_ids(fasta):\n if not os.path.exists(fasta) or (not os.path.isfile(fasta)):\n raise FileNotFoundError(fasta)\n seq_ids = set()\n with open(fasta, \"r\") as f:\n # 'fasta' is https://biopython.org/wiki/SeqIO file type.\n for record in SeqIO.parse(f, \"fasta\"):\n seq_ids.add(record.id)\n return seq_ids","def read_fasta_to_dictionary(genome_file):\n filename = genome_file\n dct = {}\n\n id_name = \"\"\n sequence = \"\"\n first_pass = 1\n\n read_fh = open(filename, 'r')\n for i, line in enumerate(read_fh):\n line = line.rstrip()\n if re.search(r'^>(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(.*)', line):\n\n match_obj = re.search(r'^>(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(\\s+)(\\S+)(.*)', line)\n if not first_pass:\n dct[id_name] = sequence\n id_name = match_obj.group(1)\n id_name = re.sub(r',', \"\", id_name)\n first_pass = 0\n sequence = \"\"\n\n elif re.search(r'^>(\\S+)(.*)', line):\n\n match_obj = re.search(r'^>(\\S+)(.*)', line)\n if not first_pass:\n dct[id_name] = sequence\n id_name = match_obj.group(1)\n id_name = re.sub(r'(\\d+)_', \"\", id_name)\n id_name = re.sub(r'.*\\|', \"\", id_name)\n first_pass = 0\n sequence = \"\"\n else:\n sequence += line\n dct[id_name] = sequence\n\n return dct","def process_fasta(file, type):\n seqs = []\n with open(file) as f:\n seq = f.readline().strip()\n seq = seq + '\\t'\n for line in f:\n line = line.strip()\n if line[0] == \">\":\n s1 = seq.split('\\t')\n bac = s1[0].split(\"|\")[2]\n sequence = to_word_index(s1[1], type)\n seqs.append([bac, sequence])\n seq = line + '\\t'\n else:\n seq = seq + line\n\n s1 = seq.split('\\t')\n bac = s1[0].split(\"|\")[2]\n sequence = to_word_index(s1[1], type)\n seqs.append([bac, sequence])\n\n df = pd.DataFrame(seqs, columns=['bacteria', 'sequence'])\n df = shuffle(df)\n\n return df","def fasta_path_to_seqs(fasta_path, codon_table=False, codon_alphabet=False):\n seqs = []\n for record in SeqIO.parse(fasta_path, \"fasta\"):\n seqs.append(record)\n return seqs","def print_file(chr_list,filename):\n infile = open(filename)\n for line in infile:\n if line.startswith('SL2.40'):\n chr = int(line.strip().split()[0][-2:])\n loci = int(line.strip().split()[1])\n for chr_i,chr_l in enumerate(chr_list):\n for loc in chr_l:\n if chr==chr_i and loci==loc:\n print line\n return","def FASTA_iterator (fasta_filename):\n file=open(fasta_filename,\"r\")\n seq=''\n for line in file:\n if line[0]==\">\":\n if seq != \"\":\n yield (lastid,seq)\n seq=''\n lastid=line.rstrip()[1:]\n else:\n lastid=line.rstrip()[1:]\n else:\n seq += line.rstrip()\n if seq != \"\":\n yield (lastid,seq)","def genes():\n return [\"b2935\", \"b0723\", \"b0451\"]","def read_names_list(file_path):\r\n\tnames_list = []\r\n\twith open(file_path) as file:\r\n\t for line in file:\r\n\t cline = line.rstrip().split()\r\n\t #row_id = cline[0]\r\n\t row_name = cline[1:]\r\n\t #names_list.append((row_id, \" \".join(row_name)))\r\n\t names_list.append(\" \".join(row_name))\r\n\treturn names_list","def read_faidx(filename, filter_strs):\n if not filename.endswith('.fai'):\n # Try to find fai file.\n fai_candidates = [filename + '.fai',\n filename.rstrip('.fa') + '.fai',\n filename.rstrip('.gz') + '.fai']\n try:\n faidx_file = [os.path.isfile(c)\n for c in fai_candidates].index(True)\n faidx_file = fai_candidates[faidx_file]\n except ValueError:\n raise IOError('Could not find valid faidx for [%s]i\\n' % filename)\n else:\n faidx_file = filename\n\n try:\n chroms = {}\n with open(faidx_file) as faidx:\n for record in faidx:\n col = record.strip().split()\n name, length = col[0], int(col[1])\n if not any([ignore in name for ignore in filter_strs]):\n chroms[name] = length\n return chroms\n except Exception:\n print('Could not read faidx file [%s]' % faidx_file)\n raise","def load_fasta_sequences(fasta_file, return_keys=False):\n fasta = Fasta(fasta_file, as_raw=True, sequence_always_upper=True)\n seqs = [seq[:] for seq in fasta]\n if return_keys:\n keys = list(fasta.keys())\n fasta.close()\n if return_keys:\n return seqs, keys\n return seqs","def get_population_names (f,a,s):\r\n ## a, s not used but needed for function to match general function format\r\n global gv\r\n aa = f.readline().strip()\r\n popnamelist = []\r\n i = 0\r\n foundghost = False\r\n while aa.find(\"Population\") >= 0:\r\n popname = aa.split()[3]\r\n if popname.upper() == \"GHOST\":\r\n foundghost = True\r\n popnamelist.append(popname)\r\n i += 1\r\n aa = f.readline().strip()\r\n if gv[\"useghost\"] == True and foundghost == False: # for compatibility with older output files\r\n popnamelist.append('ghost')\r\n anames = []\r\n if gv[\"usealtnames\"]:\r\n for line in open(gv[\"altnamefilename\"],\"r\"):\r\n temp = line.strip()\r\n if len(temp) > 0:\r\n anames.append(temp)\r\n anames = anames[0:len(popnamelist)]\r\n gv[\"altpopnames\"] = list(anames)\r\n return popnamelist","def gene_finder(dna, threshold):\n \n List_of_dna=find_all_ORFs_both_strands(dna)\n aa_list=[]\n for string in List_of_dna:\n if len(string)< threshold:\n continue\n else:\n aa_list.append(coding_strand_to_AA(string))\n return aa_list","def parse_dna(file_handle):\n sequence = []\n for line in file_handle:\n words = line.split()\n seq_string = \"\".join(words[:-1])\n seq_list = list(seq_string)\n sequence.extend(seq_list)\n return sequence","def read_fasta(sequence_file :str):\n\n #for gziped files:\n\n if sequence_file.endswith(\".gz\"):\n with gzip.open(sequence_file, \"rt\") as file:\n seqDict = SeqIO.to_dict(SeqIO.parse(file, 'fasta'))\n ident = ident.split(\"|\")[1]\n return seqDict\n\n # for no gziped fasta files:\n else:\n seqRecord = SeqIO.read(sequence_file, \"fasta\")\n sequence = seqRecord.seq\n ident = seqRecord.id\n ident = ident.split(\"|\")[1]\n return ident, sequence","def collect_names(files):\n names = set()\n routes = defaultdict(dict)\n for file in files:\n gene_name = file.split('/')[-1].split('.')[0]\n for record in SeqIO.parse(file, 'fasta'):\n if record.name.count('_') >= 3:\n name = record.name.split('_')[0]\n route = record.name.split('_')[2]\n routes[gene_name][name] = route\n elif '_' in record.name:\n name = record.name.split('_')[0]\n else:\n name = record.name\n names.add(name)\n return sorted(list(names)), routes","def available_samples(vcf_path):\n return _header_from_vcf(vcf_path)[9:]","def iter_protenn_matches(file: str):\n with open(file, \"rt\") as fh:\n for line in fh:\n sequence_id, pfam_acc, start, end = line.rstrip().split(\"\\t\")\n if re.fullmatch(r\"PF\\d+\", pfam_acc):\n yield sequence_id, pfam_acc, int(start), int(end)","def read_screen_names(filename):\n flist = []\n f = open('candidates.txt')\n for line in f:\n \tflist.append(line.strip('\\n'))\t\n return flist","def names(self) -> list[str]:","def get_sequence_from_fasta(fasta_file):\n\n if not fasta_file:\n raise ValueError(\"Path cannot be empty.\")\n\n handle = open(fasta_file, 'r')\n try:\n sequence = handle.readlines()\n finally:\n handle.close()\n\n sequence = [line.strip() for line in sequence if not '>' in line]\n sequence = ''.join(sequence)\n\n return sequence","def fix_seqname(sname):\r\n # protid is on each line of the FASTA file; splitting doesn't really do anything\r\n # protid = sname.split(' ')\r\n # TK 2020-07-22\r\n # Dictionary for filenames so that we know which CDS file to query for each\r\n # protein ID.\r\n lookups = {\r\n 'AET' : 'Aegilops_tauschii.Aet_v4.0.cds.all.fa',\r\n\t'PNS' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\r\n\t'PNT' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\r\n\t'KQJ' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\r\n\t'KQK' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\r\n\t'Dr' : 'Dioscorea_rotundata.TDr96_F1_Pseudo_Chromosome_v1.0.cds.all.fa',\r\n\t'Et' : 'Eragrostis_tef.ASM97063v1.cds.all.fa',\r\n\t'HORVU' : 'Hordeum_vulgare.IBSC_v2.cds.all.fa',\r\n\t'LPERR' : 'Leersia_perrieri.Lperr_V1.4.cds.all.fa',\r\n\t'GSMUA' : 'Musa_acuminata.ASM31385v1.cds.all.fa',\r\n\t'OBART' : 'Oryza_barthii.O.barthii_v1.cds.all.fa',\r\n\t'ORGLA' : 'Oryza_glaberrima.Oryza_glaberrima_V1.cds.all.fa',\r\n\t'ONIVA': 'Oryza_nivara.Oryza_nivara_v1.0.cds.all.fa',\r\n\t'ORUFI' : 'Oryza_rufipogon.OR_W1943.cds.all.fa',\r\n\t'PVH' : 'Panicum_hallii_fil2.PHallii_v3.1.cds.all.fa',\r\n\t'Sspon' : 'Saccharum_spontaneum.Sspon.HiC_chr_asm.cds.all.fa',\r\n\t'KQL' : 'Setaria_italica.Setaria_italica_v2.0.cds.all.fa',\r\n\t'TraesCS' : 'Triticum_aestivum.IWGSC.cds.all.fa',\r\n\t'Zm' : 'Zea_mays.B73_RefGen_v4.cds.all.fa',\r\n\t'Zlat': 'Zlat_V1.cds.fa',\r\n 'FUN': 'rice.transcripts.fa',\r\n 'Os': 'Oryza_sativa.IRGSP-1.0.cds.all.fa'\r\n }\r\n # Get the filename based on what the sequence starts with.\r\n for id_start, cds_file in lookups.items():\r\n if sname.startswith(id_start):\r\n target_file = cds_file\r\n break\r\n # Return the protein name and CDS target file as a tuple\r\n return (target_file, sname)\r\n\r\n # Make a lookup table to get the species name based on the protein ID.\r\n # lookups = [('Zlat*','Zizania_latifolia'),('FUN*','Zizania_palustris'),('Os*','Oryza_sativa')]\r\n # Initialize an empty species dictionary to assist in connecting protid (gene name) to species name\r\n # species_dict = {}\r\n # # This for loop will populate the species dictionary so that we can get species name keyed on the protid (gene name)\r\n # for i in protid:\r\n # species = lookup(i, lookups)\r\n # return species.encode, i\r\n # species_dict[protid] = species.encode()\r\n # return None\r","def parse_FASTA(file):\r\n\tstate = 0\r\n\tdna_list = []\r\n\tfor line in file:\r\n\t\tline = line.strip()\r\n\t\tif state == 0:\r\n\t\t\tif line[0] == '>':\r\n\t\t\t\tadd_new_DNA(dna_list, line)\r\n\t\t\t\tstate = 1\r\n\t\t\telif line == '':\r\n\t\t\t\tcontinue\r\n\t\t\telse:\r\n\t\t\t\traise Exception()\r\n\t\telif state == 1:\r\n\t\t\tadd_line_to_DNA(dna_list[-1], line)\r\n\t\t\tstate = 2\r\n\t\telif state == 2:\r\n\t\t\tif line[0] == '>':\r\n\t\t\t\tadd_new_DNA(dna_list, line)\r\n\t\t\t\tstate = 1\r\n\t\t\telse:\r\n\t\t\t\tadd_line_to_DNA(dna_list[-1], line)\r\n\t\telse:\r\n\t\t\traise Exception()\r\n\tfile.seek(0)\r\n\treturn dna_list","def readFile(fileName):\n\tf = open(fileName, 'r')\n\tnames = map(lambda s: s[1:-1], f.read().split(','))\n\tnames.sort()\n\treturn names","def read_chr(fpath):\n\t# init dict and indices\n\tchrom_dicts={}\n\tstart=0\n\tindex=0\n\n\t# iterate through chromosome scores \n\tfor line in fileinput.input(fpath):\n\t\tx=line.split()\n\t\t\n\t\t# if chromosome skips some region, then normalize the previous window (<100 bp) and init new window \t\n\t\tif len(x)==4:\n\t\t\tif start in chrom_dicts:\n\t\t\t\tchrom_dicts[start]/=index\n\t\t\tstart=int(x[2].split(\"=\")[1])\n\t\t\tchrom_dicts[start]=0\n\t\t\tindex=0\n\n\t\t# if not a black region, then make news windows every 100 locations\n\t\tif len(x)==1:\n\t\t\tchrom_dicts[start]+=float(x[0])\n\t\t\tif index==100:\n\t\t\t\tchrom_dicts[start]/=index\n\t\t\t\tindex=0\n\t\t\t\tstart+=100\n\t\t\t\tchrom_dicts[start]=0\n\t\t\tindex+=1\n\t\n\t# track chromosomes that have been binned\n\tprint(\"%s %d\" % (fpath,len(chrom_dicts)))\n\treturn(chrom_dicts)","def GenomeReader(GenomeFile):\n GenomeScaffolds = {}\n key = []\n with open(GenomeFile, 'r') as f:\n for line in f:\n line = line.strip()\n if line.startswith(\">\"):\n NamedSeq = line.replace('>', '')\n key.append(NamedSeq)\n GenomeScaffolds[NamedSeq] = \"\"\n else:\n GenomeScaffolds[NamedSeq] += line\n return GenomeScaffolds # Returns a Dictionary object","def read_fasta(amplicon_file, minseqlen):\n if amplicon_file.endswith(\"gz\"): \n with gzip.open(amplicon_file, \"rb\") as gz:\n seq = b\"\"\n for line in gz:\n if line.startswith(b\">\"):\n if len(seq) >= minseqlen:\n yield seq.decode('ascii')\n seq = b\"\"\n else:\n seq += line.strip()\n yield seq\n\n elif amplicon_file.endswith(\"fasta\"):\n with open(amplicon_file, \"r\") as fasta:\n seq = \"\"\n for line in fasta:\n if line.startswith('>'):\n if len(seq) >= minseqlen:\n yield seq\n seq =\"\"\n \n else:\n seq = seq + line[:-1]\n if len(seq) >= minseqlen:\n yield seq","def protein_from_orfs(dna):\n rna = dna.replace(\"T\", \"U\")\n reverse_complement_rna = complement_strand(dna).replace(\"T\", \"U\")\n\n candidate_proteins = set()\n\n for strand in [rna, reverse_complement_rna]:\n for index in [m.start() for m in re.finditer('AUG', strand)]:\n codons_list = codons(strand[index:])\n protein = \"\"\n\n if any(rna_codon_dict[codon] == \"Stop\" for codon in codons_list):\n for codon in codons_list:\n symbol = rna_codon_dict[codon]\n\n if symbol != \"Stop\":\n protein += symbol\n else:\n candidate_proteins.add(protein)\n break\n\n return candidate_proteins","def fasta_parser(filename):\n fasta = {}\n with open(filename) as f:\n contents = f.read()[1:].split('\\n>')\n for section in contents:\n sample = section.split('\\n')\n sample_id = sample[0]\n seq = ''.join(sample[1:]).strip()\n fasta[sample_id] = seq\n return fasta"],"string":"[\n \"def readFasta(self, fastaFile):\\t\\n\\t\\tname, seq = None, []\\n\\t\\tfor line in fastaFile:\\n\\t\\t\\tline = line.rstrip()\\n\\t\\t\\tif (line.startswith(\\\">\\\")):\\n\\t\\t\\t\\tif name: yield (name, ''.join(seq))\\n\\t\\t\\t\\tname, seq = line, []\\n\\t\\t\\telse:\\n\\t\\t\\t\\tseq.append(line)\\n\\t\\tif name: yield (name, ''.join(seq))\",\n \"def fasta_seqs(file_name):\\n list = []\\n with open('../test_files/' + file_name, 'r') as infile:\\n text = infile.read()\\n seqs = text.split('>')\\n for seq in seqs:\\n try:\\n x = seq.split('\\\\n', 1)\\n # sequence will be stored in x[1], and i am removing nextline '\\\\n' characters that comes with it.\\n list.append(x[1].replace('\\\\n', ''))\\n except:\\n pass\\n return list\",\n \"def full_chromosomes(reader):\\n for line in reader.header.get_lines(\\\"contig\\\"):\\n if line.id in CHROMS:\\n name = line.id\\n length = line.length or 1_000_000_000\\n yield \\\"{}:{}-{}\\\".format(name, 1, length)\",\n \"def read_fasta_file(path):\\n with open(path) as data_file:\\n output = {}\\n sequence_name = None\\n for line in data_file.readlines():\\n if line.startswith(\\\">\\\"):\\n sequence_name = line[1:].strip()\\n else:\\n output.setdefault(sequence_name, \\\"\\\")\\n line = \\\"\\\".join(re.findall(\\\"[acgtACGT]+\\\", line))\\n\\n output[sequence_name]+=line.upper()\\n return output\",\n \"def load_fasta(filepath):\\n chromosomes = {}\\n\\n seqs = SeqIO.parse(filepath, format='fasta', \\n alphabet=IUPAC.ambiguous_dna)\\n\\n # iterate over seqs and add to chromosome dictionary\\n for seq in seqs:\\n # determine chromosome number\\n match = re.search('\\\\d+', seq.name)\\n chromosome_number = int(match.group())\\n\\n chromosomes[chromosome_number] = seq\\n\\n return chromosomes\",\n \"def parse_fasta_use_bio(file_name):\\n pro_id_list = []\\n for seq_record in SeqIO.parse(file_name, \\\"fasta\\\"):\\n tmp_list = seq_record.id.strip('\\\\n').split('|')\\n pro_id_list.append(tmp_list[1])\\n # break\\n\\n return pro_id_list\",\n \"def readFastaFile(filename):\\n if os.path.exists(filename)==False:return {}\\n sequences={}\\n fhr=open(filename,\\\"r\\\")\\n for line in fhr:\\n if line[0]==\\\">\\\":\\n sequences[line.strip()[1:].split()[0]]=fhr.readline().strip()\\n fhr.close()\\n return sequences\",\n \"def fasta_headers(file_name):\\n list = []\\n with open('../test_files/' + file_name, 'r') as infile:\\n text = infile.read()\\n seqs = text.split('>')\\n for seq in seqs:\\n try:\\n x = seq.split('\\\\n', 1)\\n if x[0] != '':\\n #x[0] contains only headers\\n list.append(x[0])\\n except:\\n pass\\n return list\",\n \"def get_genes(infile,outfile):\\n gene_list = []\\n with open(infile) as gene:\\n tag = False\\n for line in gene:\\n if line.startswith('name'):\\n tag = True\\n continue\\n if tag:\\n items = line.split()\\n if len(items) > 0:\\n gene_list.append(items[0])\\n gene_list = gene_list[1:-7]\\n with open(outfile, 'w') as outfile:\\n for i in gene_list:\\n outfile.write(i+'\\\\n')\\n return True\",\n \"def extract_sequence(chrom,start,end,fasta_file):\\n # extract the sequence from this region with pybedtools\\n my_peak = '\\\\t'.join([chrom,str(start),str(end)])\\n bedtool_peak = pybedtools.BedTool(my_peak, from_string=True)\\n fasta = pybedtools.example_filename(fasta_file)\\n a = a.sequence(fi=fasta)\\n #print(open(a.seqfn).read()) \",\n \"def load_data() -> list:\\n # trans_dict is used for changing the given names into standardized names.\\n trans_dict = {\\\"chr1\\\": \\\"1\\\", \\\"chr2\\\": \\\"2\\\", \\\"chr3\\\": \\\"3\\\", \\\"chr4\\\": \\\"4\\\", \\\"chr5\\\": \\\"5\\\", \\\"chr6\\\": \\\"6\\\", \\\"chr7\\\": \\\"7\\\",\\n \\\"chr8\\\": \\\"8\\\", \\\"chr9\\\": \\\"9\\\", \\\"chr10\\\": \\\"10\\\", \\\"chr11\\\": \\\"11\\\", \\\"chr12\\\": \\\"12\\\", \\\"chr13\\\": \\\"13\\\", \\\"chr14\\\": \\\"14\\\",\\n \\\"chr15\\\": \\\"15\\\", \\\"chr16\\\": \\\"16\\\", \\\"chr17\\\": \\\"17\\\", \\\"chr18\\\": \\\"18\\\", \\\"chr19\\\": \\\"19\\\", \\\"chrx\\\": \\\"x\\\", \\\"chry\\\": \\\"y\\\"}\\n # This try statement catches user error.\\n try:\\n with open(sys.argv[1]) as bed_file, open(sys.argv[2]) as fasta_file:\\n fasta_records = []\\n # Opens the bed file and splits into lists\\n bed_file = list(csv.reader(bed_file, delimiter='\\\\t'))\\n # Changes the names of the chromosomes in bed file, does some light rearranging and formatting.\\n bed_file = [[trans_dict[record[0].lower()], record[1], record[3][0:record[3].index(\\n '\\\\'')]] for record in bed_file]\\n # Sorts the desired indices by chromosome, then by index in the chromosome.\\n bed_file = sorted(bed_file, key=itemgetter(1))\\n bed_file = sorted(bed_file, key=itemgetter(0))\\n # This stores the desired indexes for each chromosome.\\n indexable_bed_records = {'1': [], '2': [], '3': [], '4': [], '5': [], '6': [], '7': [], '8': [], '9': [],\\n '10': [], '11': [], '12': [], '13': [], '14': [], '15': [], '16': [], '17': [],\\n '18': [], '19': [], 'x': [], 'y': []}\\n # Put each desired index into it's appropriate chromosome list.\\n for record in bed_file:\\n indexable_bed_records[record[0]].append([record[2], record[1]])\\n # Loops over fasta records in the supplied fasta file\\n for fasta_record in fasta_iter(fasta_file):\\n # grabs the chromosome id\\n chrom_id = fasta_record[\\\"header\\\"][:fasta_record[\\\"header\\\"].index(' ')].lower()\\n # Some chromosomes are not desired, skip them.\\n if chrom_id not in indexable_bed_records.keys():\\n continue\\n # Grabs the indexes we want to extract from the chromosome.\\n indexes = indexable_bed_records[chrom_id]\\n # Grabs each index+/-10 from the sequence\\n for index in indexes:\\n fasta_records.append([index[0], fasta_record[\\\"seq\\\"][int(index[1]) - 10:int(index[1]) + 10]])\\n # Returns a list of lists of format [5'/3',splice site sequence]\\n return fasta_records\\n # Catches user error.\\n except (FileNotFoundError, IndexError) as e:\\n if type(e) is IndexError:\\n sys.stderr.write(\\\"Usage: {} bed_file fasta_file\\\\n\\\\tbed_file: The appropriate bed file. \\\\n\\\\t\\\"\\n \\\"fasta_file: The appropriate fasta file.\\\\n\\\".format(os.path.basename(__file__)))\\n elif type(e) is FileNotFoundError:\\n sys.stderr.write(\\\"One of the specified files was not found.\\\\n\\\")\\n sys.exit(1)\",\n \"def gene_names(filepath, complete=True):\\n if complete:\\n df_ucsc = pd.read_csv(filepath, sep='\\\\t', header=None)\\n df_ucsc.columns = (\\n ['number', 'gene_name', 'locus_link',\\n 'ref_seq_num', 'genbank', 'uniprot', 'taxon']\\n )\\n gene_ucsc = set(\\n [str(name).lower() for name in df_ucsc[\\\"gene_name\\\"]\\n if len(str(name)) >1]\\n )\\n return gene_ucsc\\n else:\\n df_syn = pd.read_csv(filepath, sep='\\\\t', header=None)\\n df_syn.columns = ['number', 'gene_name']\\n gene_ucsc = set(\\n [str(name).lower() for name in df_syn[\\\"gene_name\\\"]\\n if len(str(name)) >1]\\n )\\n return gene_ucsc\",\n \"def fetch_as_fasta(chrom,start,end,gindex,fname):\\n \\n # Print the sequence in fasta format.\\n header = '>%s:%s-%s' % (chrom, start, end)\\n fname.write('%s\\\\n%s\\\\n' % (header, gindex[chrom][start:end]))\",\n \"def _chrom_sizes(fasta_file):\\n from pysam import FastaFile\\n fa = FastaFile(fasta_file)\\n chrom_lens = OrderedDict([(name, l) for name, l in zip(fa.references, fa.lengths)])\\n if len(chrom_lens) == 0:\\n raise ValueError(f\\\"no chromosomes found in fasta file: {fasta_file}. \\\"\\n \\\"Make sure the file path is correct and that the fasta index \\\"\\n \\\"file {fasta_file}.fai is up to date\\\")\\n fa.close()\\n return chrom_lens\",\n \"def read_file(infile_name):\\n chr_list = [0]*13 \\n for i in range(len(chr_list)):\\n chr_list[i] = [] \\n infile = open(infile_name)\\n for line in infile:\\n if line.startswith('SL2.40'):\\n chr = int(line.strip().split()[0][-2:])\\n loci = int(line.strip().split()[1])\\n chr_list[chr] += [loci]\\n else:\\n pass\\n infile.close()\\n return chr_list\",\n \"def fasta_reader(inp):\\n #inp is hard coded as \\\"Sequence1/2.fasta in this script\\\".\\n with open(inp) as in_file: \\n for line in in_file.readlines():\\n #Guarantees sequence is pulled from the FASTA file not the title \\n if line[0].isalpha():\\n seq = line.rstrip()\\n return (seq)\",\n \"def read_fasta(fp):\\n name, seq = None, []\\n for line in fp:\\n line = line.rstrip()\\n if line.startswith(\\\">\\\"):\\n if name: yield (name, ''.join(seq))\\n name, seq = line, []\\n else:\\n seq.append(line)\\n if name: yield (name, ''.join(seq))\",\n \"def read_fasta_file(fname):\\n with open(fname, 'r') as f:\\n AA = ''.join(f.read().splitlines()[1:])\\n return AA\",\n \"def read_file(infile_name):\\n chr_list = [0]*13 \\n for i in range(len(chr_list)):\\n chr_list[i] = [] \\n infile = open(infile_name)\\n for line in infile:\\n if line.startswith('SL2.40'):\\n info = line.strip().split()\\n chr = int(info[0][-2:])\\n chr_list[chr].append(map(int,info[1:3])+[[info[-1]]])\\n else:\\n pass\\n infile.close()\\n return chr_list\",\n \"def read_genome(genome_file):\\r\\n with open(genome_file, 'r') as fid:\\r\\n seq = [line.strip() for line in fid.readlines()]\\r\\n sequence = ''.join(seq[1:])\\r\\n return sequence\",\n \"def get_seqs(in_fpath):\\n f = open(in_fpath, 'r')\\n csvread = csv.reader(f)\\n seqs = [str(row) for row in csvread]\\n seq1 = re.sub('[^A-Z]+', \\\"\\\", seqs[0])\\n seq2 = re.sub('[^A-Z]+', \\\"\\\", seqs[1])\\n return seq1, seq2\",\n \"def pluck_contig(chromosome_name, genome_source):\\n chromosome_name = '>' + chromosome_name\\n print(\\\"Searching for\\\", chromosome_name)\\n seq_collection = []\\n printing = False\\n with open(genome_source, 'r') as genome:\\n for line in genome:\\n if line.startswith('>'):\\n # headers.append(line)\\n line = line.rstrip()\\n if line.upper() == chromosome_name.upper():\\n printing = True\\n print(\\\"Found\\\", line)\\n elif printing:\\n break # we've collected all sequence and reached the beginning of the next contig\\n elif printing: # This MUST come after the check for a '>'\\n line = line.rstrip()\\n seq_collection.append(line.upper()) # always upper case so equality checks work\\n if not len(seq_collection):\\n # File contained these contigs:\\\\n\\\" + '\\\\n'.join(headers)\\n raise IOError(\\\"Contig not found.\\\" + chromosome_name + \\\" inside \\\" + genome_source)\\n return ''.join(seq_collection)\",\n \"def read_fasta_file(fasta):\\n\\n ptn_list = []\\n fasta_content = open(fasta, \\\"r\\\")\\n new_ptn = None\\n for line in fasta_content:\\n if \\\">sp\\\" in line or \\\">tr\\\" in line:\\n if new_ptn != None:\\n new_ptn[\\\"seq\\\"] = sequence\\n ptn_list.append(new_ptn)\\n tokens = line.split()\\n new_ptn = {\\\"id\\\": tokens[0] }\\n sequence = \\\"\\\"\\n else:\\n sequence += line[:-1]\\n new_ptn[\\\"seq\\\"] = sequence\\n ptn_list.append(new_ptn)\\n\\n return ptn_list\",\n \"def fasta(path):\\n label = None\\n sequence = None\\n with open(path, 'r') as data:\\n for line in data:\\n line = line.strip()\\n if line.startswith('>'):\\n if label and sequence:\\n yield (label, sequence)\\n label = line[1:]\\n sequence = \\\"\\\"\\n else:\\n sequence += line\\n\\n if label and sequence:\\n yield (label, sequence)\",\n \"def read_fasta(amplicon_file, minseqlen):\\n with gzip.open(amplicon_file) as file:\\n sequences = file.readlines()\\n seqs = \\\"\\\"\\n for sequence in sequences:\\n #print(\\\"sequence\\\")\\n seq = sequence.replace(b\\\"\\\\n\\\", b\\\"\\\")\\n seq = seq.decode('utf8')\\n #print(seq)\\n for character in seq:\\n if character not in \\\"TGAC\\\":\\n if len(seqs)>=minseqlen:\\n yield seqs\\n #print(seqs)\\n seq = \\\"\\\"\\n seqs = \\\"\\\"\\n break\\n seqs += seq\\n #print(seqs)\\n yield seqs\",\n \"def protein_name_collector():\\n resL = []\\n with open(\\\"bob/processed/bobprots_down.csv\\\", \\\"r\\\") as inpF:\\n for inpLine in inpF:\\n inpLine = inpLine.split(\\\",\\\")\\n resL.append(inpLine[0].strip(\\\" \\\\n\\\"))\\n return resL\",\n \"def gene_finder(dna):\\n threshold = longest_ORF_noncoding(dna, 1500)\\n l = []\\n for i in find_all_ORFs_both_strands(dna):\\n \\tif len(i)>=threshold:\\n \\t\\tl.append(coding_strand_to_AA(i))\\n print l\\n return l\",\n \"def gene_finder(dna):\\n #use longest_ORF_noncoding to determine what the longest strand of DNA could be in a random sequence\\n threshold = longest_ORF_noncoding(dna,1500)\\n\\n #find all of the orfs on both strand and the generate an empty list\\n all_orfs = find_all_ORFs_both_strands(dna)\\n all_orfs_long = []\\n\\n #this makes a list of strings of dna that are longer than the threshold\\n\\n for i in range (0, len(all_orfs)):\\n if len(all_orfs[i]) > threshold:\\n all_orfs_long.append(all_orfs[i])\\n\\n #this takes each dna string in a list and converts it to an amino acid sequence\\n\\n aa_list = []\\n\\n for i in range (0, len(all_orfs_long)):\\n aa_strand = coding_strand_to_AA(all_orfs_long[i])\\n aa_list.append(aa_strand)\\n\\n #returns strings of amino acids\\n return aa_list\",\n \"def process_all_leading_genes(f_path):\\n with open(f_path, 'r') as f:\\n contents = f.read()\\n parts = contents.strip().split('\\\\t')\\n genes = parts[2:]\\n return genes\",\n \"def get_fasta_identifiers(fasta_handle):\\n fasta_handle.seek(0)\\n current_identifiers = []\\n for line in fasta_handle:\\n if '>' in line:\\n current_id = line.split('>')[1].strip()\\n current_identifiers.append(current_id)\\n return current_identifiers\",\n \"def FASTA_iterator(filename):\\n fasta_file=open(filename, \\\"r\\\")\\n id_fasta=\\\"\\\"\\n seq_fasta=\\\"\\\"\\n\\n for line in fasta_file:\\n if line.startswith(\\\">\\\"):\\n if id_fasta == \\\"\\\":\\n id_fasta=line.strip()\\n continue\\n fasta = id_fasta , seq_fasta\\n yield fasta\\n seq_fasta=\\\"\\\"\\n id_fasta=line.strip()\\n\\n else:\\n seq_fasta += line.strip()\\n\\n if seq_fasta != \\\"\\\":\\n yield id_fasta, seq_fasta\",\n \"def get_names(lines): \\n next = False \\n names = []\\n for line in lines:\\n if next:\\n if len(line) == 1:\\n break\\n else:\\n tmp = line.split()\\n names.append(tmp[1])\\n if line.startswith('Sequences loaded ...'):\\n next = True\\n return names\",\n \"def get_uniprot_gene_info(uniprot_result):\\n gene_lines = [l for l in uniprot_result.split('\\\\n') if l.startswith('GN')]\\n\\n gene_names = []\\n\\n for gn_line in gene_lines:\\n parts = gn_line[2:].split(';')\\n for p in parts:\\n p = p.strip()\\n if p.startswith('Name='):\\n gene_names.append(p[5:])\\n elif p.startswith('Synonyms='):\\n gene_names += [s.strip() for s in p[9:].split(',')]\\n\\n return gene_names\",\n \"def parse_fasta_file(filename):\\n if filename.endswith('.gz'):\\n opener = lambda filename: gzip.open(filename, 'rt')\\n else:\\n opener = lambda filename: open(filename, 'r')\\n\\n with opener(filename) as f:\\n fasta_iter = (it[1] for it in itertools.groupby(f, is_header))\\n for name in fasta_iter:\\n name = name.__next__()[1:].strip()\\n sequences = ''.join(seq.strip() for seq in fasta_iter.__next__())\\n yield name, sequences\",\n \"def readFastaFile(filename):\\n info={}\\n fhr=open(filename,\\\"r\\\")\\n while(True):\\n line=fhr.readline()\\n if not line: break\\n if(\\\">\\\" in line):\\n try:\\n info[line.strip()[1:].split()[0]]=fhr.readline().strip()\\n except ValueError:\\n pass\\n return info\",\n \"def gene_finder(dna):\\n threshold = longest_ORF_noncoding(dna, 1500)\\n list_of_aminos = []\\n list_of_ORFs = find_all_ORFs_both_strands(dna)\\n for an_ORF in list_of_ORFs:\\n if an_ORF > threshold:\\n amino_acid_ORF = coding_strand_to_AA(an_ORF)\\n list_of_aminos.append(amino_acid_ORF)\\n return list_of_aminos\",\n \"def huffman_letter_codes_from_file_contents(file_name):\\r\\n # Suggested strategy...\\r\\n freqs = file_character_frequencies(file_name)\\r\\n return huffman_codes_from_frequencies(freqs)\",\n \"def get_seqs_to_keep_lookup_from_fasta_file(fasta_f):\\r\\n return (\\r\\n set([seq_id.split()[0] for seq_id, seq in parse_fasta(fasta_f)])\\r\\n )\",\n \"def getSequence(ref, fasta):\\n\\n fasta_header = \\\"\\\"\\n\\n fh_fasta = open(fasta, \\\"r\\\")\\n entry = (x[1] for x in groupby(fh_fasta, lambda line: line[0] == \\\">\\\"))\\n\\n for header in entry:\\n headerStr = header.__next__()[1:].strip()\\n\\n seq = \\\"\\\".join(s.strip() for s in entry.__next__())\\n\\n if ref == headerStr.replace('>',''):\\n filename = os.path.join(os.getcwd(), ref.replace('/','_').split('|')[0])\\n fasta_header = replace_char(headerStr)\\n\\n with open(filename + '.fa', \\\"w\\\") as output_file:\\n output_file.write(\\\">\\\" + fasta_header + \\\"\\\\\\\\n\\\" + seq.upper() + \\\"\\\\\\\\n\\\")\\n\\n fh_fasta.close()\\n return fasta_header\",\n \"def read_file(file_name):\\n with open(file_name) as f:\\n content = f.readlines()\\n names = []\\n dnas = []\\n dna = \\\"\\\"\\n name = \\\"\\\"\\n for line in content:\\n line = line.strip()\\n if line[0] == \\\">\\\":\\n names.append(name)\\n dnas.append(dna)\\n name = line[1:]\\n dna = \\\"\\\"\\n else:\\n dna += line\\n names.append(name)\\n dnas.append(dna)\\n\\n return (names[1:], dnas[1:])\",\n \"def ReadFASTA(fastafile):\\n lines = open(fastafile).readlines()\\n headers_seqs = []\\n header = None\\n seq = []\\n for line in lines:\\n if line[0] == '>':\\n if (not header) and (not seq):\\n pass # first sequence in file\\n elif header and not seq:\\n raise ValueError, \\\"Empty sequence for %s\\\" % header\\n elif seq and not header:\\n raise ValueError, \\\"File does not begin with header.\\\"\\n else:\\n seq = ''.join(seq)\\n seq = seq.replace(' ', '')\\n headers_seqs.append((header, seq))\\n header = line.strip()[1 : ]\\n seq = []\\n else:\\n seq.append(line.strip())\\n if (not header) and (not seq):\\n pass # first sequence in file\\n elif header and not seq:\\n raise ValueError, \\\"Empty sequence for %s\\\" % header\\n elif seq and not header:\\n raise ValueError, \\\"File does not begin with header.\\\"\\n else:\\n seq = ''.join(seq)\\n seq = seq.replace(' ', '')\\n headers_seqs.append((header, seq))\\n return headers_seqs\",\n \"def list_of_gene_IDs_and_symbols_from_file(input_seq_file):\\n print(\\\"Find entrezgene IDs for reporter genes in RNAseq run\\\")\\n lines = []\\n with open(input_seq_file, 'U') as input_seq_file:\\n next(input_seq_file)\\n for line in input_seq_file:\\n new_line = line.strip().split('\\\\t')[0]\\n new_line = re.sub('\\\"', '', new_line) # inputs contained quotes\\n lines.append(new_line)\\n\\n query_list = pd.Series(data=lines).tolist()\\n\\n print(\\\"length of query list: \\\", len(query_list))\\n return query_list\",\n \"def fasta(file_path):\\n \\n print(f\\\"Parsing fasta '{file_path}'\\\")\\n data = {\\n 'ur_up_': [], 'accession': [],\\n 'entry_name': [], 'offset': [],\\n 'taxonomy': [], 'sequence': []\\n }\\n\\n with open(file_path, 'r') as f:\\n for i, line in enumerate(f):\\n line = line.strip()\\n \\n if line[0] == '>':\\n key = line[1:]\\n \\n if i == 0:\\n name, offset = key.split(\\\"/\\\")\\n ur_up_, acc = None, None\\n else:\\n ur_up_, acc, name_offset = key.split(\\\"|\\\")\\n name, offset = name_offset.split('/')\\n \\n data['ur_up_'].append(ur_up_)\\n data['accession'].append(acc)\\n data['entry_name'].append(name)\\n data['offset'].append(offset)\\n data['sequence'].append('')\\n data['taxonomy'].append(name.split('_')[1])\\n else:\\n data['sequence'][-1] += line\\n \\n if i and (i % 50000 == 0):\\n print(f\\\"Reached: {i}\\\")\\n\\n return pd.DataFrame(data=data)\",\n \"def Parse_Fasta(filename):\\n dic = {}\\n name = None\\n seq = ''\\n with open(filename) as F:\\n for line in F:\\n if line.startswith('>'):\\n if name is not None:\\n dic[name] = seq\\n seq = ''\\n name = line.strip()\\n else:\\n seq += line\\n if not name in dic:\\n dic[name] = seq\\n return dic\",\n \"def read_drama_names(drama_file):\\n with open(drama_file, 'rb') as f:\\n drama_list = [d.decode('utf-8').strip() for d in f.readlines()]\\n return drama_list\",\n \"def find_GC_content(fasta_file_name):\\n\\twith open(fasta_file_name) as fasta:\\n\\t\\tGC_content = {}\\n\\t\\tfor line in fasta:\\n\\n\\t\\t\\t# Each line (bar the last) ends with '\\\\n'\\n\\t\\t\\tloc_line = line.replace('\\\\n', '')\\n\\n\\t\\t\\t# Finds '>' at opening of line (FASTA seq title)\\n\\t\\t\\tif re.match(r'^>', loc_line):\\n\\t\\t\\t\\tGC_content[loc_line] = 0\\n\\t\\t\\t\\tG_count = 0\\n\\t\\t\\t\\tC_count = 0\\n\\t\\t\\t\\tcount = 0\\n\\t\\t\\t\\tcurrent = loc_line\\n\\t\\t\\telse:\\n\\t\\t\\t\\tG_count += loc_line.count('G')\\n\\t\\t\\t\\tC_count += loc_line.count('C')\\n\\t\\t\\t\\tcount += len(loc_line)\\n\\t\\t\\t\\tGC_content[current] = float((G_count + C_count)) / count\\n\\treturn GC_content\",\n \"def parse_fasta(self, filename):\\n id = ''\\n desc = ''\\n tempseq = []\\n try:\\n seqfile = open(filename,'r')\\n for line in seqfile:\\n if line.startswith('>'):\\n if not id is '':\\n yield { 'id': id.strip(), 'desc': desc.strip(), 'dna': ''.join(tempseq) }\\n if ' ' in line:\\n (id, desc) = line[1::].split(' ', 1)\\n else:\\n id = line[1::].strip()\\n desc = ''\\n tempseq = []\\n elif not line.startswith('>'):\\n tempseq.append(line.rstrip())\\n if not id is '':\\n yield { 'id': id.strip(), 'desc': desc.strip(), 'dna': ''.join(tempseq) }\\n except OSError:\\n raise PathError(''.join(['ERROR: cannot open', refseqpath]))\",\n \"def read_genes(gene_file):\\n genes = []\\n with open(gene_file, 'rU') as genefile:\\n for gene in genefile:\\n gene = gene.strip()\\n genes.append(gene)\\n return(genes)\",\n \"def get_chroms(chromfile):\\n chroms = {}\\n with open(chromfile) as c:\\n for line in c:\\n try:\\n chrom, length = line.strip().split()\\n chroms[chrom] = length\\n except ValueError:\\n chroms[line.strip()] = 1\\n return chroms\",\n \"def read_fasta(filename):\\n with open(filename, \\\"r\\\") as f:\\n s = \\\"\\\"\\n for l in f.readlines()[1:]:\\n s += l.strip()\\n return s\",\n \"def gene_finder(dna):\\n viable_strings = []\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# intitialize empty list (for strings)\\n viable_amino_acids = []\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# intitialize empty list (for amino acids)\\n threshold = longest_ORF_noncoding(dna, 1500)\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# sets threshold to longest random dna string\\n real_dna = list(find_all_ORFs_both_strands(dna))\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# sets real_dna equal to all the ORFs, both strands\\n for i in range(len(real_dna)):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# searches through all the elements in list real_dna\\n \\tif len(real_dna[i]) > len(threshold):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# compares real string to random string\\n \\t\\tviable_strings.append(real_dna[i])\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# if real string is longer, adds it to list\\n for i in range(len(viable_strings)):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# searches through all elements in viable_strings\\n \\ta = coding_strand_to_AA(viable_strings[i])\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# translates each string to amino acid sequence\\n \\tviable_amino_acids.append(a)\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# adds amino acids to list\\n return viable_amino_acids\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# returns list\",\n \"def readTheFile(path, gui):\\n global names\\n global SAMPLES_PARTS\\n file = open(path, 'r')\\n names = file.readline().split()\\n names = names[5:]\\n SAMPLES_PARTS = [0, 0]\\n for name in names:\\n if \\\"Acute\\\" in name:\\n SAMPLES_PARTS[0] += 1\\n elif \\\"Chall\\\" in name:\\n SAMPLES_PARTS[1] += 1\\n SAMPLES_PARTS[1] += SAMPLES_PARTS[0]\\n line = file.readline()\\n data = []\\n counter = 1\\n gui.write_to_output(\\\"\\\\n\\\")\\n while line != '':\\n if counter % 1000 == 0:\\n gui.write_to_output(\\\"Done reading \\\" + str(counter) + \\\" lines\\\\n\\\", overwrite=True)\\n counter += 1\\n columns = line.split()\\n reads = np.array([float(x) for x in columns[5:]])\\n name = columns[0]\\n chrm = columns[1]\\n if chrm == \\\"chrM\\\":\\n line = file.readline()\\n continue\\n start = int(columns[2])\\n end = int(columns[3])\\n if abs(end - start) > 500:\\n line = file.readline()\\n continue\\n strand = columns[4]\\n data.append(Gene(name, reads, np.array([start, end]).astype(np.int), strand, chrm))\\n line = file.readline()\\n gui.write_to_output(\\\"Done reading \\\" + str(counter) + \\\" lines...Now sorting...\\\\n\\\", overwrite=True)\\n return list(sorted(data, key=lambda x: x.getName()))\",\n \"def get_names_from_Seq_db(seq_db):\\r\\n names = []\\r\\n names_abudance_removed = []\\r\\n db = open(seq_db, \\\"r\\\")\\r\\n for seq_record in SeqIO.parse(db, \\\"fasta\\\"):\\r\\n if seq_record.id.endswith(\\\"_1\\\"):\\r\\n names.append(seq_record.id)\\r\\n names_abudance_removed.append((\\\"_\\\").join(\\r\\n seq_record.id.split(\\\"_\\\")[:-1]))\\r\\n else:\\r\\n names_abudance_removed.append(seq_record.id)\\r\\n names.append(seq_record.id + \\\"_1\\\")\\r\\n db.close()\\r\\n return names, names_abudance_removed\",\n \"def get_chromosome_names(bam):\\n\\n # ref_tid = {str(name): int(bam.get_tid(name)) + 1 for name in bam.get_reference_name}\\n\\n ref_tid = {} # 'I' | 0, 'II' | 1, ...\\n for i in range(bam.nreferences): #if bam.nreferences does not work, use range(17) #16 chromosomes and the mitochondrial chromosome\\n ref_name = bam.get_reference_name(i)\\n ref_tid[ref_name] = bam.get_tid(ref_name)\\n\\n return ref_tid\",\n \"def fastaDictionary(inFile, chrName=None):\\n\\n d = {}\\n for (title, seq) in FastaIterator(inFile):\\n title = title.split()[0]\\n if not chrName:\\n d[title] = seq\\n elif chrName == title:\\n d[title] = seq\\n return d\\n\\n if chrName:\\n print \\\"NOT ABLE TO FIND!\\\", chrName\\n return d\",\n \"def get_pokemon_names():\\n with open(POKEMON_FILE, 'r') as fh:\\n pokemon = json.load(fh)\\n return [name.lower() for name in pokemon]\",\n \"def GetGeneName(arg):\\n\\n genbank = ChromUnzip(arg)\\n \\n p1=re.compile(r'(?:ACCESSION\\\\s+)(\\\\w+\\\\d+)')\\n p6=re.compile(r'(?:/gene=\\\")(.+?)(?:\\\"\\\\s+)')\\n\\n gene_name_dict={}\\n \\n for entry in genbank:\\n gene_list=[] \\n gene_it_6=p6.finditer(entry)\\n gene_it_1=p1.finditer(entry) \\n for hit in gene_it_6:\\n gene_list.append(hit.group(1))\\n for item in gene_it_1:\\n gene_name_dict[item.group(1)]=gene_list[0]\\n \\n return gene_name_dict\",\n \"def get_cds_start_end_locations_genbank_file(filename):\\n # Loop over the features\\n genes = defaultdict(list)\\n cds = 0\\n for seq_record in SeqIO.parse(filename, \\\"genbank\\\"):\\n print(f'Dealing with GenBank record {seq_record.id}')\\n for seq_feature in seq_record.features:\\n if seq_feature.type == \\\"CDS\\\" and 'protein_id' in seq_feature.qualifiers:\\n cds += 1\\n prot_id = seq_feature.qualifiers['protein_id'][0]\\n start, end = int(seq_feature.location.start), int(seq_feature.location.end)\\n genes[prot_id] = genes.get(prot_id, []) + [start, end]\\n print(f'There are {cds} CDS and {len(genes)} genes annoted for this genbank record')\\n return genes\",\n \"def read_fasta(src, remove_gaps=False):\\n file_obj = None\\n if isinstance(src, str):\\n try:\\n file_obj = open(src, \\\"r\\\")\\n except IOError:\\n print((\\\"The file `%s` does not exist, exiting gracefully\\\" % src))\\n elif isinstance(src, filetypes):\\n file_obj = src\\n else:\\n raise TypeError('FASTA reader cannot recognize the source of %s, %s, %s' % (src,type(src),isinstance(src, filetypes)))\\n name = None\\n seq_list = list()\\n for line_number, i in enumerate(file_obj):\\n if i.startswith('>'):\\n if name:\\n if remove_gaps:\\n yield name, ''.join(seq_list).replace('-', '')\\n else:\\n yield name, ''.join(seq_list)\\n seq_list = list()\\n name = i[1:].strip()\\n else:\\n #seq = ''.join(i.strip().upper().split())\\n seq = ''.join(i.strip().split())\\n #if not is_sequence_legal(seq):\\n # raise Exception(\\\"Error: illegal characeters in sequence at line %d\\\" % line_number)\\n seq_list.append(seq)\\n if name:\\n if remove_gaps:\\n yield name, ''.join(seq_list).replace('-', '')\\n else:\\n yield name, ''.join(seq_list)\\n if isinstance(src, str):\\n file_obj.close()\",\n \"def gene_finder(dna):\\n threshold = longest_ORF_noncoding(dna, 1500)\\n orfs = find_all_ORFs_both_strands(dna)\\n list1 = []\\n for orf in orfs:\\n if len(orf) > threshold:\\n list1.append(coding_strand_to_AA(orf))\\n return list1\",\n \"def readGenome(filename):\\n\\tgenome = ''\\n\\twith open(filename,'r') as f:\\n\\t\\tfor line in f:\\n\\t\\t\\tif not line[0] == '>':\\n\\t\\t\\t\\tgenome += line.rstrip()\\n\\treturn genome\",\n \"def _getSeqName(header):\\n seqNameList = []\\n unMapped=''\\n for sn in header['sq']:\\n if (sn[0].startswith('GL')) or (sn[0].startswith('chrUn')):\\n unMapped += \\\" %s\\\" % sn[0]\\n else:\\n seqNameList.append(sn[0]) # first column is seqName\\n\\n if unMapped != '': \\n seqNameList.append(unMapped)\\n\\n return seqNameList\",\n \"def parse_fasta(data):\\n name, seq = None, []\\n for line in data:\\n line = line.rstrip()\\n if line.startswith('>'):\\n if name:\\n yield (name, ''.join(seq))\\n name, seq = line, []\\n else:\\n seq.append(line)\\n if name:\\n yield (name, ''.join(seq))\",\n \"def readFastaFile(filename):\",\n \"def getFile(filename):\\n f = open(filename)\\n lines = f.readlines()\\n f.close()\\n names = []\\n names.append(\\\"\\\")\\n for name in lines[0].split(','):\\n \\n names.append(name[1:-1])\\n names = sorted(names)\\n return names\",\n \"def read_fasta(fasta_name):\\n \\n \\\"\\\"\\\"first open the file outside \\\"\\\"\\\"\\n file_handler = open(fasta_name)\\n\\n # ditch the boolean (x[0]) and just keep the header or sequence since\\n # we know they alternate.\\n fasta_iter = (x[1] for x in groupby(file_handler, lambda line: line[0] == \\\">\\\"))\\n\\n for header in fasta_iter:\\n # drop the \\\">\\\"\\n headerStr = header.__next__()[1:].strip()\\n\\n # join all sequence lines to one.\\n seq = \\\"\\\".join(s.strip() for s in fasta_iter.__next__())\\n\\n # yield (headerStr, seq)\\n result_record = {'header':headerStr,'seqRecord':seq}\\n return result_record\",\n \"def get_fasta_labels(input_fasta_fp):\\r\\n\\r\\n fasta_labels = []\\r\\n\\r\\n fasta_f = open(input_fasta_fp, \\\"U\\\")\\r\\n\\r\\n for label, seq in parse_fasta(fasta_f):\\r\\n fasta_labels.append(label.split()[0])\\r\\n\\r\\n return fasta_labels\",\n \"def fasta_read_generator(file_handler):\\r\\n seq = []\\r\\n name = ''\\r\\n for line in file_handler:\\r\\n if line[0] == '>':\\r\\n sequence = ''.join(seq)\\r\\n if name: # only yield when we already have all data for the first sequence\\r\\n yield name, sequence\\r\\n name = line.rstrip()[1:] # omitting the leading >\\r\\n seq = []\\r\\n else:\\r\\n seq += [line]#.rstrip()] # keep line breaks\\r\\n sequence = ''.join(seq)\\r\\n yield name, sequence # don't forget the last sequence\\r\",\n \"def _gene_ann(gene_ann_path):\\n gene_ann = pd.read_csv(gene_ann_path)\\n protein_gene = gene_ann[gene_ann.gene_type ==\\n 'protein_coding'].gene_name.tolist()\\n return(protein_gene)\",\n \"def readfile(filename):\\n infile = open(filename,\\\"r\\\")\\n seq = infile.read()\\n return re.sub('[^acgtACGT]', '', seq).upper()\",\n \"def scan_full_pr(fastafile):\\n n_full=0\\n n=0\\n\\n with open(fastafile, \\\"r\\\") as f:\\n lines=f.readlines()\\n name=\\\"\\\"\\n for line_n in lines:\\n line=line_n.strip()\\n if line[0]==\\\">\\\":\\n name=line.replace(\\\">\\\",\\\"\\\")\\n n+=1\\n else:\\n if line[0]==\\\"M\\\" and line[-1]==\\\"*\\\":\\n n_full+=1\\n sys.stdout.write(str(name)+\\\"\\\\n\\\")\\n\\n return n, n_full\",\n \"def get_surnames(filename):\\n result = []\\n with open(filename, \\\"r\\\") as file:\\n for line in file.readlines():\\n surname = line.split('\\\\t')[1]\\n result.append(surname)\\n return result\",\n \"def get_fasta_sequence_ids(fasta):\\n if not os.path.exists(fasta) or (not os.path.isfile(fasta)):\\n raise FileNotFoundError(fasta)\\n seq_ids = set()\\n with open(fasta, \\\"r\\\") as f:\\n # 'fasta' is https://biopython.org/wiki/SeqIO file type.\\n for record in SeqIO.parse(f, \\\"fasta\\\"):\\n seq_ids.add(record.id)\\n return seq_ids\",\n \"def read_fasta_to_dictionary(genome_file):\\n filename = genome_file\\n dct = {}\\n\\n id_name = \\\"\\\"\\n sequence = \\\"\\\"\\n first_pass = 1\\n\\n read_fh = open(filename, 'r')\\n for i, line in enumerate(read_fh):\\n line = line.rstrip()\\n if re.search(r'^>(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(.*)', line):\\n\\n match_obj = re.search(r'^>(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(\\\\s+)(\\\\S+)(.*)', line)\\n if not first_pass:\\n dct[id_name] = sequence\\n id_name = match_obj.group(1)\\n id_name = re.sub(r',', \\\"\\\", id_name)\\n first_pass = 0\\n sequence = \\\"\\\"\\n\\n elif re.search(r'^>(\\\\S+)(.*)', line):\\n\\n match_obj = re.search(r'^>(\\\\S+)(.*)', line)\\n if not first_pass:\\n dct[id_name] = sequence\\n id_name = match_obj.group(1)\\n id_name = re.sub(r'(\\\\d+)_', \\\"\\\", id_name)\\n id_name = re.sub(r'.*\\\\|', \\\"\\\", id_name)\\n first_pass = 0\\n sequence = \\\"\\\"\\n else:\\n sequence += line\\n dct[id_name] = sequence\\n\\n return dct\",\n \"def process_fasta(file, type):\\n seqs = []\\n with open(file) as f:\\n seq = f.readline().strip()\\n seq = seq + '\\\\t'\\n for line in f:\\n line = line.strip()\\n if line[0] == \\\">\\\":\\n s1 = seq.split('\\\\t')\\n bac = s1[0].split(\\\"|\\\")[2]\\n sequence = to_word_index(s1[1], type)\\n seqs.append([bac, sequence])\\n seq = line + '\\\\t'\\n else:\\n seq = seq + line\\n\\n s1 = seq.split('\\\\t')\\n bac = s1[0].split(\\\"|\\\")[2]\\n sequence = to_word_index(s1[1], type)\\n seqs.append([bac, sequence])\\n\\n df = pd.DataFrame(seqs, columns=['bacteria', 'sequence'])\\n df = shuffle(df)\\n\\n return df\",\n \"def fasta_path_to_seqs(fasta_path, codon_table=False, codon_alphabet=False):\\n seqs = []\\n for record in SeqIO.parse(fasta_path, \\\"fasta\\\"):\\n seqs.append(record)\\n return seqs\",\n \"def print_file(chr_list,filename):\\n infile = open(filename)\\n for line in infile:\\n if line.startswith('SL2.40'):\\n chr = int(line.strip().split()[0][-2:])\\n loci = int(line.strip().split()[1])\\n for chr_i,chr_l in enumerate(chr_list):\\n for loc in chr_l:\\n if chr==chr_i and loci==loc:\\n print line\\n return\",\n \"def FASTA_iterator (fasta_filename):\\n file=open(fasta_filename,\\\"r\\\")\\n seq=''\\n for line in file:\\n if line[0]==\\\">\\\":\\n if seq != \\\"\\\":\\n yield (lastid,seq)\\n seq=''\\n lastid=line.rstrip()[1:]\\n else:\\n lastid=line.rstrip()[1:]\\n else:\\n seq += line.rstrip()\\n if seq != \\\"\\\":\\n yield (lastid,seq)\",\n \"def genes():\\n return [\\\"b2935\\\", \\\"b0723\\\", \\\"b0451\\\"]\",\n \"def read_names_list(file_path):\\r\\n\\tnames_list = []\\r\\n\\twith open(file_path) as file:\\r\\n\\t for line in file:\\r\\n\\t cline = line.rstrip().split()\\r\\n\\t #row_id = cline[0]\\r\\n\\t row_name = cline[1:]\\r\\n\\t #names_list.append((row_id, \\\" \\\".join(row_name)))\\r\\n\\t names_list.append(\\\" \\\".join(row_name))\\r\\n\\treturn names_list\",\n \"def read_faidx(filename, filter_strs):\\n if not filename.endswith('.fai'):\\n # Try to find fai file.\\n fai_candidates = [filename + '.fai',\\n filename.rstrip('.fa') + '.fai',\\n filename.rstrip('.gz') + '.fai']\\n try:\\n faidx_file = [os.path.isfile(c)\\n for c in fai_candidates].index(True)\\n faidx_file = fai_candidates[faidx_file]\\n except ValueError:\\n raise IOError('Could not find valid faidx for [%s]i\\\\n' % filename)\\n else:\\n faidx_file = filename\\n\\n try:\\n chroms = {}\\n with open(faidx_file) as faidx:\\n for record in faidx:\\n col = record.strip().split()\\n name, length = col[0], int(col[1])\\n if not any([ignore in name for ignore in filter_strs]):\\n chroms[name] = length\\n return chroms\\n except Exception:\\n print('Could not read faidx file [%s]' % faidx_file)\\n raise\",\n \"def load_fasta_sequences(fasta_file, return_keys=False):\\n fasta = Fasta(fasta_file, as_raw=True, sequence_always_upper=True)\\n seqs = [seq[:] for seq in fasta]\\n if return_keys:\\n keys = list(fasta.keys())\\n fasta.close()\\n if return_keys:\\n return seqs, keys\\n return seqs\",\n \"def get_population_names (f,a,s):\\r\\n ## a, s not used but needed for function to match general function format\\r\\n global gv\\r\\n aa = f.readline().strip()\\r\\n popnamelist = []\\r\\n i = 0\\r\\n foundghost = False\\r\\n while aa.find(\\\"Population\\\") >= 0:\\r\\n popname = aa.split()[3]\\r\\n if popname.upper() == \\\"GHOST\\\":\\r\\n foundghost = True\\r\\n popnamelist.append(popname)\\r\\n i += 1\\r\\n aa = f.readline().strip()\\r\\n if gv[\\\"useghost\\\"] == True and foundghost == False: # for compatibility with older output files\\r\\n popnamelist.append('ghost')\\r\\n anames = []\\r\\n if gv[\\\"usealtnames\\\"]:\\r\\n for line in open(gv[\\\"altnamefilename\\\"],\\\"r\\\"):\\r\\n temp = line.strip()\\r\\n if len(temp) > 0:\\r\\n anames.append(temp)\\r\\n anames = anames[0:len(popnamelist)]\\r\\n gv[\\\"altpopnames\\\"] = list(anames)\\r\\n return popnamelist\",\n \"def gene_finder(dna, threshold):\\n \\n List_of_dna=find_all_ORFs_both_strands(dna)\\n aa_list=[]\\n for string in List_of_dna:\\n if len(string)< threshold:\\n continue\\n else:\\n aa_list.append(coding_strand_to_AA(string))\\n return aa_list\",\n \"def parse_dna(file_handle):\\n sequence = []\\n for line in file_handle:\\n words = line.split()\\n seq_string = \\\"\\\".join(words[:-1])\\n seq_list = list(seq_string)\\n sequence.extend(seq_list)\\n return sequence\",\n \"def read_fasta(sequence_file :str):\\n\\n #for gziped files:\\n\\n if sequence_file.endswith(\\\".gz\\\"):\\n with gzip.open(sequence_file, \\\"rt\\\") as file:\\n seqDict = SeqIO.to_dict(SeqIO.parse(file, 'fasta'))\\n ident = ident.split(\\\"|\\\")[1]\\n return seqDict\\n\\n # for no gziped fasta files:\\n else:\\n seqRecord = SeqIO.read(sequence_file, \\\"fasta\\\")\\n sequence = seqRecord.seq\\n ident = seqRecord.id\\n ident = ident.split(\\\"|\\\")[1]\\n return ident, sequence\",\n \"def collect_names(files):\\n names = set()\\n routes = defaultdict(dict)\\n for file in files:\\n gene_name = file.split('/')[-1].split('.')[0]\\n for record in SeqIO.parse(file, 'fasta'):\\n if record.name.count('_') >= 3:\\n name = record.name.split('_')[0]\\n route = record.name.split('_')[2]\\n routes[gene_name][name] = route\\n elif '_' in record.name:\\n name = record.name.split('_')[0]\\n else:\\n name = record.name\\n names.add(name)\\n return sorted(list(names)), routes\",\n \"def available_samples(vcf_path):\\n return _header_from_vcf(vcf_path)[9:]\",\n \"def iter_protenn_matches(file: str):\\n with open(file, \\\"rt\\\") as fh:\\n for line in fh:\\n sequence_id, pfam_acc, start, end = line.rstrip().split(\\\"\\\\t\\\")\\n if re.fullmatch(r\\\"PF\\\\d+\\\", pfam_acc):\\n yield sequence_id, pfam_acc, int(start), int(end)\",\n \"def read_screen_names(filename):\\n flist = []\\n f = open('candidates.txt')\\n for line in f:\\n \\tflist.append(line.strip('\\\\n'))\\t\\n return flist\",\n \"def names(self) -> list[str]:\",\n \"def get_sequence_from_fasta(fasta_file):\\n\\n if not fasta_file:\\n raise ValueError(\\\"Path cannot be empty.\\\")\\n\\n handle = open(fasta_file, 'r')\\n try:\\n sequence = handle.readlines()\\n finally:\\n handle.close()\\n\\n sequence = [line.strip() for line in sequence if not '>' in line]\\n sequence = ''.join(sequence)\\n\\n return sequence\",\n \"def fix_seqname(sname):\\r\\n # protid is on each line of the FASTA file; splitting doesn't really do anything\\r\\n # protid = sname.split(' ')\\r\\n # TK 2020-07-22\\r\\n # Dictionary for filenames so that we know which CDS file to query for each\\r\\n # protein ID.\\r\\n lookups = {\\r\\n 'AET' : 'Aegilops_tauschii.Aet_v4.0.cds.all.fa',\\r\\n\\t'PNS' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\\r\\n\\t'PNT' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\\r\\n\\t'KQJ' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\\r\\n\\t'KQK' : 'Brachypodium_distachyon.Brachypodium_distachyon_v3.0.cds.all.fa',\\r\\n\\t'Dr' : 'Dioscorea_rotundata.TDr96_F1_Pseudo_Chromosome_v1.0.cds.all.fa',\\r\\n\\t'Et' : 'Eragrostis_tef.ASM97063v1.cds.all.fa',\\r\\n\\t'HORVU' : 'Hordeum_vulgare.IBSC_v2.cds.all.fa',\\r\\n\\t'LPERR' : 'Leersia_perrieri.Lperr_V1.4.cds.all.fa',\\r\\n\\t'GSMUA' : 'Musa_acuminata.ASM31385v1.cds.all.fa',\\r\\n\\t'OBART' : 'Oryza_barthii.O.barthii_v1.cds.all.fa',\\r\\n\\t'ORGLA' : 'Oryza_glaberrima.Oryza_glaberrima_V1.cds.all.fa',\\r\\n\\t'ONIVA': 'Oryza_nivara.Oryza_nivara_v1.0.cds.all.fa',\\r\\n\\t'ORUFI' : 'Oryza_rufipogon.OR_W1943.cds.all.fa',\\r\\n\\t'PVH' : 'Panicum_hallii_fil2.PHallii_v3.1.cds.all.fa',\\r\\n\\t'Sspon' : 'Saccharum_spontaneum.Sspon.HiC_chr_asm.cds.all.fa',\\r\\n\\t'KQL' : 'Setaria_italica.Setaria_italica_v2.0.cds.all.fa',\\r\\n\\t'TraesCS' : 'Triticum_aestivum.IWGSC.cds.all.fa',\\r\\n\\t'Zm' : 'Zea_mays.B73_RefGen_v4.cds.all.fa',\\r\\n\\t'Zlat': 'Zlat_V1.cds.fa',\\r\\n 'FUN': 'rice.transcripts.fa',\\r\\n 'Os': 'Oryza_sativa.IRGSP-1.0.cds.all.fa'\\r\\n }\\r\\n # Get the filename based on what the sequence starts with.\\r\\n for id_start, cds_file in lookups.items():\\r\\n if sname.startswith(id_start):\\r\\n target_file = cds_file\\r\\n break\\r\\n # Return the protein name and CDS target file as a tuple\\r\\n return (target_file, sname)\\r\\n\\r\\n # Make a lookup table to get the species name based on the protein ID.\\r\\n # lookups = [('Zlat*','Zizania_latifolia'),('FUN*','Zizania_palustris'),('Os*','Oryza_sativa')]\\r\\n # Initialize an empty species dictionary to assist in connecting protid (gene name) to species name\\r\\n # species_dict = {}\\r\\n # # This for loop will populate the species dictionary so that we can get species name keyed on the protid (gene name)\\r\\n # for i in protid:\\r\\n # species = lookup(i, lookups)\\r\\n # return species.encode, i\\r\\n # species_dict[protid] = species.encode()\\r\\n # return None\\r\",\n \"def parse_FASTA(file):\\r\\n\\tstate = 0\\r\\n\\tdna_list = []\\r\\n\\tfor line in file:\\r\\n\\t\\tline = line.strip()\\r\\n\\t\\tif state == 0:\\r\\n\\t\\t\\tif line[0] == '>':\\r\\n\\t\\t\\t\\tadd_new_DNA(dna_list, line)\\r\\n\\t\\t\\t\\tstate = 1\\r\\n\\t\\t\\telif line == '':\\r\\n\\t\\t\\t\\tcontinue\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\traise Exception()\\r\\n\\t\\telif state == 1:\\r\\n\\t\\t\\tadd_line_to_DNA(dna_list[-1], line)\\r\\n\\t\\t\\tstate = 2\\r\\n\\t\\telif state == 2:\\r\\n\\t\\t\\tif line[0] == '>':\\r\\n\\t\\t\\t\\tadd_new_DNA(dna_list, line)\\r\\n\\t\\t\\t\\tstate = 1\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tadd_line_to_DNA(dna_list[-1], line)\\r\\n\\t\\telse:\\r\\n\\t\\t\\traise Exception()\\r\\n\\tfile.seek(0)\\r\\n\\treturn dna_list\",\n \"def readFile(fileName):\\n\\tf = open(fileName, 'r')\\n\\tnames = map(lambda s: s[1:-1], f.read().split(','))\\n\\tnames.sort()\\n\\treturn names\",\n \"def read_chr(fpath):\\n\\t# init dict and indices\\n\\tchrom_dicts={}\\n\\tstart=0\\n\\tindex=0\\n\\n\\t# iterate through chromosome scores \\n\\tfor line in fileinput.input(fpath):\\n\\t\\tx=line.split()\\n\\t\\t\\n\\t\\t# if chromosome skips some region, then normalize the previous window (<100 bp) and init new window \\t\\n\\t\\tif len(x)==4:\\n\\t\\t\\tif start in chrom_dicts:\\n\\t\\t\\t\\tchrom_dicts[start]/=index\\n\\t\\t\\tstart=int(x[2].split(\\\"=\\\")[1])\\n\\t\\t\\tchrom_dicts[start]=0\\n\\t\\t\\tindex=0\\n\\n\\t\\t# if not a black region, then make news windows every 100 locations\\n\\t\\tif len(x)==1:\\n\\t\\t\\tchrom_dicts[start]+=float(x[0])\\n\\t\\t\\tif index==100:\\n\\t\\t\\t\\tchrom_dicts[start]/=index\\n\\t\\t\\t\\tindex=0\\n\\t\\t\\t\\tstart+=100\\n\\t\\t\\t\\tchrom_dicts[start]=0\\n\\t\\t\\tindex+=1\\n\\t\\n\\t# track chromosomes that have been binned\\n\\tprint(\\\"%s %d\\\" % (fpath,len(chrom_dicts)))\\n\\treturn(chrom_dicts)\",\n \"def GenomeReader(GenomeFile):\\n GenomeScaffolds = {}\\n key = []\\n with open(GenomeFile, 'r') as f:\\n for line in f:\\n line = line.strip()\\n if line.startswith(\\\">\\\"):\\n NamedSeq = line.replace('>', '')\\n key.append(NamedSeq)\\n GenomeScaffolds[NamedSeq] = \\\"\\\"\\n else:\\n GenomeScaffolds[NamedSeq] += line\\n return GenomeScaffolds # Returns a Dictionary object\",\n \"def read_fasta(amplicon_file, minseqlen):\\n if amplicon_file.endswith(\\\"gz\\\"): \\n with gzip.open(amplicon_file, \\\"rb\\\") as gz:\\n seq = b\\\"\\\"\\n for line in gz:\\n if line.startswith(b\\\">\\\"):\\n if len(seq) >= minseqlen:\\n yield seq.decode('ascii')\\n seq = b\\\"\\\"\\n else:\\n seq += line.strip()\\n yield seq\\n\\n elif amplicon_file.endswith(\\\"fasta\\\"):\\n with open(amplicon_file, \\\"r\\\") as fasta:\\n seq = \\\"\\\"\\n for line in fasta:\\n if line.startswith('>'):\\n if len(seq) >= minseqlen:\\n yield seq\\n seq =\\\"\\\"\\n \\n else:\\n seq = seq + line[:-1]\\n if len(seq) >= minseqlen:\\n yield seq\",\n \"def protein_from_orfs(dna):\\n rna = dna.replace(\\\"T\\\", \\\"U\\\")\\n reverse_complement_rna = complement_strand(dna).replace(\\\"T\\\", \\\"U\\\")\\n\\n candidate_proteins = set()\\n\\n for strand in [rna, reverse_complement_rna]:\\n for index in [m.start() for m in re.finditer('AUG', strand)]:\\n codons_list = codons(strand[index:])\\n protein = \\\"\\\"\\n\\n if any(rna_codon_dict[codon] == \\\"Stop\\\" for codon in codons_list):\\n for codon in codons_list:\\n symbol = rna_codon_dict[codon]\\n\\n if symbol != \\\"Stop\\\":\\n protein += symbol\\n else:\\n candidate_proteins.add(protein)\\n break\\n\\n return candidate_proteins\",\n \"def fasta_parser(filename):\\n fasta = {}\\n with open(filename) as f:\\n contents = f.read()[1:].split('\\\\n>')\\n for section in contents:\\n sample = section.split('\\\\n')\\n sample_id = sample[0]\\n seq = ''.join(sample[1:]).strip()\\n fasta[sample_id] = seq\\n return fasta\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6546648","0.64621747","0.63865525","0.63529944","0.63245755","0.63238037","0.6276679","0.6252582","0.62015104","0.6200787","0.6186508","0.6152302","0.6124569","0.60324305","0.60317713","0.60203993","0.60121757","0.6001881","0.60012823","0.59866214","0.59445727","0.5939449","0.59315443","0.5913733","0.59018314","0.5899237","0.58927226","0.58738494","0.5871942","0.5865627","0.5864292","0.58608663","0.58428377","0.58387595","0.58200175","0.5803017","0.5800004","0.5795172","0.5784118","0.5774436","0.5767786","0.57621086","0.57551914","0.57550734","0.573837","0.57379025","0.57343125","0.5718479","0.5703688","0.57025295","0.57008964","0.5688657","0.5676221","0.56747776","0.5673884","0.5672079","0.5669437","0.56675744","0.56605196","0.5658471","0.5651157","0.56437916","0.5643541","0.5642325","0.5637875","0.562893","0.5626493","0.56263405","0.5624273","0.5623922","0.5621494","0.56157106","0.56041706","0.5603895","0.5591852","0.558656","0.5583267","0.5574478","0.5573734","0.5571349","0.5559709","0.5558329","0.5556931","0.5556213","0.554911","0.554103","0.5538864","0.553581","0.5527858","0.5527031","0.5526976","0.5521385","0.5519206","0.5514586","0.55118763","0.5503021","0.5495705","0.5489219","0.54865396","0.5486401"],"string":"[\n \"0.6546648\",\n \"0.64621747\",\n \"0.63865525\",\n \"0.63529944\",\n \"0.63245755\",\n \"0.63238037\",\n \"0.6276679\",\n \"0.6252582\",\n \"0.62015104\",\n \"0.6200787\",\n \"0.6186508\",\n \"0.6152302\",\n \"0.6124569\",\n \"0.60324305\",\n \"0.60317713\",\n \"0.60203993\",\n \"0.60121757\",\n \"0.6001881\",\n \"0.60012823\",\n \"0.59866214\",\n \"0.59445727\",\n \"0.5939449\",\n \"0.59315443\",\n \"0.5913733\",\n \"0.59018314\",\n \"0.5899237\",\n \"0.58927226\",\n \"0.58738494\",\n \"0.5871942\",\n \"0.5865627\",\n \"0.5864292\",\n \"0.58608663\",\n \"0.58428377\",\n \"0.58387595\",\n \"0.58200175\",\n \"0.5803017\",\n \"0.5800004\",\n \"0.5795172\",\n \"0.5784118\",\n \"0.5774436\",\n \"0.5767786\",\n \"0.57621086\",\n \"0.57551914\",\n \"0.57550734\",\n \"0.573837\",\n \"0.57379025\",\n \"0.57343125\",\n \"0.5718479\",\n \"0.5703688\",\n \"0.57025295\",\n \"0.57008964\",\n \"0.5688657\",\n \"0.5676221\",\n \"0.56747776\",\n \"0.5673884\",\n \"0.5672079\",\n \"0.5669437\",\n \"0.56675744\",\n \"0.56605196\",\n \"0.5658471\",\n \"0.5651157\",\n \"0.56437916\",\n \"0.5643541\",\n \"0.5642325\",\n \"0.5637875\",\n \"0.562893\",\n \"0.5626493\",\n \"0.56263405\",\n \"0.5624273\",\n \"0.5623922\",\n \"0.5621494\",\n \"0.56157106\",\n \"0.56041706\",\n \"0.5603895\",\n \"0.5591852\",\n \"0.558656\",\n \"0.5583267\",\n \"0.5574478\",\n \"0.5573734\",\n \"0.5571349\",\n \"0.5559709\",\n \"0.5558329\",\n \"0.5556931\",\n \"0.5556213\",\n \"0.554911\",\n \"0.554103\",\n \"0.5538864\",\n \"0.553581\",\n \"0.5527858\",\n \"0.5527031\",\n \"0.5526976\",\n \"0.5521385\",\n \"0.5519206\",\n \"0.5514586\",\n \"0.55118763\",\n \"0.5503021\",\n \"0.5495705\",\n \"0.5489219\",\n \"0.54865396\",\n \"0.5486401\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79199076"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90599,"cells":{"query":{"kind":"string","value":"Get the chromosome sizes for a fasta file"},"document":{"kind":"string","value":"def _chrom_sizes(fasta_file):\n from pysam import FastaFile\n fa = FastaFile(fasta_file)\n chrom_lens = OrderedDict([(name, l) for name, l in zip(fa.references, fa.lengths)])\n if len(chrom_lens) == 0:\n raise ValueError(f\"no chromosomes found in fasta file: {fasta_file}. \"\n \"Make sure the file path is correct and that the fasta index \"\n \"file {fasta_file}.fai is up to date\")\n fa.close()\n return chrom_lens"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def expected_readlen(bedfile, bedHeader, annoList):\n\n #chromosomes from project bed\n with open(bedfile, 'r') as f:\n if bedHeader=='yes':\n chroms = [key for key in dict(Counter([line.split('\\t')[0] for il, line in enumerate(f) if il>0])).keys()]\n else:\n chroms = [key for key in dict(Counter([line.split('\\t')[0] for il, line in enumerate(f)])).keys()]\n\n #dictionaries: keys are chrom and values are lists with start/end positions\n ampStarts = {}; ampEnds = {}\n for chrom in chroms:\n ampStarts[chrom] = []\n ampEnds[chrom] = []\n\n with open(bedfile, 'r') as f:\n if bedHeader=='yes':\n next(f)\n for line in f:\n ampStarts[line.split('\\t')[0]].append(int(line.split('\\t')[1]))\n\n with open(bedfile, 'r') as f:\n if bedHeader=='yes':\n next(f) \n for line in f:\n ampEnds[line.split('\\t')[0]].append(int(line.split('\\t')[2]))\n\n \n exp_readlength = []\n of = open('expected_readlen.txt','w')\n for v in annoList:\n chrom = v.split('\\t')[0]\n start = v.split('\\t')[1]\n nVarAmp = 0\n amplength = []\n #no. of amplicons spanning the chromosome\n namp = len(ampStarts.get(chrom))\n for ia in range(0,namp):\n #no. of amplicons that span the variant\n if (int(start) >= int(ampStarts.get(chrom)[ia])) and (int(start) <= int(ampEnds.get(chrom)[ia])):\n nVarAmp += 1\n amplength.append(int(ampEnds.get(chrom)[ia]) - int(ampStarts.get(chrom)[ia]) + 1)\n # if amplicon start is greater than variant pos, go to next variant\n if int(start) < int(ampStarts.get(chrom)[ia]):\n break\n exp_readlength.append(np.mean(amplength))\n\n of.write(str(np.mean(amplength)) + '\\n')\n \n of.close()\n \n return exp_readlength\n\n\n ## save the chrom#, begin, end of amplicons from the project bed file\n #with open(bedfile,'r') as bf:\n # bedpos = [line.split('\\t')[:3] for line in bf if 'chr' in line.split('\\t')[0]]\n #\n ## iterate through the variants\n #exp_readlen = []\n #for idx, var in enumerate(annoList):\n # varchrom = var.split('\\t')[0]\n # varpos = var.split('\\t')[1]\n # namp = 0\n # amplen = []\n\n # # iterate through the amplicons\n # for amp in bedpos:\n # ampchrom = amp[0]\n # ampstart = amp[1]\n # ampend = amp[2]\n\n # # find the amplicons that belong to the chrom and pos of the variant\n # if (varchrom == ampchrom) and \\\n # (int(varpos) >= int(ampstart) and int(varpos) <= int(ampend)):\n # amplen.append(int(ampend) - int(ampstart) + 1)\n # namp += 1\n # # if amplicon start is greater than variant pos in same chrom, go to next variant\n # if (varchrom == ampchrom) and (int(varpos) < int(ampstart)):\n # break\n # # if amplicon/s found and chrom is different, go to next variant\n # if (varchrom != ampchrom) and (namp > 0):\n # break\n # \n # #print varchrom, varpos, namp \n # exp_readlen.append(np.mean(amplen))","def chromosome_sizes(probes, to_mb=False):\n chrom_sizes = collections.OrderedDict()\n for chrom, rows in probes.by_chromosome():\n chrom_sizes[chrom] = rows[\"end\"].max()\n if to_mb:\n chrom_sizes[chrom] *= MB\n return chrom_sizes","def get_chromosome_length(genome):\n \n chr_list = {}\n \n for key in genome:\n chr_list[key] = len(genome[key])\n\n return chr_list","def get_counts(filename, alphabet, kmin, kmax):\n # get the list of kmers to count with length between kmin and kmax\n kmers_list = get_all_possible_kmers(alphabet, kmin, kmax)\n # initialyze the counter with all possible kmer with length\n # between kmin and kmax with zero counts\n counter = Counter(dict([(km, 0) for km in kmers_list]))\n # open and read in the kmers/string in the file\n with gzip.open(filename, 'rt') as fh:\n # iterates through the strings\n for line in fh:\n # make the adjustments int the strings\n kmer = line.replace('\\n', '')\n # check if kmer/string is in the counter\n if kmer in counter:\n # if kmer is in add 1 other wise keep the zero count\n counter[kmer] += 1\n return counter","def get_gsize(self):\n gsize_file = Genome(self.genome).get_fasize()\n gsize = 0\n with open(gsize_file, 'rt') as fi:\n for a in fi:\n c, n = a.strip().split('\\t')\n gsize += int(n)\n return gsize","def get_array_size():\n tg_file = 'NA_CAS_gauges.txt'\n lines = open(tg_file).readlines()\n tg_nbr = len(lines)\n return tg_nbr","def test_count_genomic_region_sizes(self):\n \n regions = OrderedDict()\n regions[\"exons\"] = \"Exon\"\n regions[\"utr3\"] = \"3' UTR\"\n regions[\"utr5\"] = \"5' UTR\"\n regions[\"proxintron500\"] = \"Proximal\\nIntron\"\n regions[\"distintron500\"] = \"Distal\\nIntron\"\n results = count_genomic_region_sizes(os.path.join(clipper.test_dir(), \"regions\"), regions, \"mm9\")","def chromsizes(genome):\n try:\n return getattr(genome_registry, genome)\n except AttributeError:\n return get_chromsizes_from_ucsc(genome)","def count_seqs_from_file(fasta_file, parser=parse_fasta):\r\n result = 0\r\n lens = []\r\n for record in parser(fasta_file):\r\n result += 1\r\n lens.append(len(record[1]))\r\n if result == 0:\r\n return result, None, None\r\n else:\r\n return result, mean(lens), std(lens)","def full_chromosomes(reader):\n for line in reader.header.get_lines(\"contig\"):\n if line.id in CHROMS:\n name = line.id\n length = line.length or 1_000_000_000\n yield \"{}:{}-{}\".format(name, 1, length)","def countgenes():\n directory = openfile('db_directory.txt')\n no_genes_file = directory+'GENES_IN_HPO.txt'\n GENES_IN_HPO = openfile(no_genes_file)\n #GENES_IN_HPO = openfile(numbergenes_file)\n return int(GENES_IN_HPO)","def lengths(self):\n\t\toutput_file = csv.writer(open('contigLengths.csv', 'wb'))\n\t\tfor i,x in enumerate(self.contigsInfo.keys()):\n\t\t\tseq = self.contigsInfo[x]\n\t\t\tl = len(seq)\n\t\t\toutput_file.writerow([i,l])","def count_sizes(fastq_file, amplicon, guide_rna, window=20, anchor_length=10):\n editing_position = amplicon.index(guide_rna)\n\n guide_plus_window = (editing_position - window, editing_position + len(guide_rna) + window)\n\n left_anchor_start = guide_plus_window[0] - anchor_length\n right_anchor_end = guide_plus_window[1] + anchor_length\n\n left_anchor_end = left_anchor_start + anchor_length\n right_anchor_start = right_anchor_end - anchor_length\n\n a = amplicon[left_anchor_start: left_anchor_end]\n b = amplicon[right_anchor_start: right_anchor_end]\n\n pattern = a + \".*\" + b\n\n window_size = (right_anchor_end - left_anchor_start) + 1\n\n os.system(\"zcat {} | grep -o {} > counts\".format(fastq_file, pattern))\n\n with open(\"counts\", 'r') as handle:\n lines = handle.readlines()\n\n # return difference between window size and read length\n return Counter([len(x) - window_size for x in lines])","def bpCount(file):\n amount_bp = len(file)\n return amount_bp","def get_chroms(chromfile):\n chroms = {}\n with open(chromfile) as c:\n for line in c:\n try:\n chrom, length = line.strip().split()\n chroms[chrom] = length\n except ValueError:\n chroms[line.strip()] = 1\n return chroms","def get_library_sizes(args):\n with open(args.counts, \"r\") as counts:\n sizes = []\n head = True\n for line in counts:\n line = line.strip()\n if head:\n head = False\n samples = line.split(\"\\t\")[3:]\n total_counts = [0] * len(samples)\n else:\n counts = line.split(\"\\t\")\n if counts[1] == \"NA\":\n break\n else:\n counts = counts[3:]\n for i in range(len(counts)):\n total_counts[i] += int(counts[i])\n\n for i in range(len(samples)):\n sizes.append([samples[i], total_counts[i]])\n\n return sizes","def countCharacters(file_name, start, end):\r\n\r\n with open(file_name, \"r\") as file:\r\n counter_chars = 0\r\n\r\n for line in islice(file, start, end):\r\n counter_chars += len(line)\r\n\r\n return counter_chars","def chromosome_lengths(self):\n chr_lens = {}\n for r in self.regions(lazy=True):\n if chr_lens.get(r.chromosome) is None:\n chr_lens[r.chromosome] = r.end\n continue\n if r.end > chr_lens[r.chromosome]:\n chr_lens[r.chromosome] = r.end\n return chr_lens","def max_min_kmer_sizes(filename):\n try:\n fh = gzip.open if isgzip(filename) else open\n with fh(filename, 'rt') as f:\n kmer_sizes = np.array([len(rec.split()[0]) for rec in f])\n\n return kmer_sizes.min(), kmer_sizes.max()\n\n except Exception:\n print('Not able to read file [%s]\\n' % filename)\n raise","def count_seqs(fasta_filepath, parser=parse_fasta):\r\n # Open the file and pass it to py_count_seqs_from_file -- wrapping\r\n # this makes for easier unit testing\r\n return count_seqs_from_file(open(fasta_filepath, 'U'), parser=parser)","def getLen(alignment):\n AlignmentLength = 0\n with open(alignment,'rU') as F:\n F.readline()\n while True:\n Data = F.readline().strip()\n if Data[0] != '>':\n AlignmentLength += len(Data)\n else:\n return AlignmentLength","def feature_total_lengths(genefile, ignore_multiple_splice_variants=False, genome_fasta_file=DEFAULT_NUCLEAR_GENOME_FILE):\n # BCBio uses 0-based and end-exclusive positions (first-third base is bases 0,1,2, i.e range 0-3), so length is straightforward\n feature_total_lengths = defaultdict(int)\n total_genome_length = 0\n # get the total chromosome lengths from genome_fasta_file if given - needed to calculate total intergenic length \n if genome_fasta_file:\n with open(genome_fasta_file) as FASTAFILE: fasta_seq_dict = SeqIO.to_dict(SeqIO.parse(FASTAFILE, \"fasta\"))\n else: fasta_seq_dict = {}\n with open(os.path.expanduser(genefile)) as GENEFILE:\n for chromosome_record in GFF.parse(GENEFILE, base_dict=fasta_seq_dict):\n total_genome_length += len(chromosome_record.seq)\n for gene_record in chromosome_record.features:\n gene_length = gene_record.location.end.position - gene_record.location.start.position\n feature_total_lengths['gene'] += gene_length\n if len(gene_record.sub_features) == 0:\n raise NoRNAError(\"Gene %s has no RNA - can't determine CDS start/end!\"%gene_record.id)\n if len(gene_record.sub_features) > 1:\n if ignore_multiple_splice_variants: \n feature_total_lengths['MULTIPLE_SPLICE_VARIANTS'] += gene_length\n continue\n else: \n raise MultipleRNAError(\"Gene %s has multiple RNAs - can't determine single CDS start/end!\"%gene_record.id)\n else:\n features = gene_record.sub_features[0].sub_features\n for feature in features:\n feature_total_lengths[feature.type] += (feature.location.end.position - feature.location.start.position)\n # calculate total intron length from total gene and exon/UTR length\n feature_total_lengths['intron'] = feature_total_lengths['gene'] - sum(length for feature,length \n in feature_total_lengths.items() if feature != 'gene')\n # calculate total intergenic length from total genome and gene length\n feature_total_lengths['all'] = total_genome_length\n feature_total_lengths['intergenic'] = total_genome_length - feature_total_lengths['gene']\n return dict(feature_total_lengths)","def reads_in_chromosome(self, chromosome):\n return sum(m.read_info(self.dataset_name).total_read_count \n for m in self.dataset if m.position not in SPECIAL_POSITIONS.all_undefined and m.position.chromosome==chromosome)","def size(path):","def get_regions_counts(fname, seglen, mincounts):\n counts = defaultdict(int)\n seglen=int(seglen)\n with open(fname) as fin:\n infile = csv.DictReader(fin, delimiter='\\t')\n for line in infile:\n if int(line['interactions']) < mincounts:\n continue\n t_reg = (\n line['RNA1 chromosome'],int(int(line['Start of RNA1 first read'])/seglen)*seglen,\n line['RNA1 strand'], \n line['RNA2 chromosome'],int(int(line['Start of RNA2 last read'])/seglen)*seglen,\n line['RNA2 strand'])\n\n counts[t_reg] = int(line['interactions'])\n return counts","def get_num_chunks(self) -> int:","def scan_full_pr(fastafile):\n n_full=0\n n=0\n\n with open(fastafile, \"r\") as f:\n lines=f.readlines()\n name=\"\"\n for line_n in lines:\n line=line_n.strip()\n if line[0]==\">\":\n name=line.replace(\">\",\"\")\n n+=1\n else:\n if line[0]==\"M\" and line[-1]==\"*\":\n n_full+=1\n sys.stdout.write(str(name)+\"\\n\")\n\n return n, n_full","def getContigSizes( self ):\n if not self.mIsLoaded: self.__loadIndex()\n contig_sizes = {}\n for key, val in self.mIndex.items():\n contig_sizes[key] = val[2]\n return contig_sizes","def countSamples(filename):\n with open(filename, \"r\") as f:\n line = f.readline().split(\"\\t\")\n return len(line) - 2","def _get_nparts(filename,headersize,itemsize):\n return (os.path.getsize(filename)-headersize)/itemsize","def countBasesInFasta(fastaFile):\n recordRE=re.compile(r'^>')\n whiteSpaceRE=re.compile(r'\\s+')\n totalBases=0\n totalSeqs=0\n with open(fastaFile) as f:\n for line in f:\n if recordRE.match(line):\n totalSeqs+=1\n continue\n totalBases+=len(whiteSpaceRE.sub('',line))","def get_read_length(read_fn, n_read=10000):\n with GzipFile(read_fn, mode='rb') as f:\n h = SeqIO.QualityIO.FastqGeneralIterator(f)\n i = 0\n l = []\n while i < n_read:\n try:\n t = h.next()\n l.append(len(t[1]))\n i += 1\n except StopIteration:\n logger.warning(\"Requested %d reads but reached the end of the file after %d\", n_read, i)\n return int(np.round(np.mean(l)))","def get_sequence_count(input_fasta_files):\n \n # Correction for the case that only one file passed\n if type(input_fasta_files)==str:\n input_fasta_files=[input_fasta_files]\n \n count=0\n for n in input_fasta_files:\n fasta_f=open(n,'U')\n for label,seq in MinimalFastaParser(fasta_f):\n count+=1\n fasta_f.close()\n return count","def GenFrequencies(alignment):\n bases = {'A':0,'C':0,'G':0,'T':0,'-':0}\n FreqArray = []\n SeqLen = getLen(alignment)\n for i in range(SeqLen):\n FreqArray.append(bases.copy())\n count = 0\n SeqNum = 0\n with open(alignment,'rU') as F:\n data = 'placeHolder'\n while data:\n data = F.readline().strip()\n if data and not data[0] == '>':\n for char in data:\n FreqArray[count][char] += 1\n count +=1\n elif data:\n count = 0\n SeqNum += 1\n else:\n break\n for position in FreqArray:\n for base in position:\n position[base] /= float(SeqNum)\n return FreqArray","def contig_count(contig):\n return sum([1 for line in open(contig, 'rU').readlines() if line.startswith('>')])","def countReadCoverage(bam,chrom,start,end,strand=None):\n\n coverage = []\n start = int(start)\n end = int(end)\n for i in range(end-start+1):\n coverage.append(0.0)\n\n i = 0\n if chrom in bam.references:\n for pcol in bam.pileup(chrom,start,end):\n n = 0\n if pcol.pos >= start and pcol.pos <= end:\n for read in pcol.pileups:\n if strand == '+':\n if not read.alignment.is_reverse and read.alignment.mapq >= 0 and not read.alignment.is_duplicate:\n n += 1\n elif strand == '-':\n if read.alignment.is_reverse and read.alignment.mapq >= 0 and not read.alignment.is_duplicate:\n n += 1\n else:\n if read.alignment.mapq >= 0 and not read.alignment.is_duplicate:\n n += 1\n coverage[i] = n\n i += 1\n\n return coverage","def countBaseAtPos(bamfile,chrom,pos):\n locstr = chrom + \":\" + str(pos) + \"-\" + str(pos)\n args = ['samtools','mpileup',bamfile,'-r',locstr]\n\n p = subprocess.Popen(args,stdout=subprocess.PIPE,stderr=subprocess.PIPE)\n p.wait()\n pout = p.stdout.readlines()\n\n pileup = None \n\n for line in pout:\n c = line.strip().split()\n pileup = c[4].upper()\n\n bases = []\n if pileup:\n for b in pileup:\n if b in ['A','T','C','G']:\n bases.append(b)\n\n return bases","def read_file(infile_name):\n chr_list = [0]*13 \n for i in range(len(chr_list)):\n chr_list[i] = [] \n infile = open(infile_name)\n for line in infile:\n if line.startswith('SL2.40'):\n chr = int(line.strip().split()[0][-2:])\n loci = int(line.strip().split()[1])\n chr_list[chr] += [loci]\n else:\n pass\n infile.close()\n return chr_list","def cnt_freq(filename):\r\n counts = [0] * 256\r\n fp_file = open(filename, \"r\")\r\n lines = fp_file.readlines()\r\n for i in lines:\r\n for j in i: # count every letter in the line\r\n counts[ord(j)] += 1 # counts[ord(j)] + 1\r\n counts[0] = 1\r\n fp_file.close()\r\n return counts","def get_chrom_length(request, genome, chrom):\n logger.debug(\"annotation_server.get_chrom_length called for genome: %s chromosome: %s\" % (genome, chrom)) \n \n if genome in SUPPORTED_GENOMES:\n current_table = eval(genome+ \"_ChromInfo\")\n curr_vals = current_table.objects.filter(chrom__iexact=chrom).values('chrom', 'size')\n data = ValuesQuerySetToDict(curr_vals)\n return HttpResponse(data, 'application/json')\n else:\n return HttpResponse(status=400)\n \n # TODO: return genome lengths according to chrom order i.e. 1,2,3 etc. \n #cursor = connection.cursor() \n #if (chrom):\n # query = \"\"\"SELECT chrom, size from %s.chrominfo where chrom ilike '%s'\"\"\" % (genome, chrom)\n #cursor.execute(query)\n #return HttpResponse(cursor_to_json(cursor), 'application/javascript')","def total_number():\r\n total_number = 0\r\n file_read = read_file()\r\n for key in file_read:\r\n total_number = total_number + len(file_read[key])\r\n return total_number","def eamap_size(*args):\n return _ida_hexrays.eamap_size(*args)","def get_bases_stats(sequence, alphabet, start):\n seq = sequence.upper()\n seq_len = len(seq)\n half_seq = seq_len // 2\n ter = start + half_seq\n # as a circular genome\n if ter > seq_len:\n ter = ter - seq_len + 1\n counts = defaultdict(int)\n for base in alphabet:\n total = seq.count(base)\n if ter > start: # start ---> ter\n f_count = seq[start:ter].count(base)\n r_count = total - f_count\n else: # ter ---> start\n r_count = seq[ter:start].count(base)\n f_count = total - r_count\n counts[base] = (total, f_count, r_count)\n return counts","def create_length_genome():\n bam = glob.glob(os.path.join(os.getcwd(), '*.bam'))[0]\n command = r\"\"\"samtools view -H %s | perl -ne 'if ($_ =~ m/^\\@SQ/) { print $_ }' | perl -ne 'if ($_ =~ m/SN:(.+)\\s+LN:(\\d+)/) { print $1, \"\\t\", $2, \"\\n\"}' > lengths.genome\"\"\"\n sp.check_call(command % bam, shell=True)","def calculate_homopolymer_counts(fasta_file, min_repeats, min_count):\n count_matrix = dict()\n\n logging.info(\"Extracting homopolymers from %s ...\", fasta_file)\n with gzip.open(fasta_file, \"rt\") as handle:\n records = SeqIO.parse(handle, \"fasta\", IUPAC.unambiguous_dna)\n for record in records:\n last_base = \"\"\n poly_len = 0\n for base in record.seq:\n if base == last_base:\n poly_len += 1\n continue\n if poly_len >= min_repeats:\n count_matrix.setdefault(last_base, dict())[poly_len] = \\\n count_matrix.get(last_base, dict()).get(poly_len, 0) + 1\n last_base = base\n poly_len = 1\n\n print(\"nucleotide\", \"polymer_length\", \"count\", sep=\"\\t\")\n for nucleotide, polymer_lengths in count_matrix.items():\n for polymer_length, count in polymer_lengths.items():\n if count < min_count:\n continue\n print(nucleotide, polymer_length, count, sep=\"\\t\")","def _chrom_names(fasta_file):\n from pysam import FastaFile\n with FastaFile(fasta_file) as fa:\n chroms = list(fa.references)\n return chroms","def indexSize(analyzer):\n return om.size(analyzer['songs'])","def map_count(filename):\n f = open(filename, \"r+\")\n buf = mmap.mmap(f.fileno(), 0)\n lines = 0\n readline = buf.readline\n while readline():\n lines += 1\n return lines","def countLength():\n counter = 0\n\n with open('bc.processed3.csv', 'r') as openfile:\n for line in openfile:\n counter += 1\n if counter == 1:\n print line\n\n print('Length: ', counter)","def count_total_mutations_cpp(seqs):\n folder = \"/gpfs/group/cdm/IPRO_Suite/modules/CPP/humanization/\"\n name = \"humanization.out\"\n shutil.copyfile(folder + name, name)\n cmd = \"chmod a+x \" + name\n os.system(cmd)\n seqFile = \"sequences.txt\"\n f = open(seqFile, 'w')\n for s in seqs:\n f.write(s + \"\\n\")\n f.close()\n cmd = \"./humanization.out \" + seqFile\n os.system(cmd)\n countFile = \"counts.txt\"\n if os.path.exists(countFile):\n f = open(countFile, 'r')\n firstline = f.readline().strip(' \\t\\n')\n return int(firstline)\n else:\n text = \"humanization.out cpp code do not give the right counts of the mutations, please check\"\n raise DeimmunizationError(text)","def get_sequence_length(bam):\n\n chr_lengths = {} # 'I' | 230218, 'II' | 813184, ...\n chr_lengths_cumsum = {} # 'I' | 0, 'II' | 230218, 'III' | 1043402, ...\n ref_summedlength = 0\n ref_tid = get_chromosome_names(bam)\n for key in ref_tid.keys():\n ref_length = bam.get_reference_length(key)\n chr_lengths[key] = bam.get_reference_length(key)\n chr_lengths_cumsum[key] = ref_summedlength\n ref_summedlength += ref_length\n\n return chr_lengths, chr_lengths_cumsum","def size(self):\n\t\treturn (len(self.aminos))","def get_length(dna):\n return len (dna)","def get_number_of_atoms(self):\n natoms = 0\n\n with open(self.path, 'r') as f:\n line = f.readline()\n while line != '' and natoms == 0:\n # Automatically determine the number of atoms\n if 'CARTESIAN COORDINATES (ANGSTROEM)' in line and natoms == 0:\n for i in range(2):\n line = f.readline()\n\n while '---------------------------------' not in line:\n natoms += 1\n line = f.readline()\n if not line.strip():\n f.close()\n return natoms\n line = f.readline()","def read_file(infile_name):\n chr_list = [0]*13 \n for i in range(len(chr_list)):\n chr_list[i] = [] \n infile = open(infile_name)\n for line in infile:\n if line.startswith('SL2.40'):\n info = line.strip().split()\n chr = int(info[0][-2:])\n chr_list[chr].append(map(int,info[1:3])+[[info[-1]]])\n else:\n pass\n infile.close()\n return chr_list","def count_contigs(fastafile):\n\n # import file into a dictionary using biopython module\n from Bio import SeqIO\n seq_dict = {rec.id : rec.seq for rec in SeqIO.parse(fastafile, \"fasta\")}\n\n # count contigs\n count_dict = {}\n for id in seq_dict:\n count_dict[id] = len(seq_dict[id])\n\n # cluster amount of contigs according to their lengths\n smaller_than_500 = 0\n up_to_1000bp = 0\n up_to_5000bp = 0\n ten_thousand = 0\n twenty_thousand = 0\n fifty_thousand = 0\n hundred_thousand_and_larger = 0\n larger_than_100000 = 0\n\n for id in count_dict:\n if count_dict[id] <= 500:\n smaller_than_500 += 1\n elif 500 < count_dict[id] <= 1000:\n up_to_1000bp += 1\n elif 1000 < count_dict[id] <= 5000:\n up_to_5000bp += 1\n elif 5000 < count_dict[id] <= 10000:\n ten_thousand += 1\n elif 10000 < count_dict[id] <= 20000:\n twenty_thousand += 1\n elif 20000 < count_dict[id] <= 50000:\n fifty_thousand += 1\n elif 50000 < count_dict[id] <= 100000:\n hundred_thousand_and_larger += 1\n elif 100000 < count_dict[id]:\n larger_than_100000 += 1\n\n print (\"up to 500 bp:\",smaller_than_500)\n print (\"500 to 1000 bp:\", up_to_1000bp)\n print (\"1000 - 5000 bp:\", up_to_5000bp)\n print (\"5000 - 10 000 bp:\", ten_thousand)\n print (\"10 000 - 20 000 bp:\", twenty_thousand)\n print (\"20 000 - 50 000 bp:\", fifty_thousand)\n print (\"50 000 - 100 000 bp:\", hundred_thousand_and_larger)\n print (\"larger than 100 000 bp:\", larger_than_100000)","def __len__(self):\n return len(self.chromosome_list)","def bufcount(filename):\n\timport gzip\n\tif filename.split('.')[-1] in ['gz','gzip']: f = gzip.open(filename)\n\telse: f = open(filename)\n\tlines = 0\n\tbuf_size = 1024 * 1024\n\tread_f = f.read # loop optimization\n\t\n\tbuf = read_f(buf_size)\n\twhile buf:\n\t\tlines += buf.count('\\n')\n\t\tbuf = read_f(buf_size)\n\t\tf.close\n\treturn lines","def countsubcatchments(inputfilename=FileSettings.settingsdict['inputfilename']):\r\n global count\r\n with open(inputfilename, 'r') as swmmput:\r\n contents = swmmput.readlines()\r\n count = len(contents)\r\n return(count)","def count_n_grams_fasta(fasta_dict, name, kmin, kmax):\n # get the number of files in the names directory\n num_fastas = len(fasta_dict[name])\n # initialyze the counter\n counter = Counter()\n # iterates through the list of paths\n for filename in fasta_dict[name]:\n # reads the file and parse the content\n print(f'Reading and parsing the filename {filename}')\n for name, sequence in parse_fasta(filename):\n # counting the kmers\n cnt = count_kmers(sequence, kmin, kmax, counter=None)\n # add the count of the current file to the counter\n counter.update(cnt)\n # to get the mean of the kmer count for all the files\n final_counter = {k: (c // num_fastas) for k, c in counter.items()}\n return final_counter","def find_GC_content(fasta_file_name):\n\twith open(fasta_file_name) as fasta:\n\t\tGC_content = {}\n\t\tfor line in fasta:\n\n\t\t\t# Each line (bar the last) ends with '\\n'\n\t\t\tloc_line = line.replace('\\n', '')\n\n\t\t\t# Finds '>' at opening of line (FASTA seq title)\n\t\t\tif re.match(r'^>', loc_line):\n\t\t\t\tGC_content[loc_line] = 0\n\t\t\t\tG_count = 0\n\t\t\t\tC_count = 0\n\t\t\t\tcount = 0\n\t\t\t\tcurrent = loc_line\n\t\t\telse:\n\t\t\t\tG_count += loc_line.count('G')\n\t\t\t\tC_count += loc_line.count('C')\n\t\t\t\tcount += len(loc_line)\n\t\t\t\tGC_content[current] = float((G_count + C_count)) / count\n\treturn GC_content","def count_matches(sam_input):\n logging.info(\"Counting aligned bases in %s ...\", sam_input.name)\n\n total_bases = 0\n with pysam.AlignmentFile(sam_input, \"r\") as sam:\n for read in sam:\n total_bases += aligned_bases(read.cigar)\n return total_bases","def findFLength(filename):\n f = os.popen('wc -l < {}'.format(filename))\n return int(f.read())","def sox_get_audio_length(self, audio_file):\n logging.info('Getting source file length ...')\n result = self._process_command('soxi -D \"%s\"' % audio_file, PIPE)\n if result[1][0] != '':\n return float(result[1][0].strip('\\n'))\n else:\n return 1000","def get_length(dna):\n return len(dna)","def file_len(fname):\n with open(fname) as f:\n for i, l in enumerate(f):\n pass\n Nrows = i + 1\n return Nrows","def runstats(fasta_file):\n loc = locale.setlocale(locale.LC_ALL, '')\n locale.setlocale(locale.LC_ALL, loc)\n\n seqs = [seq for seq in SeqIO.parse(fasta_file, \"fasta\")]\n lengths_list = [len(i.seq) for i in seqs]\n\n total_size = locale.format(\"%d\", np.sum(lengths_list), grouping=True)\n ctg_n50 = locale.format(\"%d\", calculate_N50(lengths_list), grouping=True)\n minsize = locale.format(\"%d\", min(lengths_list), grouping=True)\n maxsize = locale.format(\"%d\", max(lengths_list), grouping=True)\n gc_percent = np.average([GC(i.seq) for i in seqs])\n\n print '{0:25}\\t{1}'.format(\"Total number of contigs:\", locale.format(\"%d\", len(seqs), grouping=True))\n print '{0:25}\\t{1}'.format(\"Total size of all contigs:\", total_size)\n print '{0:25}\\t{1}'.format(\"N50 of all contigs:\", ctg_n50)\n print '{0:25}\\t{1}'.format(\"Largest contig:\", maxsize)\n print '{0:25}\\t{1}'.format(\"Smallest contig:\", minsize)\n print '{0:25}\\t{1:.2f}'.format(\"G+C % of contigs:\", gc_percent)","def countDataSize(self,filename):\n \n d = h5py.File(filename,'r')\n features = d['spectrometer/features'][:]\n select = self.selectData(features.astype(float), self.ifeature, d)\n N = len(features[select])\n d.close()\n\n N = (N//self.offsetLen) * self.offsetLen\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def get_size(fname):\n return os.path.getsize(fname)","def get_dataset_length(file_path, had_header=True):\n with open(file_path, 'r') as f:\n length = 0\n for _ in f:\n length += 1\n length = length - had_header\n return length","def analyze_text(filename):\n lines = 0\n characters = 0\n with open(filename, \"r\") as f:\n for line in f:\n lines += 1\n characters += len(line)\n return lines, characters","def read_chr(fpath):\n\t# init dict and indices\n\tchrom_dicts={}\n\tstart=0\n\tindex=0\n\n\t# iterate through chromosome scores \n\tfor line in fileinput.input(fpath):\n\t\tx=line.split()\n\t\t\n\t\t# if chromosome skips some region, then normalize the previous window (<100 bp) and init new window \t\n\t\tif len(x)==4:\n\t\t\tif start in chrom_dicts:\n\t\t\t\tchrom_dicts[start]/=index\n\t\t\tstart=int(x[2].split(\"=\")[1])\n\t\t\tchrom_dicts[start]=0\n\t\t\tindex=0\n\n\t\t# if not a black region, then make news windows every 100 locations\n\t\tif len(x)==1:\n\t\t\tchrom_dicts[start]+=float(x[0])\n\t\t\tif index==100:\n\t\t\t\tchrom_dicts[start]/=index\n\t\t\t\tindex=0\n\t\t\t\tstart+=100\n\t\t\t\tchrom_dicts[start]=0\n\t\t\tindex+=1\n\t\n\t# track chromosomes that have been binned\n\tprint(\"%s %d\" % (fpath,len(chrom_dicts)))\n\treturn(chrom_dicts)","def parse_sequence_lengths(filepath, base_pair_limit):\n\n total_count = 0\n limit_count = 0\n with open(filepath) as f:\n line = f.readline()\n while line:\n if line.startswith('@'):\n total_count += 1\n seq = f.readline()\n sep = f.readline()\n qual = f.readline()\n if len(seq.strip()) > base_pair_limit:\n limit_count += 1\n line = f.readline()\n\n return limit_count / total_count","def count(handle, extractor, sample_size, threshold, use_freq=False):\n barcodes = defaultdict(int)\n\n for i, record in enumerate(SeqIO.parse(handle, guess_file_format(handle))):\n if i > sample_size:\n break\n barcodes[extractor.get(record)] += 1\n\n if use_freq:\n return filter(lambda x: barcodes[x] >= threshold, barcodes)\n return sorted(barcodes, key=barcodes.get, reverse=True)[:threshold]","def readlength_histogram(filename, offset=0):\n hist = Counter()\n with SequenceReader(filename) as fr:\n for record in fr:\n hist[len(record.sequence) + offset] += 1\n return hist","def get_genome_coverage(file_path, chrom_lengths_file):\n lines_in_input = float(get_number_of_lines(file_path))\n chrom_lengths = get_chrom_lengths(chrom_lengths_file)\n genome_size = float(get_genome_size(chrom_lengths))\n if genome_size == 0:\n # Use default.\n genome_size = float(MAX_GENOME_SIZE)\n genome_coverage = '%.4f' % float(lines_in_input / genome_size)\n return float(genome_coverage)","def get_chromsizes_from_ucsc(genome, saveas=None, mysql='mysql', timeout=1):\n cmds = [mysql,\n '--user=genome',\n '--host=genome-mysql.cse.ucsc.edu',\n '-A',\n '-B',\n '-e',\n 'select chrom, size from %s.chromInfo' % genome]\n\n try:\n p = subprocess.Popen(cmds,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n )\n stdout, stderr = p.communicate()\n if stderr:\n print(stderr)\n print('Commands were:\\n')\n print(subprocess.list2cmdline(cmds))\n\n lines = stdout.splitlines()[1:]\n d = {}\n for line in lines:\n chrom, size = line.split()\n d[chrom] = (0, int(size))\n\n if saveas is not None:\n chromsizes_to_file(d, saveas)\n\n return d\n\n except OSError as err:\n if err.errno == 2:\n raise OSError(\"Can't find mysql -- if you don't have it \"\n \"installed, you'll have to get chromsizes \"\n \"manually, or \"\n \"specify the path with the 'mysql' kwarg.\")\n else:\n raise","def cnt_freq(filename):\n freq = [0] * 256\n try:\n f_in = open(filename,'r')\n except:\n raise FileNotFoundError\n for line in f_in:\n for char in line:\n freq[ord(char)] = freq[ord(char)] + 1\n f_in.close()\n return freq","def est_read_len(fq, reads=100):\n if is_gz_file(fq):\n openf = gzip.open\n else:\n openf = open\n readlens = []\n with openf(fq) as f:\n try: # File less than 4*reads lines\n for _ in range(reads):\n next(f)\n readlens.append(len(next(f).strip()))\n next(f), next(f)\n except:\n pass\n return median(readlens)","def get_filesize(inputfile) -> int:\n with open(inputfile, \"rb\") as f:\n lines = 0\n buf_size = 1024 * 1024\n read_f = f.raw.read\n\n buf = read_f(buf_size)\n while buf:\n lines += buf.count(b\"\\n\")\n buf = read_f(buf_size)\n\n return lines","def get_read_len(wildcards):\n read_len = caseinfo.loc[(wildcards.sample, wildcards.unit), \"read_len\"]\n return int(read_len)","def _getMaxSize(self):\n \n # get gene list and related seqs\n geneList = map(lambda l: l.strip('\\n'), open(self.mdapArgs[1]).readlines())\n self.coRegSeqs = MDAP_defs.seqSubSet(geneList,self.mdapArgs[0])\n \n # warn user if there are missing genes\n if self.coRegSeqs[1]:\n sys.stderr.write('Warning: %s seqs in your gene list were not found in the fasta file provided.\\nA list of names follows:\\n%s\\n'\\\n % (len(self.coRegSeqs[1]),str(self.coRegSeqs[1])))\n \n # Concatonate, get and set self.maxsize\n return len(''.join(self.coRegSeqs[0].values()))\n \n \n #----------- ","def length(analog_file):\n if analog_file[-10:] == 'analog.brw':\n with h5py.File(analog_file, 'r') as file:\n print(len(file[\"3BData\"][\"Raw\"]))\n else:\n raise NotImplementedError(\"Only for use with *analog.brw files\")","def file_len(full_path):\n f = open(full_path)\n nr_of_lines = sum(1 for line in f)\n f.close()\n return nr_of_lines","def countDataSize(self,filename):\n \n try:\n d = h5py.File(filename,'r')\n except:\n print(filename)\n return \n\n N = 0\n scan_edges = d['level2/Statistics/scan_edges'][:]\n for (start,end) in scan_edges:\n N += (end-start)//self.offsetLen * self.offsetLen\n d.close()\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def find_dimesion(filename):\n file = open(filename,\"r\")\n\n line = file.readline()\n file.close()\n return len(line.split())","def cellranger_counts(fname, genome=\"matrix\"):\n with tables.open_file(fname, \"r\") as f:\n try:\n group = f.get_node(f.root, genome)\n except tables.NoSuchNodeError:\n print(\"That genome does not exist in this file.\")\n return None\n gene_ids = getattr(group, \"features/id\").read()\n barcodes = getattr(group, \"barcodes\").read()\n data = getattr(group, \"data\").read()\n indices = getattr(group, \"indices\").read()\n indptr = getattr(group, \"indptr\").read()\n shape = getattr(group, \"shape\").read()\n\n matrix = sp_sparse.csc_matrix((data, indices, indptr), shape=shape)\n gene_ids = np.array([x.decode() for x in gene_ids])\n barcodes = np.array([x.decode().replace(\"-1\", \"\") for x in barcodes])\n\n return CellRangerCounts(matrix, gene_ids, barcodes)","def GenomeHeadItems(genome_class):\n\tgc = genome_class()\n\treturn (len(gc.headers().split(',')),gc.genome_length())","def load_lengths(filename, return_base=False):\n data = pd.read_csv(filename, sep=\"\\t\", comment=\"#\", header=None)\n data = data.as_matrix()\n _, idx, lengths = np.unique(data[:, 0], return_counts=True,\n return_index=True)\n if return_base:\n return lengths[idx.argsort()], data[0, 3]\n else:\n return lengths[idx.argsort()]","def get_singles_counts(sname, seglen, mincounts):\n counts = defaultdict(int)\n with open(sname) as fin:\n infile = csv.DictReader(fin, delimiter='\\t')\n for line in infile:\n ints = int(line['interactions'])\n if ints < mincounts:\n continue\n r1_reg = (\n line['RNA1 chromosome'],int(int(line['Start of RNA1 first read'])/seglen)*seglen,\n line['RNA1 strand'])\n r2_reg = (\n line['RNA2 chromosome'],int(int(line['Start of RNA2 last read'])/seglen)*seglen,\n line['RNA2 strand'])\n counts[r1_reg] += ints\n counts[r2_reg] += ints\n return counts","def get_recording_length(file_path):\n f = open(file_path, 'rb')\n header = f.read(256)\n f.close()\n \n return int(header[236:244].decode('ascii'))","def get_number_of_letters(self):\n filename = f'{self.path}/{self.filename}'\n file = open(filename, 'r', encoding='utf-8')\n \"\"\"Count number of lettes without digits, non letter characters, without xml tags\"\"\"\n data = file.read()\n data = re.sub('<.*?binary.*?>*<.*?binary.*?>',' ', data)\n data = re.sub('\\\\s\\\\s*', '', (re.sub('\\\\W|\\\\d', ' ', re.sub('<.*?>', '', data))))\n let_count = len(data)\n sqlite_for_ht.CreateTable.update_table(f_1, self.filename, 'number_of_letters', let_count)\n print(datetime.now(), '-', 'number_of_letters for', self.filename, 'calculated =', let_count)\n return None","def read_off_size(path):\n try:\n with open(path, 'r') as file:\n lines = file.readlines()\n if lines[0] != 'OFF\\n':\n print(path, 'Error: is not an .off file')\n num_vertices, num_faces = tuple(lines[1].split()[:2])\n return int(num_vertices), int(num_faces)\n except IOError:\n print('Error: Failed reading file:', path)","def __len__(self):\n return self._fa.faidx.index[self.name].rlen","def analyze_text(filename):\n lines = 0\n chars = 0\n\n with open(filename, 'r') as f:\n for line in f:\n lines += 1\n chars += len(line)\n return (lines, chars)","def calc_GC(filepath):\n liste=['small.exon.piRNA_2.fa', 'small.exon.piRNA_1.fa', 'small.exon.piRNA_3.fa']\n \n length=list(range(0,34))\n d={}\n for i in length:\n d[i]={'A':0, 'G':0, 'T':0, 'C':0}\n for i in liste:\n with open(filepath+'/'+i, 'r') as f:\n for line in f:\n #fasta header starts with >\n if line.startswith('>'):\n pass\n else:\n line_l=list(line)\n for el in range(len(line_l)):\n if line_l[el]=='A':\n d[el]['A']+=1\n elif line_l[el]=='T':\n d[el]['T']+=1\n elif line_l[el]== 'G':\n d[el]['G']+=1\n elif line_l[el]== 'C':\n d[el]['C']+=1\n\n df=pd.DataFrame.from_dict(d)\n df=df.transpose()\n df.index = np.arange(1, len(df) + 1)\n \n\n df['A [%]']=df['A']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['G [%]']=df['G']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['T [%]']=df['T']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\n df['C [%]']=df['C']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100","def test_count_genomic_types(self):\n \n result, bed_result = parse_AS_STRUCTURE_dict(\"test\", clipper.test_dir())\n result = count_genomic_types(result)\n \n self.assertDictEqual(result, {\"CE:\" : 14})","def final_kmer_counts(seq_dict, num_seqs, alphabet, min_k, max_k):\n counted = Counter()\n len_seqs = 0\n for name, sequence in seq_dict.items():\n seq = seq_cleaner(sequence, alphabet)\n len_seqs += len(seq)\n counted.update(count_kmers_cython(seq, min_k, max_k))\n final_count = {k: (v // num_seqs) for k, v in counted.items()}\n # total_len = (len_seqs // num_seqs)\n return final_count, len_seqs","def get_size(self):","def getCubeSize(cubePath):\n\n # Make sure the input file exists\n if not os.path.exists(cubePath):\n raise Exception('Cube file ' + cubePath + ' not found!')\n \n # Use subprocess to suppress the command output\n cmd = ['gdalinfo', cubePath]\n p = subprocess.Popen(cmd, stdout=subprocess.PIPE)\n textOutput, err = p.communicate()\n\n # Extract the size from the text\n sizePos = textOutput.find('Size is')\n endPos = textOutput.find('\\n', sizePos+7)\n sizeStr = textOutput[sizePos+7:endPos]\n sizeStrs = sizeStr.strip().split(',')\n numSamples = int(sizeStrs[0])\n numLines = int(sizeStrs[1])\n \n size = [numSamples, numLines]\n return size"],"string":"[\n \"def expected_readlen(bedfile, bedHeader, annoList):\\n\\n #chromosomes from project bed\\n with open(bedfile, 'r') as f:\\n if bedHeader=='yes':\\n chroms = [key for key in dict(Counter([line.split('\\\\t')[0] for il, line in enumerate(f) if il>0])).keys()]\\n else:\\n chroms = [key for key in dict(Counter([line.split('\\\\t')[0] for il, line in enumerate(f)])).keys()]\\n\\n #dictionaries: keys are chrom and values are lists with start/end positions\\n ampStarts = {}; ampEnds = {}\\n for chrom in chroms:\\n ampStarts[chrom] = []\\n ampEnds[chrom] = []\\n\\n with open(bedfile, 'r') as f:\\n if bedHeader=='yes':\\n next(f)\\n for line in f:\\n ampStarts[line.split('\\\\t')[0]].append(int(line.split('\\\\t')[1]))\\n\\n with open(bedfile, 'r') as f:\\n if bedHeader=='yes':\\n next(f) \\n for line in f:\\n ampEnds[line.split('\\\\t')[0]].append(int(line.split('\\\\t')[2]))\\n\\n \\n exp_readlength = []\\n of = open('expected_readlen.txt','w')\\n for v in annoList:\\n chrom = v.split('\\\\t')[0]\\n start = v.split('\\\\t')[1]\\n nVarAmp = 0\\n amplength = []\\n #no. of amplicons spanning the chromosome\\n namp = len(ampStarts.get(chrom))\\n for ia in range(0,namp):\\n #no. of amplicons that span the variant\\n if (int(start) >= int(ampStarts.get(chrom)[ia])) and (int(start) <= int(ampEnds.get(chrom)[ia])):\\n nVarAmp += 1\\n amplength.append(int(ampEnds.get(chrom)[ia]) - int(ampStarts.get(chrom)[ia]) + 1)\\n # if amplicon start is greater than variant pos, go to next variant\\n if int(start) < int(ampStarts.get(chrom)[ia]):\\n break\\n exp_readlength.append(np.mean(amplength))\\n\\n of.write(str(np.mean(amplength)) + '\\\\n')\\n \\n of.close()\\n \\n return exp_readlength\\n\\n\\n ## save the chrom#, begin, end of amplicons from the project bed file\\n #with open(bedfile,'r') as bf:\\n # bedpos = [line.split('\\\\t')[:3] for line in bf if 'chr' in line.split('\\\\t')[0]]\\n #\\n ## iterate through the variants\\n #exp_readlen = []\\n #for idx, var in enumerate(annoList):\\n # varchrom = var.split('\\\\t')[0]\\n # varpos = var.split('\\\\t')[1]\\n # namp = 0\\n # amplen = []\\n\\n # # iterate through the amplicons\\n # for amp in bedpos:\\n # ampchrom = amp[0]\\n # ampstart = amp[1]\\n # ampend = amp[2]\\n\\n # # find the amplicons that belong to the chrom and pos of the variant\\n # if (varchrom == ampchrom) and \\\\\\n # (int(varpos) >= int(ampstart) and int(varpos) <= int(ampend)):\\n # amplen.append(int(ampend) - int(ampstart) + 1)\\n # namp += 1\\n # # if amplicon start is greater than variant pos in same chrom, go to next variant\\n # if (varchrom == ampchrom) and (int(varpos) < int(ampstart)):\\n # break\\n # # if amplicon/s found and chrom is different, go to next variant\\n # if (varchrom != ampchrom) and (namp > 0):\\n # break\\n # \\n # #print varchrom, varpos, namp \\n # exp_readlen.append(np.mean(amplen))\",\n \"def chromosome_sizes(probes, to_mb=False):\\n chrom_sizes = collections.OrderedDict()\\n for chrom, rows in probes.by_chromosome():\\n chrom_sizes[chrom] = rows[\\\"end\\\"].max()\\n if to_mb:\\n chrom_sizes[chrom] *= MB\\n return chrom_sizes\",\n \"def get_chromosome_length(genome):\\n \\n chr_list = {}\\n \\n for key in genome:\\n chr_list[key] = len(genome[key])\\n\\n return chr_list\",\n \"def get_counts(filename, alphabet, kmin, kmax):\\n # get the list of kmers to count with length between kmin and kmax\\n kmers_list = get_all_possible_kmers(alphabet, kmin, kmax)\\n # initialyze the counter with all possible kmer with length\\n # between kmin and kmax with zero counts\\n counter = Counter(dict([(km, 0) for km in kmers_list]))\\n # open and read in the kmers/string in the file\\n with gzip.open(filename, 'rt') as fh:\\n # iterates through the strings\\n for line in fh:\\n # make the adjustments int the strings\\n kmer = line.replace('\\\\n', '')\\n # check if kmer/string is in the counter\\n if kmer in counter:\\n # if kmer is in add 1 other wise keep the zero count\\n counter[kmer] += 1\\n return counter\",\n \"def get_gsize(self):\\n gsize_file = Genome(self.genome).get_fasize()\\n gsize = 0\\n with open(gsize_file, 'rt') as fi:\\n for a in fi:\\n c, n = a.strip().split('\\\\t')\\n gsize += int(n)\\n return gsize\",\n \"def get_array_size():\\n tg_file = 'NA_CAS_gauges.txt'\\n lines = open(tg_file).readlines()\\n tg_nbr = len(lines)\\n return tg_nbr\",\n \"def test_count_genomic_region_sizes(self):\\n \\n regions = OrderedDict()\\n regions[\\\"exons\\\"] = \\\"Exon\\\"\\n regions[\\\"utr3\\\"] = \\\"3' UTR\\\"\\n regions[\\\"utr5\\\"] = \\\"5' UTR\\\"\\n regions[\\\"proxintron500\\\"] = \\\"Proximal\\\\nIntron\\\"\\n regions[\\\"distintron500\\\"] = \\\"Distal\\\\nIntron\\\"\\n results = count_genomic_region_sizes(os.path.join(clipper.test_dir(), \\\"regions\\\"), regions, \\\"mm9\\\")\",\n \"def chromsizes(genome):\\n try:\\n return getattr(genome_registry, genome)\\n except AttributeError:\\n return get_chromsizes_from_ucsc(genome)\",\n \"def count_seqs_from_file(fasta_file, parser=parse_fasta):\\r\\n result = 0\\r\\n lens = []\\r\\n for record in parser(fasta_file):\\r\\n result += 1\\r\\n lens.append(len(record[1]))\\r\\n if result == 0:\\r\\n return result, None, None\\r\\n else:\\r\\n return result, mean(lens), std(lens)\",\n \"def full_chromosomes(reader):\\n for line in reader.header.get_lines(\\\"contig\\\"):\\n if line.id in CHROMS:\\n name = line.id\\n length = line.length or 1_000_000_000\\n yield \\\"{}:{}-{}\\\".format(name, 1, length)\",\n \"def countgenes():\\n directory = openfile('db_directory.txt')\\n no_genes_file = directory+'GENES_IN_HPO.txt'\\n GENES_IN_HPO = openfile(no_genes_file)\\n #GENES_IN_HPO = openfile(numbergenes_file)\\n return int(GENES_IN_HPO)\",\n \"def lengths(self):\\n\\t\\toutput_file = csv.writer(open('contigLengths.csv', 'wb'))\\n\\t\\tfor i,x in enumerate(self.contigsInfo.keys()):\\n\\t\\t\\tseq = self.contigsInfo[x]\\n\\t\\t\\tl = len(seq)\\n\\t\\t\\toutput_file.writerow([i,l])\",\n \"def count_sizes(fastq_file, amplicon, guide_rna, window=20, anchor_length=10):\\n editing_position = amplicon.index(guide_rna)\\n\\n guide_plus_window = (editing_position - window, editing_position + len(guide_rna) + window)\\n\\n left_anchor_start = guide_plus_window[0] - anchor_length\\n right_anchor_end = guide_plus_window[1] + anchor_length\\n\\n left_anchor_end = left_anchor_start + anchor_length\\n right_anchor_start = right_anchor_end - anchor_length\\n\\n a = amplicon[left_anchor_start: left_anchor_end]\\n b = amplicon[right_anchor_start: right_anchor_end]\\n\\n pattern = a + \\\".*\\\" + b\\n\\n window_size = (right_anchor_end - left_anchor_start) + 1\\n\\n os.system(\\\"zcat {} | grep -o {} > counts\\\".format(fastq_file, pattern))\\n\\n with open(\\\"counts\\\", 'r') as handle:\\n lines = handle.readlines()\\n\\n # return difference between window size and read length\\n return Counter([len(x) - window_size for x in lines])\",\n \"def bpCount(file):\\n amount_bp = len(file)\\n return amount_bp\",\n \"def get_chroms(chromfile):\\n chroms = {}\\n with open(chromfile) as c:\\n for line in c:\\n try:\\n chrom, length = line.strip().split()\\n chroms[chrom] = length\\n except ValueError:\\n chroms[line.strip()] = 1\\n return chroms\",\n \"def get_library_sizes(args):\\n with open(args.counts, \\\"r\\\") as counts:\\n sizes = []\\n head = True\\n for line in counts:\\n line = line.strip()\\n if head:\\n head = False\\n samples = line.split(\\\"\\\\t\\\")[3:]\\n total_counts = [0] * len(samples)\\n else:\\n counts = line.split(\\\"\\\\t\\\")\\n if counts[1] == \\\"NA\\\":\\n break\\n else:\\n counts = counts[3:]\\n for i in range(len(counts)):\\n total_counts[i] += int(counts[i])\\n\\n for i in range(len(samples)):\\n sizes.append([samples[i], total_counts[i]])\\n\\n return sizes\",\n \"def countCharacters(file_name, start, end):\\r\\n\\r\\n with open(file_name, \\\"r\\\") as file:\\r\\n counter_chars = 0\\r\\n\\r\\n for line in islice(file, start, end):\\r\\n counter_chars += len(line)\\r\\n\\r\\n return counter_chars\",\n \"def chromosome_lengths(self):\\n chr_lens = {}\\n for r in self.regions(lazy=True):\\n if chr_lens.get(r.chromosome) is None:\\n chr_lens[r.chromosome] = r.end\\n continue\\n if r.end > chr_lens[r.chromosome]:\\n chr_lens[r.chromosome] = r.end\\n return chr_lens\",\n \"def max_min_kmer_sizes(filename):\\n try:\\n fh = gzip.open if isgzip(filename) else open\\n with fh(filename, 'rt') as f:\\n kmer_sizes = np.array([len(rec.split()[0]) for rec in f])\\n\\n return kmer_sizes.min(), kmer_sizes.max()\\n\\n except Exception:\\n print('Not able to read file [%s]\\\\n' % filename)\\n raise\",\n \"def count_seqs(fasta_filepath, parser=parse_fasta):\\r\\n # Open the file and pass it to py_count_seqs_from_file -- wrapping\\r\\n # this makes for easier unit testing\\r\\n return count_seqs_from_file(open(fasta_filepath, 'U'), parser=parser)\",\n \"def getLen(alignment):\\n AlignmentLength = 0\\n with open(alignment,'rU') as F:\\n F.readline()\\n while True:\\n Data = F.readline().strip()\\n if Data[0] != '>':\\n AlignmentLength += len(Data)\\n else:\\n return AlignmentLength\",\n \"def feature_total_lengths(genefile, ignore_multiple_splice_variants=False, genome_fasta_file=DEFAULT_NUCLEAR_GENOME_FILE):\\n # BCBio uses 0-based and end-exclusive positions (first-third base is bases 0,1,2, i.e range 0-3), so length is straightforward\\n feature_total_lengths = defaultdict(int)\\n total_genome_length = 0\\n # get the total chromosome lengths from genome_fasta_file if given - needed to calculate total intergenic length \\n if genome_fasta_file:\\n with open(genome_fasta_file) as FASTAFILE: fasta_seq_dict = SeqIO.to_dict(SeqIO.parse(FASTAFILE, \\\"fasta\\\"))\\n else: fasta_seq_dict = {}\\n with open(os.path.expanduser(genefile)) as GENEFILE:\\n for chromosome_record in GFF.parse(GENEFILE, base_dict=fasta_seq_dict):\\n total_genome_length += len(chromosome_record.seq)\\n for gene_record in chromosome_record.features:\\n gene_length = gene_record.location.end.position - gene_record.location.start.position\\n feature_total_lengths['gene'] += gene_length\\n if len(gene_record.sub_features) == 0:\\n raise NoRNAError(\\\"Gene %s has no RNA - can't determine CDS start/end!\\\"%gene_record.id)\\n if len(gene_record.sub_features) > 1:\\n if ignore_multiple_splice_variants: \\n feature_total_lengths['MULTIPLE_SPLICE_VARIANTS'] += gene_length\\n continue\\n else: \\n raise MultipleRNAError(\\\"Gene %s has multiple RNAs - can't determine single CDS start/end!\\\"%gene_record.id)\\n else:\\n features = gene_record.sub_features[0].sub_features\\n for feature in features:\\n feature_total_lengths[feature.type] += (feature.location.end.position - feature.location.start.position)\\n # calculate total intron length from total gene and exon/UTR length\\n feature_total_lengths['intron'] = feature_total_lengths['gene'] - sum(length for feature,length \\n in feature_total_lengths.items() if feature != 'gene')\\n # calculate total intergenic length from total genome and gene length\\n feature_total_lengths['all'] = total_genome_length\\n feature_total_lengths['intergenic'] = total_genome_length - feature_total_lengths['gene']\\n return dict(feature_total_lengths)\",\n \"def reads_in_chromosome(self, chromosome):\\n return sum(m.read_info(self.dataset_name).total_read_count \\n for m in self.dataset if m.position not in SPECIAL_POSITIONS.all_undefined and m.position.chromosome==chromosome)\",\n \"def size(path):\",\n \"def get_regions_counts(fname, seglen, mincounts):\\n counts = defaultdict(int)\\n seglen=int(seglen)\\n with open(fname) as fin:\\n infile = csv.DictReader(fin, delimiter='\\\\t')\\n for line in infile:\\n if int(line['interactions']) < mincounts:\\n continue\\n t_reg = (\\n line['RNA1 chromosome'],int(int(line['Start of RNA1 first read'])/seglen)*seglen,\\n line['RNA1 strand'], \\n line['RNA2 chromosome'],int(int(line['Start of RNA2 last read'])/seglen)*seglen,\\n line['RNA2 strand'])\\n\\n counts[t_reg] = int(line['interactions'])\\n return counts\",\n \"def get_num_chunks(self) -> int:\",\n \"def scan_full_pr(fastafile):\\n n_full=0\\n n=0\\n\\n with open(fastafile, \\\"r\\\") as f:\\n lines=f.readlines()\\n name=\\\"\\\"\\n for line_n in lines:\\n line=line_n.strip()\\n if line[0]==\\\">\\\":\\n name=line.replace(\\\">\\\",\\\"\\\")\\n n+=1\\n else:\\n if line[0]==\\\"M\\\" and line[-1]==\\\"*\\\":\\n n_full+=1\\n sys.stdout.write(str(name)+\\\"\\\\n\\\")\\n\\n return n, n_full\",\n \"def getContigSizes( self ):\\n if not self.mIsLoaded: self.__loadIndex()\\n contig_sizes = {}\\n for key, val in self.mIndex.items():\\n contig_sizes[key] = val[2]\\n return contig_sizes\",\n \"def countSamples(filename):\\n with open(filename, \\\"r\\\") as f:\\n line = f.readline().split(\\\"\\\\t\\\")\\n return len(line) - 2\",\n \"def _get_nparts(filename,headersize,itemsize):\\n return (os.path.getsize(filename)-headersize)/itemsize\",\n \"def countBasesInFasta(fastaFile):\\n recordRE=re.compile(r'^>')\\n whiteSpaceRE=re.compile(r'\\\\s+')\\n totalBases=0\\n totalSeqs=0\\n with open(fastaFile) as f:\\n for line in f:\\n if recordRE.match(line):\\n totalSeqs+=1\\n continue\\n totalBases+=len(whiteSpaceRE.sub('',line))\",\n \"def get_read_length(read_fn, n_read=10000):\\n with GzipFile(read_fn, mode='rb') as f:\\n h = SeqIO.QualityIO.FastqGeneralIterator(f)\\n i = 0\\n l = []\\n while i < n_read:\\n try:\\n t = h.next()\\n l.append(len(t[1]))\\n i += 1\\n except StopIteration:\\n logger.warning(\\\"Requested %d reads but reached the end of the file after %d\\\", n_read, i)\\n return int(np.round(np.mean(l)))\",\n \"def get_sequence_count(input_fasta_files):\\n \\n # Correction for the case that only one file passed\\n if type(input_fasta_files)==str:\\n input_fasta_files=[input_fasta_files]\\n \\n count=0\\n for n in input_fasta_files:\\n fasta_f=open(n,'U')\\n for label,seq in MinimalFastaParser(fasta_f):\\n count+=1\\n fasta_f.close()\\n return count\",\n \"def GenFrequencies(alignment):\\n bases = {'A':0,'C':0,'G':0,'T':0,'-':0}\\n FreqArray = []\\n SeqLen = getLen(alignment)\\n for i in range(SeqLen):\\n FreqArray.append(bases.copy())\\n count = 0\\n SeqNum = 0\\n with open(alignment,'rU') as F:\\n data = 'placeHolder'\\n while data:\\n data = F.readline().strip()\\n if data and not data[0] == '>':\\n for char in data:\\n FreqArray[count][char] += 1\\n count +=1\\n elif data:\\n count = 0\\n SeqNum += 1\\n else:\\n break\\n for position in FreqArray:\\n for base in position:\\n position[base] /= float(SeqNum)\\n return FreqArray\",\n \"def contig_count(contig):\\n return sum([1 for line in open(contig, 'rU').readlines() if line.startswith('>')])\",\n \"def countReadCoverage(bam,chrom,start,end,strand=None):\\n\\n coverage = []\\n start = int(start)\\n end = int(end)\\n for i in range(end-start+1):\\n coverage.append(0.0)\\n\\n i = 0\\n if chrom in bam.references:\\n for pcol in bam.pileup(chrom,start,end):\\n n = 0\\n if pcol.pos >= start and pcol.pos <= end:\\n for read in pcol.pileups:\\n if strand == '+':\\n if not read.alignment.is_reverse and read.alignment.mapq >= 0 and not read.alignment.is_duplicate:\\n n += 1\\n elif strand == '-':\\n if read.alignment.is_reverse and read.alignment.mapq >= 0 and not read.alignment.is_duplicate:\\n n += 1\\n else:\\n if read.alignment.mapq >= 0 and not read.alignment.is_duplicate:\\n n += 1\\n coverage[i] = n\\n i += 1\\n\\n return coverage\",\n \"def countBaseAtPos(bamfile,chrom,pos):\\n locstr = chrom + \\\":\\\" + str(pos) + \\\"-\\\" + str(pos)\\n args = ['samtools','mpileup',bamfile,'-r',locstr]\\n\\n p = subprocess.Popen(args,stdout=subprocess.PIPE,stderr=subprocess.PIPE)\\n p.wait()\\n pout = p.stdout.readlines()\\n\\n pileup = None \\n\\n for line in pout:\\n c = line.strip().split()\\n pileup = c[4].upper()\\n\\n bases = []\\n if pileup:\\n for b in pileup:\\n if b in ['A','T','C','G']:\\n bases.append(b)\\n\\n return bases\",\n \"def read_file(infile_name):\\n chr_list = [0]*13 \\n for i in range(len(chr_list)):\\n chr_list[i] = [] \\n infile = open(infile_name)\\n for line in infile:\\n if line.startswith('SL2.40'):\\n chr = int(line.strip().split()[0][-2:])\\n loci = int(line.strip().split()[1])\\n chr_list[chr] += [loci]\\n else:\\n pass\\n infile.close()\\n return chr_list\",\n \"def cnt_freq(filename):\\r\\n counts = [0] * 256\\r\\n fp_file = open(filename, \\\"r\\\")\\r\\n lines = fp_file.readlines()\\r\\n for i in lines:\\r\\n for j in i: # count every letter in the line\\r\\n counts[ord(j)] += 1 # counts[ord(j)] + 1\\r\\n counts[0] = 1\\r\\n fp_file.close()\\r\\n return counts\",\n \"def get_chrom_length(request, genome, chrom):\\n logger.debug(\\\"annotation_server.get_chrom_length called for genome: %s chromosome: %s\\\" % (genome, chrom)) \\n \\n if genome in SUPPORTED_GENOMES:\\n current_table = eval(genome+ \\\"_ChromInfo\\\")\\n curr_vals = current_table.objects.filter(chrom__iexact=chrom).values('chrom', 'size')\\n data = ValuesQuerySetToDict(curr_vals)\\n return HttpResponse(data, 'application/json')\\n else:\\n return HttpResponse(status=400)\\n \\n # TODO: return genome lengths according to chrom order i.e. 1,2,3 etc. \\n #cursor = connection.cursor() \\n #if (chrom):\\n # query = \\\"\\\"\\\"SELECT chrom, size from %s.chrominfo where chrom ilike '%s'\\\"\\\"\\\" % (genome, chrom)\\n #cursor.execute(query)\\n #return HttpResponse(cursor_to_json(cursor), 'application/javascript')\",\n \"def total_number():\\r\\n total_number = 0\\r\\n file_read = read_file()\\r\\n for key in file_read:\\r\\n total_number = total_number + len(file_read[key])\\r\\n return total_number\",\n \"def eamap_size(*args):\\n return _ida_hexrays.eamap_size(*args)\",\n \"def get_bases_stats(sequence, alphabet, start):\\n seq = sequence.upper()\\n seq_len = len(seq)\\n half_seq = seq_len // 2\\n ter = start + half_seq\\n # as a circular genome\\n if ter > seq_len:\\n ter = ter - seq_len + 1\\n counts = defaultdict(int)\\n for base in alphabet:\\n total = seq.count(base)\\n if ter > start: # start ---> ter\\n f_count = seq[start:ter].count(base)\\n r_count = total - f_count\\n else: # ter ---> start\\n r_count = seq[ter:start].count(base)\\n f_count = total - r_count\\n counts[base] = (total, f_count, r_count)\\n return counts\",\n \"def create_length_genome():\\n bam = glob.glob(os.path.join(os.getcwd(), '*.bam'))[0]\\n command = r\\\"\\\"\\\"samtools view -H %s | perl -ne 'if ($_ =~ m/^\\\\@SQ/) { print $_ }' | perl -ne 'if ($_ =~ m/SN:(.+)\\\\s+LN:(\\\\d+)/) { print $1, \\\"\\\\t\\\", $2, \\\"\\\\n\\\"}' > lengths.genome\\\"\\\"\\\"\\n sp.check_call(command % bam, shell=True)\",\n \"def calculate_homopolymer_counts(fasta_file, min_repeats, min_count):\\n count_matrix = dict()\\n\\n logging.info(\\\"Extracting homopolymers from %s ...\\\", fasta_file)\\n with gzip.open(fasta_file, \\\"rt\\\") as handle:\\n records = SeqIO.parse(handle, \\\"fasta\\\", IUPAC.unambiguous_dna)\\n for record in records:\\n last_base = \\\"\\\"\\n poly_len = 0\\n for base in record.seq:\\n if base == last_base:\\n poly_len += 1\\n continue\\n if poly_len >= min_repeats:\\n count_matrix.setdefault(last_base, dict())[poly_len] = \\\\\\n count_matrix.get(last_base, dict()).get(poly_len, 0) + 1\\n last_base = base\\n poly_len = 1\\n\\n print(\\\"nucleotide\\\", \\\"polymer_length\\\", \\\"count\\\", sep=\\\"\\\\t\\\")\\n for nucleotide, polymer_lengths in count_matrix.items():\\n for polymer_length, count in polymer_lengths.items():\\n if count < min_count:\\n continue\\n print(nucleotide, polymer_length, count, sep=\\\"\\\\t\\\")\",\n \"def _chrom_names(fasta_file):\\n from pysam import FastaFile\\n with FastaFile(fasta_file) as fa:\\n chroms = list(fa.references)\\n return chroms\",\n \"def indexSize(analyzer):\\n return om.size(analyzer['songs'])\",\n \"def map_count(filename):\\n f = open(filename, \\\"r+\\\")\\n buf = mmap.mmap(f.fileno(), 0)\\n lines = 0\\n readline = buf.readline\\n while readline():\\n lines += 1\\n return lines\",\n \"def countLength():\\n counter = 0\\n\\n with open('bc.processed3.csv', 'r') as openfile:\\n for line in openfile:\\n counter += 1\\n if counter == 1:\\n print line\\n\\n print('Length: ', counter)\",\n \"def count_total_mutations_cpp(seqs):\\n folder = \\\"/gpfs/group/cdm/IPRO_Suite/modules/CPP/humanization/\\\"\\n name = \\\"humanization.out\\\"\\n shutil.copyfile(folder + name, name)\\n cmd = \\\"chmod a+x \\\" + name\\n os.system(cmd)\\n seqFile = \\\"sequences.txt\\\"\\n f = open(seqFile, 'w')\\n for s in seqs:\\n f.write(s + \\\"\\\\n\\\")\\n f.close()\\n cmd = \\\"./humanization.out \\\" + seqFile\\n os.system(cmd)\\n countFile = \\\"counts.txt\\\"\\n if os.path.exists(countFile):\\n f = open(countFile, 'r')\\n firstline = f.readline().strip(' \\\\t\\\\n')\\n return int(firstline)\\n else:\\n text = \\\"humanization.out cpp code do not give the right counts of the mutations, please check\\\"\\n raise DeimmunizationError(text)\",\n \"def get_sequence_length(bam):\\n\\n chr_lengths = {} # 'I' | 230218, 'II' | 813184, ...\\n chr_lengths_cumsum = {} # 'I' | 0, 'II' | 230218, 'III' | 1043402, ...\\n ref_summedlength = 0\\n ref_tid = get_chromosome_names(bam)\\n for key in ref_tid.keys():\\n ref_length = bam.get_reference_length(key)\\n chr_lengths[key] = bam.get_reference_length(key)\\n chr_lengths_cumsum[key] = ref_summedlength\\n ref_summedlength += ref_length\\n\\n return chr_lengths, chr_lengths_cumsum\",\n \"def size(self):\\n\\t\\treturn (len(self.aminos))\",\n \"def get_length(dna):\\n return len (dna)\",\n \"def get_number_of_atoms(self):\\n natoms = 0\\n\\n with open(self.path, 'r') as f:\\n line = f.readline()\\n while line != '' and natoms == 0:\\n # Automatically determine the number of atoms\\n if 'CARTESIAN COORDINATES (ANGSTROEM)' in line and natoms == 0:\\n for i in range(2):\\n line = f.readline()\\n\\n while '---------------------------------' not in line:\\n natoms += 1\\n line = f.readline()\\n if not line.strip():\\n f.close()\\n return natoms\\n line = f.readline()\",\n \"def read_file(infile_name):\\n chr_list = [0]*13 \\n for i in range(len(chr_list)):\\n chr_list[i] = [] \\n infile = open(infile_name)\\n for line in infile:\\n if line.startswith('SL2.40'):\\n info = line.strip().split()\\n chr = int(info[0][-2:])\\n chr_list[chr].append(map(int,info[1:3])+[[info[-1]]])\\n else:\\n pass\\n infile.close()\\n return chr_list\",\n \"def count_contigs(fastafile):\\n\\n # import file into a dictionary using biopython module\\n from Bio import SeqIO\\n seq_dict = {rec.id : rec.seq for rec in SeqIO.parse(fastafile, \\\"fasta\\\")}\\n\\n # count contigs\\n count_dict = {}\\n for id in seq_dict:\\n count_dict[id] = len(seq_dict[id])\\n\\n # cluster amount of contigs according to their lengths\\n smaller_than_500 = 0\\n up_to_1000bp = 0\\n up_to_5000bp = 0\\n ten_thousand = 0\\n twenty_thousand = 0\\n fifty_thousand = 0\\n hundred_thousand_and_larger = 0\\n larger_than_100000 = 0\\n\\n for id in count_dict:\\n if count_dict[id] <= 500:\\n smaller_than_500 += 1\\n elif 500 < count_dict[id] <= 1000:\\n up_to_1000bp += 1\\n elif 1000 < count_dict[id] <= 5000:\\n up_to_5000bp += 1\\n elif 5000 < count_dict[id] <= 10000:\\n ten_thousand += 1\\n elif 10000 < count_dict[id] <= 20000:\\n twenty_thousand += 1\\n elif 20000 < count_dict[id] <= 50000:\\n fifty_thousand += 1\\n elif 50000 < count_dict[id] <= 100000:\\n hundred_thousand_and_larger += 1\\n elif 100000 < count_dict[id]:\\n larger_than_100000 += 1\\n\\n print (\\\"up to 500 bp:\\\",smaller_than_500)\\n print (\\\"500 to 1000 bp:\\\", up_to_1000bp)\\n print (\\\"1000 - 5000 bp:\\\", up_to_5000bp)\\n print (\\\"5000 - 10 000 bp:\\\", ten_thousand)\\n print (\\\"10 000 - 20 000 bp:\\\", twenty_thousand)\\n print (\\\"20 000 - 50 000 bp:\\\", fifty_thousand)\\n print (\\\"50 000 - 100 000 bp:\\\", hundred_thousand_and_larger)\\n print (\\\"larger than 100 000 bp:\\\", larger_than_100000)\",\n \"def __len__(self):\\n return len(self.chromosome_list)\",\n \"def bufcount(filename):\\n\\timport gzip\\n\\tif filename.split('.')[-1] in ['gz','gzip']: f = gzip.open(filename)\\n\\telse: f = open(filename)\\n\\tlines = 0\\n\\tbuf_size = 1024 * 1024\\n\\tread_f = f.read # loop optimization\\n\\t\\n\\tbuf = read_f(buf_size)\\n\\twhile buf:\\n\\t\\tlines += buf.count('\\\\n')\\n\\t\\tbuf = read_f(buf_size)\\n\\t\\tf.close\\n\\treturn lines\",\n \"def countsubcatchments(inputfilename=FileSettings.settingsdict['inputfilename']):\\r\\n global count\\r\\n with open(inputfilename, 'r') as swmmput:\\r\\n contents = swmmput.readlines()\\r\\n count = len(contents)\\r\\n return(count)\",\n \"def count_n_grams_fasta(fasta_dict, name, kmin, kmax):\\n # get the number of files in the names directory\\n num_fastas = len(fasta_dict[name])\\n # initialyze the counter\\n counter = Counter()\\n # iterates through the list of paths\\n for filename in fasta_dict[name]:\\n # reads the file and parse the content\\n print(f'Reading and parsing the filename {filename}')\\n for name, sequence in parse_fasta(filename):\\n # counting the kmers\\n cnt = count_kmers(sequence, kmin, kmax, counter=None)\\n # add the count of the current file to the counter\\n counter.update(cnt)\\n # to get the mean of the kmer count for all the files\\n final_counter = {k: (c // num_fastas) for k, c in counter.items()}\\n return final_counter\",\n \"def find_GC_content(fasta_file_name):\\n\\twith open(fasta_file_name) as fasta:\\n\\t\\tGC_content = {}\\n\\t\\tfor line in fasta:\\n\\n\\t\\t\\t# Each line (bar the last) ends with '\\\\n'\\n\\t\\t\\tloc_line = line.replace('\\\\n', '')\\n\\n\\t\\t\\t# Finds '>' at opening of line (FASTA seq title)\\n\\t\\t\\tif re.match(r'^>', loc_line):\\n\\t\\t\\t\\tGC_content[loc_line] = 0\\n\\t\\t\\t\\tG_count = 0\\n\\t\\t\\t\\tC_count = 0\\n\\t\\t\\t\\tcount = 0\\n\\t\\t\\t\\tcurrent = loc_line\\n\\t\\t\\telse:\\n\\t\\t\\t\\tG_count += loc_line.count('G')\\n\\t\\t\\t\\tC_count += loc_line.count('C')\\n\\t\\t\\t\\tcount += len(loc_line)\\n\\t\\t\\t\\tGC_content[current] = float((G_count + C_count)) / count\\n\\treturn GC_content\",\n \"def count_matches(sam_input):\\n logging.info(\\\"Counting aligned bases in %s ...\\\", sam_input.name)\\n\\n total_bases = 0\\n with pysam.AlignmentFile(sam_input, \\\"r\\\") as sam:\\n for read in sam:\\n total_bases += aligned_bases(read.cigar)\\n return total_bases\",\n \"def findFLength(filename):\\n f = os.popen('wc -l < {}'.format(filename))\\n return int(f.read())\",\n \"def sox_get_audio_length(self, audio_file):\\n logging.info('Getting source file length ...')\\n result = self._process_command('soxi -D \\\"%s\\\"' % audio_file, PIPE)\\n if result[1][0] != '':\\n return float(result[1][0].strip('\\\\n'))\\n else:\\n return 1000\",\n \"def get_length(dna):\\n return len(dna)\",\n \"def file_len(fname):\\n with open(fname) as f:\\n for i, l in enumerate(f):\\n pass\\n Nrows = i + 1\\n return Nrows\",\n \"def runstats(fasta_file):\\n loc = locale.setlocale(locale.LC_ALL, '')\\n locale.setlocale(locale.LC_ALL, loc)\\n\\n seqs = [seq for seq in SeqIO.parse(fasta_file, \\\"fasta\\\")]\\n lengths_list = [len(i.seq) for i in seqs]\\n\\n total_size = locale.format(\\\"%d\\\", np.sum(lengths_list), grouping=True)\\n ctg_n50 = locale.format(\\\"%d\\\", calculate_N50(lengths_list), grouping=True)\\n minsize = locale.format(\\\"%d\\\", min(lengths_list), grouping=True)\\n maxsize = locale.format(\\\"%d\\\", max(lengths_list), grouping=True)\\n gc_percent = np.average([GC(i.seq) for i in seqs])\\n\\n print '{0:25}\\\\t{1}'.format(\\\"Total number of contigs:\\\", locale.format(\\\"%d\\\", len(seqs), grouping=True))\\n print '{0:25}\\\\t{1}'.format(\\\"Total size of all contigs:\\\", total_size)\\n print '{0:25}\\\\t{1}'.format(\\\"N50 of all contigs:\\\", ctg_n50)\\n print '{0:25}\\\\t{1}'.format(\\\"Largest contig:\\\", maxsize)\\n print '{0:25}\\\\t{1}'.format(\\\"Smallest contig:\\\", minsize)\\n print '{0:25}\\\\t{1:.2f}'.format(\\\"G+C % of contigs:\\\", gc_percent)\",\n \"def countDataSize(self,filename):\\n \\n d = h5py.File(filename,'r')\\n features = d['spectrometer/features'][:]\\n select = self.selectData(features.astype(float), self.ifeature, d)\\n N = len(features[select])\\n d.close()\\n\\n N = (N//self.offsetLen) * self.offsetLen\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def get_size(fname):\\n return os.path.getsize(fname)\",\n \"def get_dataset_length(file_path, had_header=True):\\n with open(file_path, 'r') as f:\\n length = 0\\n for _ in f:\\n length += 1\\n length = length - had_header\\n return length\",\n \"def analyze_text(filename):\\n lines = 0\\n characters = 0\\n with open(filename, \\\"r\\\") as f:\\n for line in f:\\n lines += 1\\n characters += len(line)\\n return lines, characters\",\n \"def read_chr(fpath):\\n\\t# init dict and indices\\n\\tchrom_dicts={}\\n\\tstart=0\\n\\tindex=0\\n\\n\\t# iterate through chromosome scores \\n\\tfor line in fileinput.input(fpath):\\n\\t\\tx=line.split()\\n\\t\\t\\n\\t\\t# if chromosome skips some region, then normalize the previous window (<100 bp) and init new window \\t\\n\\t\\tif len(x)==4:\\n\\t\\t\\tif start in chrom_dicts:\\n\\t\\t\\t\\tchrom_dicts[start]/=index\\n\\t\\t\\tstart=int(x[2].split(\\\"=\\\")[1])\\n\\t\\t\\tchrom_dicts[start]=0\\n\\t\\t\\tindex=0\\n\\n\\t\\t# if not a black region, then make news windows every 100 locations\\n\\t\\tif len(x)==1:\\n\\t\\t\\tchrom_dicts[start]+=float(x[0])\\n\\t\\t\\tif index==100:\\n\\t\\t\\t\\tchrom_dicts[start]/=index\\n\\t\\t\\t\\tindex=0\\n\\t\\t\\t\\tstart+=100\\n\\t\\t\\t\\tchrom_dicts[start]=0\\n\\t\\t\\tindex+=1\\n\\t\\n\\t# track chromosomes that have been binned\\n\\tprint(\\\"%s %d\\\" % (fpath,len(chrom_dicts)))\\n\\treturn(chrom_dicts)\",\n \"def parse_sequence_lengths(filepath, base_pair_limit):\\n\\n total_count = 0\\n limit_count = 0\\n with open(filepath) as f:\\n line = f.readline()\\n while line:\\n if line.startswith('@'):\\n total_count += 1\\n seq = f.readline()\\n sep = f.readline()\\n qual = f.readline()\\n if len(seq.strip()) > base_pair_limit:\\n limit_count += 1\\n line = f.readline()\\n\\n return limit_count / total_count\",\n \"def count(handle, extractor, sample_size, threshold, use_freq=False):\\n barcodes = defaultdict(int)\\n\\n for i, record in enumerate(SeqIO.parse(handle, guess_file_format(handle))):\\n if i > sample_size:\\n break\\n barcodes[extractor.get(record)] += 1\\n\\n if use_freq:\\n return filter(lambda x: barcodes[x] >= threshold, barcodes)\\n return sorted(barcodes, key=barcodes.get, reverse=True)[:threshold]\",\n \"def readlength_histogram(filename, offset=0):\\n hist = Counter()\\n with SequenceReader(filename) as fr:\\n for record in fr:\\n hist[len(record.sequence) + offset] += 1\\n return hist\",\n \"def get_genome_coverage(file_path, chrom_lengths_file):\\n lines_in_input = float(get_number_of_lines(file_path))\\n chrom_lengths = get_chrom_lengths(chrom_lengths_file)\\n genome_size = float(get_genome_size(chrom_lengths))\\n if genome_size == 0:\\n # Use default.\\n genome_size = float(MAX_GENOME_SIZE)\\n genome_coverage = '%.4f' % float(lines_in_input / genome_size)\\n return float(genome_coverage)\",\n \"def get_chromsizes_from_ucsc(genome, saveas=None, mysql='mysql', timeout=1):\\n cmds = [mysql,\\n '--user=genome',\\n '--host=genome-mysql.cse.ucsc.edu',\\n '-A',\\n '-B',\\n '-e',\\n 'select chrom, size from %s.chromInfo' % genome]\\n\\n try:\\n p = subprocess.Popen(cmds,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE,\\n )\\n stdout, stderr = p.communicate()\\n if stderr:\\n print(stderr)\\n print('Commands were:\\\\n')\\n print(subprocess.list2cmdline(cmds))\\n\\n lines = stdout.splitlines()[1:]\\n d = {}\\n for line in lines:\\n chrom, size = line.split()\\n d[chrom] = (0, int(size))\\n\\n if saveas is not None:\\n chromsizes_to_file(d, saveas)\\n\\n return d\\n\\n except OSError as err:\\n if err.errno == 2:\\n raise OSError(\\\"Can't find mysql -- if you don't have it \\\"\\n \\\"installed, you'll have to get chromsizes \\\"\\n \\\"manually, or \\\"\\n \\\"specify the path with the 'mysql' kwarg.\\\")\\n else:\\n raise\",\n \"def cnt_freq(filename):\\n freq = [0] * 256\\n try:\\n f_in = open(filename,'r')\\n except:\\n raise FileNotFoundError\\n for line in f_in:\\n for char in line:\\n freq[ord(char)] = freq[ord(char)] + 1\\n f_in.close()\\n return freq\",\n \"def est_read_len(fq, reads=100):\\n if is_gz_file(fq):\\n openf = gzip.open\\n else:\\n openf = open\\n readlens = []\\n with openf(fq) as f:\\n try: # File less than 4*reads lines\\n for _ in range(reads):\\n next(f)\\n readlens.append(len(next(f).strip()))\\n next(f), next(f)\\n except:\\n pass\\n return median(readlens)\",\n \"def get_filesize(inputfile) -> int:\\n with open(inputfile, \\\"rb\\\") as f:\\n lines = 0\\n buf_size = 1024 * 1024\\n read_f = f.raw.read\\n\\n buf = read_f(buf_size)\\n while buf:\\n lines += buf.count(b\\\"\\\\n\\\")\\n buf = read_f(buf_size)\\n\\n return lines\",\n \"def get_read_len(wildcards):\\n read_len = caseinfo.loc[(wildcards.sample, wildcards.unit), \\\"read_len\\\"]\\n return int(read_len)\",\n \"def _getMaxSize(self):\\n \\n # get gene list and related seqs\\n geneList = map(lambda l: l.strip('\\\\n'), open(self.mdapArgs[1]).readlines())\\n self.coRegSeqs = MDAP_defs.seqSubSet(geneList,self.mdapArgs[0])\\n \\n # warn user if there are missing genes\\n if self.coRegSeqs[1]:\\n sys.stderr.write('Warning: %s seqs in your gene list were not found in the fasta file provided.\\\\nA list of names follows:\\\\n%s\\\\n'\\\\\\n % (len(self.coRegSeqs[1]),str(self.coRegSeqs[1])))\\n \\n # Concatonate, get and set self.maxsize\\n return len(''.join(self.coRegSeqs[0].values()))\\n \\n \\n #----------- \",\n \"def length(analog_file):\\n if analog_file[-10:] == 'analog.brw':\\n with h5py.File(analog_file, 'r') as file:\\n print(len(file[\\\"3BData\\\"][\\\"Raw\\\"]))\\n else:\\n raise NotImplementedError(\\\"Only for use with *analog.brw files\\\")\",\n \"def file_len(full_path):\\n f = open(full_path)\\n nr_of_lines = sum(1 for line in f)\\n f.close()\\n return nr_of_lines\",\n \"def countDataSize(self,filename):\\n \\n try:\\n d = h5py.File(filename,'r')\\n except:\\n print(filename)\\n return \\n\\n N = 0\\n scan_edges = d['level2/Statistics/scan_edges'][:]\\n for (start,end) in scan_edges:\\n N += (end-start)//self.offsetLen * self.offsetLen\\n d.close()\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def find_dimesion(filename):\\n file = open(filename,\\\"r\\\")\\n\\n line = file.readline()\\n file.close()\\n return len(line.split())\",\n \"def cellranger_counts(fname, genome=\\\"matrix\\\"):\\n with tables.open_file(fname, \\\"r\\\") as f:\\n try:\\n group = f.get_node(f.root, genome)\\n except tables.NoSuchNodeError:\\n print(\\\"That genome does not exist in this file.\\\")\\n return None\\n gene_ids = getattr(group, \\\"features/id\\\").read()\\n barcodes = getattr(group, \\\"barcodes\\\").read()\\n data = getattr(group, \\\"data\\\").read()\\n indices = getattr(group, \\\"indices\\\").read()\\n indptr = getattr(group, \\\"indptr\\\").read()\\n shape = getattr(group, \\\"shape\\\").read()\\n\\n matrix = sp_sparse.csc_matrix((data, indices, indptr), shape=shape)\\n gene_ids = np.array([x.decode() for x in gene_ids])\\n barcodes = np.array([x.decode().replace(\\\"-1\\\", \\\"\\\") for x in barcodes])\\n\\n return CellRangerCounts(matrix, gene_ids, barcodes)\",\n \"def GenomeHeadItems(genome_class):\\n\\tgc = genome_class()\\n\\treturn (len(gc.headers().split(',')),gc.genome_length())\",\n \"def load_lengths(filename, return_base=False):\\n data = pd.read_csv(filename, sep=\\\"\\\\t\\\", comment=\\\"#\\\", header=None)\\n data = data.as_matrix()\\n _, idx, lengths = np.unique(data[:, 0], return_counts=True,\\n return_index=True)\\n if return_base:\\n return lengths[idx.argsort()], data[0, 3]\\n else:\\n return lengths[idx.argsort()]\",\n \"def get_singles_counts(sname, seglen, mincounts):\\n counts = defaultdict(int)\\n with open(sname) as fin:\\n infile = csv.DictReader(fin, delimiter='\\\\t')\\n for line in infile:\\n ints = int(line['interactions'])\\n if ints < mincounts:\\n continue\\n r1_reg = (\\n line['RNA1 chromosome'],int(int(line['Start of RNA1 first read'])/seglen)*seglen,\\n line['RNA1 strand'])\\n r2_reg = (\\n line['RNA2 chromosome'],int(int(line['Start of RNA2 last read'])/seglen)*seglen,\\n line['RNA2 strand'])\\n counts[r1_reg] += ints\\n counts[r2_reg] += ints\\n return counts\",\n \"def get_recording_length(file_path):\\n f = open(file_path, 'rb')\\n header = f.read(256)\\n f.close()\\n \\n return int(header[236:244].decode('ascii'))\",\n \"def get_number_of_letters(self):\\n filename = f'{self.path}/{self.filename}'\\n file = open(filename, 'r', encoding='utf-8')\\n \\\"\\\"\\\"Count number of lettes without digits, non letter characters, without xml tags\\\"\\\"\\\"\\n data = file.read()\\n data = re.sub('<.*?binary.*?>*<.*?binary.*?>',' ', data)\\n data = re.sub('\\\\\\\\s\\\\\\\\s*', '', (re.sub('\\\\\\\\W|\\\\\\\\d', ' ', re.sub('<.*?>', '', data))))\\n let_count = len(data)\\n sqlite_for_ht.CreateTable.update_table(f_1, self.filename, 'number_of_letters', let_count)\\n print(datetime.now(), '-', 'number_of_letters for', self.filename, 'calculated =', let_count)\\n return None\",\n \"def read_off_size(path):\\n try:\\n with open(path, 'r') as file:\\n lines = file.readlines()\\n if lines[0] != 'OFF\\\\n':\\n print(path, 'Error: is not an .off file')\\n num_vertices, num_faces = tuple(lines[1].split()[:2])\\n return int(num_vertices), int(num_faces)\\n except IOError:\\n print('Error: Failed reading file:', path)\",\n \"def __len__(self):\\n return self._fa.faidx.index[self.name].rlen\",\n \"def analyze_text(filename):\\n lines = 0\\n chars = 0\\n\\n with open(filename, 'r') as f:\\n for line in f:\\n lines += 1\\n chars += len(line)\\n return (lines, chars)\",\n \"def calc_GC(filepath):\\n liste=['small.exon.piRNA_2.fa', 'small.exon.piRNA_1.fa', 'small.exon.piRNA_3.fa']\\n \\n length=list(range(0,34))\\n d={}\\n for i in length:\\n d[i]={'A':0, 'G':0, 'T':0, 'C':0}\\n for i in liste:\\n with open(filepath+'/'+i, 'r') as f:\\n for line in f:\\n #fasta header starts with >\\n if line.startswith('>'):\\n pass\\n else:\\n line_l=list(line)\\n for el in range(len(line_l)):\\n if line_l[el]=='A':\\n d[el]['A']+=1\\n elif line_l[el]=='T':\\n d[el]['T']+=1\\n elif line_l[el]== 'G':\\n d[el]['G']+=1\\n elif line_l[el]== 'C':\\n d[el]['C']+=1\\n\\n df=pd.DataFrame.from_dict(d)\\n df=df.transpose()\\n df.index = np.arange(1, len(df) + 1)\\n \\n\\n df['A [%]']=df['A']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['G [%]']=df['G']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['T [%]']=df['T']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\\n df['C [%]']=df['C']/(df['A'].sum()+df['G'].sum()+df['C'].sum()+df['T'].sum())*100\",\n \"def test_count_genomic_types(self):\\n \\n result, bed_result = parse_AS_STRUCTURE_dict(\\\"test\\\", clipper.test_dir())\\n result = count_genomic_types(result)\\n \\n self.assertDictEqual(result, {\\\"CE:\\\" : 14})\",\n \"def final_kmer_counts(seq_dict, num_seqs, alphabet, min_k, max_k):\\n counted = Counter()\\n len_seqs = 0\\n for name, sequence in seq_dict.items():\\n seq = seq_cleaner(sequence, alphabet)\\n len_seqs += len(seq)\\n counted.update(count_kmers_cython(seq, min_k, max_k))\\n final_count = {k: (v // num_seqs) for k, v in counted.items()}\\n # total_len = (len_seqs // num_seqs)\\n return final_count, len_seqs\",\n \"def get_size(self):\",\n \"def getCubeSize(cubePath):\\n\\n # Make sure the input file exists\\n if not os.path.exists(cubePath):\\n raise Exception('Cube file ' + cubePath + ' not found!')\\n \\n # Use subprocess to suppress the command output\\n cmd = ['gdalinfo', cubePath]\\n p = subprocess.Popen(cmd, stdout=subprocess.PIPE)\\n textOutput, err = p.communicate()\\n\\n # Extract the size from the text\\n sizePos = textOutput.find('Size is')\\n endPos = textOutput.find('\\\\n', sizePos+7)\\n sizeStr = textOutput[sizePos+7:endPos]\\n sizeStrs = sizeStr.strip().split(',')\\n numSamples = int(sizeStrs[0])\\n numLines = int(sizeStrs[1])\\n \\n size = [numSamples, numLines]\\n return size\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6612106","0.65703803","0.6373489","0.6340387","0.629946","0.62345374","0.6110134","0.60759944","0.6062779","0.6048343","0.60378957","0.60344946","0.6015284","0.59918827","0.59908766","0.59731734","0.5965608","0.5897269","0.58564174","0.58517754","0.5796215","0.57924265","0.5790741","0.5785617","0.5770367","0.5766791","0.5762489","0.57443833","0.5742456","0.57346547","0.5712595","0.57117015","0.57035697","0.56921643","0.5687579","0.56428206","0.5641113","0.5634532","0.5628189","0.5627047","0.56233335","0.5612445","0.5606688","0.56018156","0.55927116","0.5585163","0.55772597","0.55749714","0.5573064","0.55382293","0.5536736","0.5517126","0.5513806","0.5512477","0.5507429","0.54997325","0.54979855","0.54936576","0.5489294","0.5487171","0.5484925","0.5481123","0.5479298","0.5479176","0.5470973","0.5467696","0.5466806","0.5465926","0.546331","0.54582405","0.5451404","0.54351336","0.5431411","0.5418278","0.54138196","0.5409931","0.54012424","0.5390928","0.5390921","0.5386176","0.5385939","0.5385825","0.538084","0.5370938","0.53622323","0.5361187","0.5358565","0.53524333","0.53409845","0.53345895","0.53337514","0.53333294","0.53301245","0.53213185","0.53172606","0.53080004","0.5304641","0.5302799","0.5302247","0.53012174"],"string":"[\n \"0.6612106\",\n \"0.65703803\",\n \"0.6373489\",\n \"0.6340387\",\n \"0.629946\",\n \"0.62345374\",\n \"0.6110134\",\n \"0.60759944\",\n \"0.6062779\",\n \"0.6048343\",\n \"0.60378957\",\n \"0.60344946\",\n \"0.6015284\",\n \"0.59918827\",\n \"0.59908766\",\n \"0.59731734\",\n \"0.5965608\",\n \"0.5897269\",\n \"0.58564174\",\n \"0.58517754\",\n \"0.5796215\",\n \"0.57924265\",\n \"0.5790741\",\n \"0.5785617\",\n \"0.5770367\",\n \"0.5766791\",\n \"0.5762489\",\n \"0.57443833\",\n \"0.5742456\",\n \"0.57346547\",\n \"0.5712595\",\n \"0.57117015\",\n \"0.57035697\",\n \"0.56921643\",\n \"0.5687579\",\n \"0.56428206\",\n \"0.5641113\",\n \"0.5634532\",\n \"0.5628189\",\n \"0.5627047\",\n \"0.56233335\",\n \"0.5612445\",\n \"0.5606688\",\n \"0.56018156\",\n \"0.55927116\",\n \"0.5585163\",\n \"0.55772597\",\n \"0.55749714\",\n \"0.5573064\",\n \"0.55382293\",\n \"0.5536736\",\n \"0.5517126\",\n \"0.5513806\",\n \"0.5512477\",\n \"0.5507429\",\n \"0.54997325\",\n \"0.54979855\",\n \"0.54936576\",\n \"0.5489294\",\n \"0.5487171\",\n \"0.5484925\",\n \"0.5481123\",\n \"0.5479298\",\n \"0.5479176\",\n \"0.5470973\",\n \"0.5467696\",\n \"0.5466806\",\n \"0.5465926\",\n \"0.546331\",\n \"0.54582405\",\n \"0.5451404\",\n \"0.54351336\",\n \"0.5431411\",\n \"0.5418278\",\n \"0.54138196\",\n \"0.5409931\",\n \"0.54012424\",\n \"0.5390928\",\n \"0.5390921\",\n \"0.5386176\",\n \"0.5385939\",\n \"0.5385825\",\n \"0.538084\",\n \"0.5370938\",\n \"0.53622323\",\n \"0.5361187\",\n \"0.5358565\",\n \"0.53524333\",\n \"0.53409845\",\n \"0.53345895\",\n \"0.53337514\",\n \"0.53333294\",\n \"0.53301245\",\n \"0.53213185\",\n \"0.53172606\",\n \"0.53080004\",\n \"0.5304641\",\n \"0.5302799\",\n \"0.5302247\",\n \"0.53012174\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7949907"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":905,"numItemsPerPage":100,"numTotalItems":95772,"offset":90500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTgwMjkyMiwianRpIjoiNmQ4MTI4NGEtNWYwOS00M2Y5LTgxZjAtZWFmZDNiMDNjOTk5Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU4MDY1MjIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.qqE14TvJbHDMPwUt72slr_q10CG42QpcmEL4tMpOOBtFfHxr2O2__WYWXCLruY3tpJ6nAjq1UWv_bsaPA1DuDw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
calculate the yaw of the object | def computeYaw(Vx, Vy):
#print(Vx, Vy)
if Vx > 0:
if Vy > 0:
angle = (math.degrees(math.atan2(Vy,Vx)))#+ how far it is from the x axis)
#print(angle)
return angle
elif Vy < 0:
angle = (math.degrees(math.atan2(Vy,Vx)) )#- how far from x axis)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yaw(self):\n return self._yaw",
"def get_yaw(self):\r\n return self.state['yaw']",
"def yawAngle(self):\n return self._yawAngle",
"def yaw_pitch_roll(self):\n\n self._normalise()\n yaw = np.arctan2(2*(self.q[0]*self.q[3] - self.q[1]*self.q[2]),\n 1 - 2*(self.... | [
"0.8203095",
"0.78113264",
"0.77804077",
"0.75509167",
"0.74476653",
"0.73709863",
"0.7311812",
"0.7227242",
"0.7172307",
"0.71263266",
"0.68762624",
"0.68734187",
"0.6838946",
"0.68307424",
"0.6699847",
"0.66728705",
"0.6631705",
"0.65682185",
"0.6424747",
"0.6411919",
"0.63... | 0.71707344 | 9 |
Convert coordinates into pygame coordinates. | def convert_coords(x, y, conversion):
if conversion == "cartesian" :
# convert to cartesian plane coordinates
x_new = x - (width/2)
y_new = (height/2) + y
elif conversion == "pygame":
# only needed to place images in pygame
x_new = x + (width/2)
y_new = (height... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_pygame(coords):\r\n return (coords[0], HEIGHT - coords[1])",
"def to_pygame_coords(self, coords):\n coords = Vector(coords)\n if Window.FollowPlayer:\n # offset coords by screen center\n coords = coords + (self.size * .5)\n # offset coords by centered_obj\... | [
"0.78059673",
"0.7273889",
"0.7208624",
"0.6877637",
"0.6870061",
"0.6828133",
"0.6746528",
"0.66239125",
"0.66116726",
"0.6578236",
"0.6463106",
"0.6436829",
"0.64202493",
"0.63641745",
"0.6275642",
"0.62741685",
"0.6270626",
"0.6260293",
"0.6182381",
"0.6165396",
"0.6151951... | 0.6974331 | 3 |
Set all parameters of the model to 0 Parameters. layers_dims list, the number of layers of the model and the number of nodes corresponding to each layer Returns parameters a dictionary containing all W and b W1 weight matrix with dimension (layers_dims[1], layers_dims[0]) b1 bias vector, dimension (layers_dims[1], 1) W... | def initialize_parameters_zeros(layers_dims):
parameters = {}
# the number of layers
L = len(layers_dims)
for l in range(1, L):
parameters["W" + str(l)] = np.zeros((layers_dims[l], layers_dims[l - 1]))
parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))
return parameters | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_parameters_random(layers_dims):\n # set random seed\n np.random.seed(3)\n parameters = {}\n L = len(layers_dims)\n\n for l in range(1, L):\n parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * 10\n parameters['b' + str(l)] = np.zeros((layers_... | [
"0.66994137",
"0.6524211",
"0.6484232",
"0.6440478",
"0.64257056",
"0.63918364",
"0.6384597",
"0.63792133",
"0.6360458",
"0.63285124",
"0.6324615",
"0.6255973",
"0.61910826",
"0.61910826",
"0.61910826",
"0.61248976",
"0.609352",
"0.6068253",
"0.6025813",
"0.6024569",
"0.59612... | 0.80968946 | 0 |
the parameter's dim is same as above | def initialize_parameters_random(layers_dims):
# set random seed
np.random.seed(3)
parameters = {}
L = len(layers_dims)
for l in range(1, L):
parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * 10
parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dim(self) -> int:",
"def dimension(self):",
"def dim(self):\n raise NotImplementedError",
"def dim(self):\n raise NotImplementedError()",
"def __call__(self, *args):\n return args[self.i_dim]",
"def dim(self) -> int:\n pass",
"def dim(self):\n return (self.n, )",
... | [
"0.781317",
"0.7463058",
"0.7403146",
"0.7294205",
"0.72452676",
"0.71214265",
"0.692741",
"0.6892263",
"0.68439007",
"0.6780016",
"0.6690328",
"0.665558",
"0.6597072",
"0.6597072",
"0.65559304",
"0.6551745",
"0.653437",
"0.65108186",
"0.6459135",
"0.6456878",
"0.64568514",
... | 0.0 | -1 |
Compute conventional batch mean and variance. | def _compute_batch_moments(x):
return torch.mean(x, dim=(0, 2, 3), keepdim=True), torch.var(x, dim=(0, 2, 3), keepdim=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_stat(x):\n\tmean = torch.mean(x, dim=[0, 2, 3], keepdim=True)\n\tvar = torch.mean((x-mean)**2, dim=[0, 2, 3], keepdim=True)\n\treturn mean, var",
"def _compute_mean_std(self, sum_, ssum, size):\n assert size > 1, 'BatchNorm computes unbiased standard-deviation, which requires size > 1.'\n ... | [
"0.7335093",
"0.7076149",
"0.7028218",
"0.6966497",
"0.6955343",
"0.67826116",
"0.6779366",
"0.66976017",
"0.66172445",
"0.65709674",
"0.6552331",
"0.65507686",
"0.6510585",
"0.65076244",
"0.6413702",
"0.6331475",
"0.6327264",
"0.6293395",
"0.62796533",
"0.62605953",
"0.62585... | 0.7130227 | 1 |
Compute instance mean and variance. | def _compute_instance_moments(x):
return torch.mean(x, dim=(2, 3), keepdim=True), torch.var(x, dim=(2, 3), keepdim=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_calculate_nhpp_mean_variance_inst_mean(self):\n\n _mean_var = calculate_nhpp_mean_variance(46, 3000.0, 0.332, 0.616, 2)\n self.assertAlmostEqual(_mean_var, 489.07164965)",
"def get_mean_and_variance(self):\n self._set_statistics()\n return self.statistics_object.get_mean(), s... | [
"0.7042789",
"0.7030097",
"0.684569",
"0.6785732",
"0.6705467",
"0.65460956",
"0.6473726",
"0.6455855",
"0.64296347",
"0.6423424",
"0.64022136",
"0.63945234",
"0.6373781",
"0.6314979",
"0.6271918",
"0.6263915",
"0.62379485",
"0.6202545",
"0.61835915",
"0.6181711",
"0.6178875"... | 0.7274688 | 0 |
Compute layer mean and variance. | def _compute_layer_moments(x):
return torch.mean(x, dim=(1, 2, 3), keepdim=True), torch.var(x, dim=(1, 2, 3), keepdim=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_mean(self):\n return [layer._get_mean() for layer in self.layers]",
"def variance(self, mean=None):\n raise NotImplementedError",
"def mean(self):\n return self.vmean",
"def _compute_mean_variance(self, mean_dict: Dict) -> None:\n self.eval_dict = defaultdict()\n f... | [
"0.68845415",
"0.68721896",
"0.68708557",
"0.6631005",
"0.6604006",
"0.6520616",
"0.6506461",
"0.6493008",
"0.6486367",
"0.64617854",
"0.643203",
"0.639767",
"0.6389797",
"0.6380059",
"0.6377723",
"0.6370964",
"0.63681614",
"0.636281",
"0.6351963",
"0.6349545",
"0.6343845",
... | 0.69694275 | 0 |
Combine batch moments with augment moments using blend factor alpha. | def _compute_pooled_moments(x, alpha, batch_mean, batch_var, augment_moment_fn):
augment_mean, augment_var = augment_moment_fn(x)
pooled_mean = alpha * batch_mean + (1.0 - alpha) * augment_mean
batch_mean_diff = batch_mean - pooled_mean
augment_mean_diff = augment_mean - pooled_mean
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def alpha_blend(input_image, segmentation_mask, alpha=0.5):\n blended = np.zeros(input_image.size, dtype=np.float32)\n blended = input_image * alpha + segmentation_mask * (1 - alpha)\n return blended",
"def blending_example2():\n pic_earth = read_image(relpath(\"./externals/pic_earth.jpg\"), 2)\n ... | [
"0.59165734",
"0.57801425",
"0.57290673",
"0.56443745",
"0.5604431",
"0.5587423",
"0.55799013",
"0.55666465",
"0.55648756",
"0.55581915",
"0.55063105",
"0.5502954",
"0.5480455",
"0.5472708",
"0.5440756",
"0.5434398",
"0.5434398",
"0.5413661",
"0.5396812",
"0.53911597",
"0.538... | 0.6051326 | 0 |
The parameters here get registered after initialization because the pretrained resnet model does not have these parameters and would fail to load if these were declared at initialization. | def register_extra_weights(self):
device = self.weight.device
# Initialize and register the learned parameters 'a' (SCALE) and 'b' (OFFSET)
# for calculating alpha as a function of context size.
a = torch.Tensor([0.0]).to(device)
b = torch.Tensor([0.0]).to(device)
self.r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_training_params(self, params):\n self.lyapunov_hybrid_system.lyapunov_relu.load_state_dict(\n params[\"lyap_relu_params\"])\n if not self.R_options.fixed_R:\n self.R_options._variables = params[\"R_params\"].clone()\n if isinstance(self.lyapunov_hybrid_system.sys... | [
"0.68823785",
"0.6851002",
"0.6845517",
"0.6694499",
"0.6601292",
"0.6566945",
"0.6486249",
"0.64748377",
"0.6469585",
"0.64005995",
"0.63946164",
"0.6357663",
"0.6351537",
"0.63105786",
"0.6289853",
"0.62844247",
"0.62796485",
"0.62754023",
"0.62484515",
"0.6247907",
"0.6222... | 0.0 | -1 |
Provides the function to compute augment moemnts. | def _get_augment_moment_fn(self):
pass # always override this function | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_augment_moment_fn(self):\n return self._compute_instance_moments",
"def augment(self, image):\n pass",
"def apply_augmentations(self, x, augmentations):\r\n # print(\"\\n#####################\\nSQDataset.apply_augmentations: x shape == \", x.shape)\r\n # print(\"SQDataset.a... | [
"0.64456785",
"0.63316554",
"0.62134147",
"0.61737436",
"0.6164592",
"0.6051583",
"0.60132986",
"0.6005452",
"0.5988301",
"0.59473735",
"0.5941723",
"0.5938459",
"0.5922076",
"0.5920503",
"0.58844405",
"0.5810467",
"0.57589525",
"0.5726853",
"0.56997806",
"0.56924295",
"0.569... | 0.635719 | 1 |
Override the base class to get the function to compute instance moments. | def _get_augment_moment_fn(self):
return self._compute_instance_moments | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def moments(self):",
"def _compute_instance_moments(x):\n return torch.mean(x, dim=(2, 3), keepdim=True), torch.var(x, dim=(2, 3), keepdim=True)",
"def _get_augment_moment_fn(self):\n pass # always override this function",
"def getMomentum(self):\n return self.p",
"def _moments_match_nume... | [
"0.7662759",
"0.68491524",
"0.68225145",
"0.57082653",
"0.56545275",
"0.56478214",
"0.5608952",
"0.55368495",
"0.5529006",
"0.5525961",
"0.5501195",
"0.54991955",
"0.54955935",
"0.5492941",
"0.5492941",
"0.54882663",
"0.53813344",
"0.53759295",
"0.53658104",
"0.532169",
"0.53... | 0.7838273 | 0 |
RadiationModel() returns a DataFrame of which the size depends on the input. The time resolution for the output is a quarter ("15T") by default but can be changed with the "TimeResolution" parameter. | def __init__(self, t0, t1, hours=("00:00", "23:45"),
forecast_zones="DK", norm=False, TimeResolution="15T"):
self.t0 = t0
self.t1 = t1
self.muni_input = forecast_zones
self.norm = norm
self.Time = TimeResolution
self.fc_zones = self._muni_interpr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_TTR(self) -> pd.DataFrame:\n\n # user options\n res = self.options.resolution\n dim = self.options.dimension\n\n # sample the corpus\n x_choices = (np.arange(res) + 1) / res\n TTR = [self.sample(x=x).as_datarow(dim) for x in x_choices]\n\n # save to sel... | [
"0.566602",
"0.55865186",
"0.55567604",
"0.55247164",
"0.5453741",
"0.54424953",
"0.5365442",
"0.5311694",
"0.5263339",
"0.52498996",
"0.5234416",
"0.52332824",
"0.52237743",
"0.52104026",
"0.5177271",
"0.515588",
"0.5075149",
"0.50734264",
"0.5069924",
"0.5063935",
"0.506119... | 0.0 | -1 |
Handles muni input as either list (or array like) or some predefined strings. | def _muni_interpreter(self, muni_input):
if isinstance(muni_input, (list, tuple, np.ndarray)):
return(muni_input)
elif muni_input == "all":
if not hasattr(self, 'muni_info'):
self._load_muni_info()
return(list(self.muni_info.index[3:]))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input2strlist_nomapfile(invar):\n \n str_list = None\n if type(invar) is str:\n if invar.startswith('[') and invar.endswith(']'):\n str_list = [f.strip(' \\'\\\"') for f in invar.strip('[]').split(',')]\n else:\n str_list = [invar.strip(' \\'\\\"')]\n elif type(in... | [
"0.61064446",
"0.6048012",
"0.60012585",
"0.5989305",
"0.5966896",
"0.5906677",
"0.59033054",
"0.58828855",
"0.5752301",
"0.57429147",
"0.5707196",
"0.5682213",
"0.5681342",
"0.5658818",
"0.5644289",
"0.5642251",
"0.5619448",
"0.5618888",
"0.55098224",
"0.548022",
"0.54716176... | 0.6802392 | 0 |
Make sure we can store a string and retrieve it. | def test_put_and_get():
test_key = 'qmk_compiler_test_unique_key_name'
# Make sure our test key doesn't exist
try:
qmk_storage.get(test_key)
raise RuntimeError('%s exists on S3 when it should not!' % test_key)
except Exception as e:
if e.__class__.__name__ != 'NoSuchKey':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def store_string(self, string: str) -> None:",
"def test_get_value_str(self):\n val = self.setting_str.get_value()\n self.assertIsInstance(val, str)\n self.assertEqual(val, 'test')",
"def test_get_value_str(self):\n val = self.setting_str.get_value()\n self.assertIsInstance(v... | [
"0.7784715",
"0.6122228",
"0.6122228",
"0.61021465",
"0.59463865",
"0.59263575",
"0.5916713",
"0.58905464",
"0.5887827",
"0.58563024",
"0.58510256",
"0.58482605",
"0.58470726",
"0.58311313",
"0.5813009",
"0.5805731",
"0.5805206",
"0.5759576",
"0.57541996",
"0.5738663",
"0.571... | 0.0 | -1 |
Create and then delete an object from s3, make sure we can't fetch it afterward. | def test_delete():
test_key = 'qmk_compiler_test_unique_key_name'
# Make sure our test key doesn't exist
try:
qmk_storage.get(test_key)
raise RuntimeError('%s exists on S3 when it should not!' % test_key)
except Exception as e:
if e.__class__.__name__ != 'NoSuchKey':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _removeAWSS3Object(self, path: str):\n log.warning(f'Deleting AWS S3 object {path}')\n bucket, key = storage_utils.SplitStoragePath(path)\n s3_client = boto3.client('s3')\n try:\n s3_client.delete_object(Bucket=bucket, Key=key)\n except Exception as error: # pylint: disable=broad-except\n ... | [
"0.7155508",
"0.69353044",
"0.66972363",
"0.6665433",
"0.6630202",
"0.66159564",
"0.65772355",
"0.6512925",
"0.64956784",
"0.6417047",
"0.63897026",
"0.6348161",
"0.627056",
"0.6259172",
"0.6250383",
"0.61582154",
"0.6149929",
"0.6120848",
"0.6094047",
"0.60888565",
"0.603231... | 0.56207746 | 69 |
Make sure we can list objects on S3. | def test_list_objects():
x = 0
for obj in qmk_storage.list_objects():
assert 'Key' in obj
assert type(obj.get('LastModified')) == datetime.datetime
if x > 5:
break
x += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_public_s3_objects(self):\n _response = urllib.urlopen(self.options.s3_bucket_url)\n _html = _response.read()\n\n if LOCAL_DEBUG:\n print _html\n\n try:\n assert \"AccessDenied\" not in _html\n assert \"NoSuchBucket\" not in _html\n except:\n print(\"ERROR: AccessDenied o... | [
"0.7614375",
"0.7051694",
"0.67730415",
"0.6648005",
"0.6610973",
"0.66037107",
"0.6603098",
"0.65443665",
"0.6526971",
"0.634856",
"0.6333928",
"0.6296448",
"0.62847036",
"0.62788695",
"0.62781334",
"0.6244884",
"0.6211903",
"0.62019926",
"0.6147974",
"0.61345005",
"0.613410... | 0.0 | -1 |
Make sure we can stream filelike objects to S3. | def test_save_fd():
test_key = 'qmk_compiler_test_unique_key_name'
# Make sure our test key doesn't exist
try:
qmk_storage.get(test_key)
raise RuntimeError('%s exists on S3 when it should not!' % test_key)
except Exception as e:
if e.__class__.__name__ != 'NoSuchKey':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _s3_stash(self):\n s3_url = 's3://{}/{}'.format(BUCKET, self.atom_file)\n bucketpath = BUCKET.strip(\"/\")\n bucketbase = BUCKET.split(\"/\")[0]\n parts = urlparse.urlsplit(s3_url)\n mimetype = 'application/xml' \n \n conn = boto.connect_s3()\n\n try:\n ... | [
"0.6714194",
"0.6538487",
"0.64656186",
"0.6400292",
"0.62917095",
"0.62451416",
"0.6186291",
"0.6185394",
"0.6147944",
"0.61407965",
"0.6138119",
"0.61183417",
"0.61051106",
"0.610099",
"0.60936815",
"0.6061965",
"0.60556763",
"0.60543287",
"0.6051277",
"0.6039379",
"0.60314... | 0.0 | -1 |
Make sure we can store a file and retrieve it. | def test_save_file():
test_key = 'qmk_compiler_test_unique_key_name'
# Make sure our test key doesn't exist
try:
qmk_storage.get(test_key)
raise RuntimeError('%s exists on S3 when it should not!' % test_key)
except Exception as e:
if e.__class__.__name__ != 'NoSuchKey':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def store(self, filename):",
"def ensure_file(self):\n if not self.has_file():\n raise AttributeError(\"No file set\")",
"def test_get_file(self):\n django_file = None\n \n with open(TEST_AVATAR_PATH, 'rb') as avatar:\n self.user.avatar_tmp = File(avatar)\n ... | [
"0.6567378",
"0.6410996",
"0.6294041",
"0.62256885",
"0.6012488",
"0.60082453",
"0.5987928",
"0.59667057",
"0.59397805",
"0.5928058",
"0.5901034",
"0.58676183",
"0.58391476",
"0.58256185",
"0.58020294",
"0.5774438",
"0.5768754",
"0.57649964",
"0.57503694",
"0.57429343",
"0.57... | 0.0 | -1 |
Make sure we can get a file with a filelike interface | def test_get_fd():
test_key = 'qmk_compiler_test_unique_key_name'
# Make sure our test key doesn't exist
try:
qmk_storage.get(test_key)
raise RuntimeError('%s exists on S3 when it should not!' % test_key)
except Exception as e:
if e.__class__.__name__ != 'NoSuchKey':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_file_object(self):\n pass",
"def _file_format_adapter(self):\n raise NotImplementedError",
"def _get_file_object(inputfile=None):\n if type(inputfile) == str:\n return open(inputfile, 'r')\n return inputfile",
"def _get_filelike(string, encoding):\n import _io as io... | [
"0.7177712",
"0.68210065",
"0.6792964",
"0.64844126",
"0.64717895",
"0.63765824",
"0.63413405",
"0.6337909",
"0.6312321",
"0.6231084",
"0.62086606",
"0.6177126",
"0.6120128",
"0.61107844",
"0.6102432",
"0.609374",
"0.60691303",
"0.6064178",
"0.6041926",
"0.6038978",
"0.603695... | 0.0 | -1 |
This takes the number to guess and the guess and compares them | def compare(number_to_guess, guess):
if guess > number_to_guess:
print('Too high. \n Guess again')
elif guess < number_to_guess:
print('Too low. \n Guess again')
else:
print(f'You got it! The answer was {number_to_guess}') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_guess(number, guess):\r\n if number == guess:\r\n return False, \"you won.\"\r\n elif number < guess:\r\n return True, \"too high.\"\r\n else:\r\n return True, \"too low.\"",
"def checkGuess(guess, secretNum): \n if guess < secretNum:\n return \"Your guess is ... | [
"0.7632458",
"0.7420763",
"0.7156625",
"0.7070007",
"0.7053276",
"0.6971584",
"0.6961167",
"0.69260126",
"0.6814522",
"0.67901284",
"0.6761293",
"0.67394257",
"0.6682385",
"0.6645885",
"0.6593592",
"0.6592362",
"0.6556644",
"0.65454453",
"0.65333205",
"0.65158445",
"0.6447257... | 0.76252204 | 1 |
Update the neb energies and forces | def get_neb_energies_forces(self):
energies = []
forces = []
for i in self.path.inner_images:
e, f = self.model.predict_energy_and_forces(i)
energies.append(e)
forces.append(f)
self.model_forces = forces
self.energies[1:-1] = energies
s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_forces(self):\r\n # update all the functions\r\n self.compute_gravity()\r\n self.compute_tides()\r\n self.compute_centrifugal()\r\n self.compute_coriolis()\r\n\r\n # add together the forces into the summation function\r\n self.forcing.assign(self.ftides+s... | [
"0.7071552",
"0.7028039",
"0.6974602",
"0.60360223",
"0.60316986",
"0.6016974",
"0.5976503",
"0.59699845",
"0.5962121",
"0.5897876",
"0.5874239",
"0.58718544",
"0.584177",
"0.58307546",
"0.5797778",
"0.5794067",
"0.578954",
"0.5766696",
"0.57582974",
"0.575816",
"0.5734929",
... | 0.71072215 | 0 |
Update CI NEB energies and forces for images of indices | def get_ci_energies_forces(self, indices: List[int]):
self.get_neb_energies_forces()
for i in indices:
if i < 1 or i > len(self.path) - 2:
raise ValueError('Index %d is at boundary' % i)
self.forces[i] = self.model_forces[i] - 2 * np.sum(self.model_forces[i] * sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_neb_energies_forces(self):\n energies = []\n forces = []\n for i in self.path.inner_images:\n e, f = self.model.predict_energy_and_forces(i)\n energies.append(e)\n forces.append(f)\n self.model_forces = forces\n self.energies[1:-1] = energ... | [
"0.59176993",
"0.5626548",
"0.5580271",
"0.5580271",
"0.55643463",
"0.5498005",
"0.540635",
"0.5385511",
"0.53412944",
"0.53172666",
"0.5275748",
"0.5260982",
"0.52208763",
"0.52207667",
"0.52154756",
"0.5145676",
"0.5142759",
"0.51413727",
"0.5129286",
"0.5127432",
"0.512379... | 0.63668287 | 0 |
Opinion Lexicon (or Sentiment Lexicon) Bing Liu (~6.800 entries) | def read_bing_liu():
fp = ta_config.BING_LIU_positive
fn = ta_config.BING_LIU_negative
lexicon = defaultdict()
with open(fp, "r") as raw_file:
reader = csv.reader(raw_file)
for i in range(35):
next(reader)
for row in reader:
lexicon[row[0].replace("-", "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def performLexiconBasedSentimentAnalysis(data):\n opinions = data[0]\n taggedTweets = data[3]\n sentiments_mapping = lexiconBasedSentimentPrediction(\n taggedTweets) # identify the sentiment orientation of each tweet\n for key in sentiments_mapping:\n opinions[key].setSO(sentiments_mappi... | [
"0.66169864",
"0.63280505",
"0.62549835",
"0.60124046",
"0.5934756",
"0.59308743",
"0.589986",
"0.5878562",
"0.5845378",
"0.57806647",
"0.5737055",
"0.57287276",
"0.57061267",
"0.5689893",
"0.568618",
"0.56512994",
"0.5585707",
"0.55769116",
"0.55455333",
"0.5544087",
"0.5541... | 0.5265308 | 64 |
MPQA (MultiPerspective Question Answering) Subjectivity Lexicon (8.222 entries) | def read_mpqa():
fname = ta_config.MPQA
with open(fname, "r") as f:
lines = f.read().splitlines()
entries = [tuple(line.split("\t")) for line in lines]
lexicon = defaultdict(dict)
for entry in entries:
priorpolarity = entry[5].split('=')[1]
pos_map = {'no... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def possession_ques(analysis):\n\n #processing as statement\n phrase = statement(analysis)\n\n #We have to know if it is plural or singular\n if other_functions.plural_noun(analysis.sn) == 1:\n return ['whose'] + phrase[:len(phrase) - 1] + ['these'] + ['?']\n else:\n return ['whose'] +... | [
"0.5961933",
"0.5959305",
"0.58352005",
"0.58204293",
"0.575788",
"0.57116324",
"0.5685468",
"0.56761533",
"0.5612229",
"0.5584282",
"0.5581954",
"0.5495818",
"0.5487884",
"0.5465028",
"0.5460172",
"0.5444511",
"0.5440515",
"0.5398719",
"0.53861916",
"0.53840286",
"0.5369511"... | 0.74378127 | 0 |
AFINN is a list of English words rated for valence with an integer between minus five (negative) and plus five (positive). The words have been manually labeled by Finn Arup Nielsen in 20092011. The file is tabseparated 2477 words and phrases. | def read_affin():
filename = ta_config.AFFIN
with open(filename, "r") as f:
reader = csv.reader(f, delimiter="\t")
lexicon = defaultdict(dict)
for row in reader:
word = row[0]
score = row[1]
lexicon[word] = {
"positive": 1 if score > 0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_afinn():\n \n afinn = dict()\n print(\"Reading Afinn words........\")\n with open('AFINN-111.txt', 'r') as val:\n for line in val:\n l = line.strip().split()\n if len(l) == 2:\n afinn[l[0]] = int(l[1])\n\n print(' %d AFINN words are read.' % (len(... | [
"0.6993629",
"0.611835",
"0.5791885",
"0.5501247",
"0.5458271",
"0.5242966",
"0.518413",
"0.5075442",
"0.506856",
"0.49806586",
"0.49069563",
"0.48904803",
"0.48904535",
"0.48791325",
"0.48773",
"0.48743063",
"0.48621935",
"0.4858531",
"0.48235747",
"0.48226544",
"0.48213983"... | 0.561662 | 3 |
Parse the xml file | def parseXML(xmlFile, strL):
f = open(xmlFile)
xml = f.read()
f.close()
tree = etree.parse(BytesIO(xml.encode('utf-8')))
#context = etree.iterparse(BytesIO(xml.encode('utf-8')))
data = tree.getroot()
blockID = '0'
for action in data:
if action.get('id') == '1':
blockID = action.get('id')
strL... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __parse(self):\n\t\tparser=xml.sax.make_parser()\n\t\tparser.setContentHandler(OSMXMLFileParser(self))\n\t\tparser.parse(self.filename)\n\t\n\t\t# convert them back to lists\n\t\tself.nodes = self.nodes.values()\n\t\tself.ways = self.ways.values()\n\t\tself.relations = self.relations.values()",
"def parsexml... | [
"0.75176644",
"0.74928975",
"0.7201614",
"0.7178409",
"0.7175466",
"0.7081453",
"0.69014853",
"0.6880011",
"0.6851029",
"0.68418354",
"0.67601335",
"0.6757079",
"0.6751641",
"0.6712353",
"0.6670032",
"0.6667893",
"0.66315633",
"0.6615761",
"0.6610617",
"0.66074437",
"0.656138... | 0.5956294 | 58 |
Qlearning is based on DISCRETE actions. Therefore, if we want to correct for Zernike aberrations which are continuous, we have to discretize the action space | def __init__(self, N_zern, initial_state, DM_stroke=0.05):
aberration_correction = [DM_stroke, -DM_stroke]
self.ACTION = N_zern * aberration_correction
### Initialize Zernike polynomials
x = np.linspace(-1, 1, self.N_pix, endpoint=True)
xx, yy = np.meshgrid(x, x)
rho, t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def learn(self, state, action, reward, next_state):\r\n\r\n \"\"\"Please Fill Your Code Here.\r\n \"\"\"\r\n self.Q[state][action] = self.Q[state][action] + self.alpha * (reward + self.gamma * max(self.Q[next_state]) - self.Q[state][action])\r\n\r\n return 0",
"def choose_action( self... | [
"0.66756207",
"0.65098524",
"0.65061414",
"0.6481986",
"0.63933593",
"0.6383092",
"0.6234665",
"0.6221809",
"0.6213232",
"0.61575735",
"0.61553764",
"0.61485934",
"0.6123872",
"0.61120117",
"0.60807794",
"0.5981917",
"0.59812754",
"0.5977964",
"0.5975286",
"0.5967645",
"0.595... | 0.0 | -1 |
Compute the PEAK of the PSF without aberrations so that we can normalize everything by it | def peak_PSF(self):
return self.compute_PSF(np.zeros(self.N_zern)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def peak_PSF(self):\n im, strehl = self.compute_PSF(np.zeros(self.N_act))\n return strehl",
"def pulp_smash():",
"def cal_pn(grams_set, grams, candidate, reference):\n count = 0\n for gram in grams_set:\n # print(gram)\n count += count_clip(gram, grams, reference)\n # calcu... | [
"0.60213965",
"0.5855361",
"0.5634777",
"0.5621128",
"0.5568037",
"0.55468833",
"0.5537976",
"0.55128574",
"0.54912055",
"0.5485965",
"0.538236",
"0.5360213",
"0.53334594",
"0.53278303",
"0.5325024",
"0.53225136",
"0.5314099",
"0.5313874",
"0.52809626",
"0.5279202",
"0.527653... | 0.5827183 | 2 |
Creates an epsilongreedy policy based on a given Qfunction and epsilon. Returns a function that takes the state as an input and returns the probabilities for each action in the form of a numpy array of length of the action space(set of possible actions). | def createEpsilonGreedyPolicy(Q, epsilon, num_actions):
def policyFunction(state):
Action_probabilities = np.ones(num_actions,
dtype=float) * epsilon / num_actions
best_action = np.argmax(Q[state])
Action_probabilities[best_action] += (1.0 - epsilon)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createEpsilonGreedyPolicy(Q, epsilon, num_actions):\n def policyFunction(state):\n\n Action_probabilities = np.ones(num_actions,\n dtype = float) * epsilon / num_actions\n\n best_action = np.argmax(Q[state])\n Action_probabilities[best_action] += (1.0 - epsilon)\n ... | [
"0.85712636",
"0.79445827",
"0.7728248",
"0.7678616",
"0.76707244",
"0.75580287",
"0.7514789",
"0.744547",
"0.73657966",
"0.73407954",
"0.7282954",
"0.7080421",
"0.7035401",
"0.70255274",
"0.69141966",
"0.6895311",
"0.6749669",
"0.6707011",
"0.6700968",
"0.6691628",
"0.667362... | 0.8536859 | 1 |
Gets inventory for user with ``user_id``. | def get_ingredients_in_progress(cls, user_id: str) -> list:
ingredients = IngredientController.get_ingredients(user_id=user_id)
data = []
for ingredient in ingredients:
curr_stock_data = cls.get_in_stock_data(ingredient=ingredient)
in_progress_data = cls.get_query().filt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_inventory_with_http_info(self, user_id, id, **kwargs):\n\n all_params = ['user_id', 'id']\n all_params.append('async')\n all_params.append('_return_http_data_only')\n all_params.append('_preload_content')\n all_params.append('_request_timeout')\n\n params = lo... | [
"0.7569133",
"0.7155626",
"0.6762009",
"0.66601497",
"0.66140306",
"0.65519214",
"0.6390761",
"0.6237989",
"0.62156236",
"0.60586905",
"0.6012444",
"0.5902178",
"0.5890392",
"0.58257943",
"0.5816766",
"0.58158743",
"0.5763474",
"0.5743524",
"0.571121",
"0.56950724",
"0.568245... | 0.5242527 | 95 |
Gets all ingredients in progress for user with ``user_id``. | def get_in_stock_data(cls, ingredient: dict) -> tuple:
curr_stock = float(ingredient["currentStock"])
curr_stock_decimal = float(ingredient["currentStockEquivalent"]) / float(ingredient["capacityEquivalent"])
curr_stock_percentage = float(100) * curr_stock_decimal
return curr_stock, cur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ingredients_in_progress(cls, user_id: str) -> list:\n ingredients = IngredientController.get_ingredients(user_id=user_id)\n data = []\n\n for ingredient in ingredients:\n curr_stock_data = cls.get_in_stock_data(ingredient=ingredient)\n in_progress_data = cls.get_q... | [
"0.82737595",
"0.77235246",
"0.6530208",
"0.62933844",
"0.62313634",
"0.5976115",
"0.5850843",
"0.5776963",
"0.570023",
"0.5661846",
"0.5653032",
"0.56467754",
"0.55553746",
"0.5512869",
"0.5502797",
"0.54599315",
"0.5439984",
"0.5435582",
"0.5389472",
"0.53699523",
"0.535007... | 0.0 | -1 |
Deletes ingredient in progress for user with ``user_id``. | def delete_ingredients_in_progress(cls, user_id: str, ingredient_id: str):
session: Session = cls.get_session()
ingredient_in_progress = cls.get_query().filter(
and_(
IngredientsInProgressModel.ingredient_id == ingredient_id,
IngredientsInProgressModel.user_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self, user_id):\n pass",
"def delete(self, user: 'UserCondensed'):\n self._delete(entity=user)",
"async def red_delete_data_for_user(self, *, requester, user_id):\n return",
"async def red_delete_data_for_user(self, *, requester, user_id):\n return",
"def delete_item(... | [
"0.678601",
"0.66784865",
"0.66746336",
"0.66746336",
"0.6618471",
"0.65111923",
"0.6441183",
"0.6438016",
"0.64127743",
"0.6369499",
"0.6331467",
"0.6273206",
"0.62685937",
"0.62605387",
"0.62178457",
"0.61816704",
"0.61548245",
"0.6083064",
"0.6066107",
"0.60525554",
"0.602... | 0.858545 | 0 |
set an author by default | def get_form(self, request, *args, **kwargs):
form = super().get_form(request, *args, **kwargs)
form.base_fields['author'].initial = request.user
return form | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_author (self, author):\n self.author = author",
"def setAuthor(self,value):\n self.PDFreactorConfiguration.in1[\"author\"] = value",
"def set_author(self, author):\n self.author = author\n self.opf.author = author",
"def author(self, value):\n self._set_attr('author... | [
"0.8252654",
"0.82439995",
"0.8213634",
"0.81213117",
"0.80845183",
"0.8008694",
"0.7875689",
"0.781252",
"0.781252",
"0.77202326",
"0.75019264",
"0.7146604",
"0.70541865",
"0.6889957",
"0.6874267",
"0.6835159",
"0.6833864",
"0.67333144",
"0.6685209",
"0.66688204",
"0.6666579... | 0.64095044 | 39 |
Example parsing code for a CSV source. | def parse_cases(raw_data_file: str, source_id: str, source_url: str):
with open(raw_data_file, "r") as f:
reader = csv.DictReader(f)
for row in reader:
case = {
"caseReference": {
"sourceId": source_id,
"sourceUrl": source_url,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_csv(self):\n try:\n reader = csv.reader(open(self.options.datafile, 'r'))\n except IOError:\n errormsg(_('Cannot read \"{}\"'.format(self.options.datafile)))\n raise Exception(_('Cannot read \"{}\"'.format(self.options.datafile)))\n if self.options.v... | [
"0.6806217",
"0.6775352",
"0.67593104",
"0.65402895",
"0.65128577",
"0.65104544",
"0.64284414",
"0.6417455",
"0.6400888",
"0.63765883",
"0.63530666",
"0.63315237",
"0.62040013",
"0.6188222",
"0.6160359",
"0.61375195",
"0.6134819",
"0.6079229",
"0.605635",
"0.605257",
"0.60455... | 0.59040284 | 34 |
Get a specific users details | def get(self, user_id):
user = UserModel.find_by_id(user_id)
# print(user)
# print(user.json())
if user is None:
return {"error": "User not found"}
return {"user": user.json()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_users_info(): \n \n data = user_obj.get_users_info()\n return data",
"def get_user_profile(self):\n return self.request('get', 'id/users')",
"def get_user_details():\n rv = query_db('select * from user')\n return rv[0] if rv else None",
"def show(user_id):\n return users.get_... | [
"0.7819347",
"0.749697",
"0.74156606",
"0.72951585",
"0.7266293",
"0.72311664",
"0.7205414",
"0.7146677",
"0.7114651",
"0.70705914",
"0.7045462",
"0.70427537",
"0.70305145",
"0.70301265",
"0.7024021",
"0.7016661",
"0.701514",
"0.69674814",
"0.69592905",
"0.69330657",
"0.69309... | 0.0 | -1 |
Get the top users | def get(self):
users = UserModel.get_top_earners()
users_json = [user.json() for user in users]
return {"users": users_json} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTopUsers(self):\n\n\t\tquery = \"\"\"select M.user_id, count( distinct M.venue_id) as cnt\n\t\t\t\t\tfrom\n\t\t\t\t\t(\n\t\t\t\t\tselect J.user_id, J.venue_id, J.latitude, J.longitude, J.Homelat, J.Homelong,\n\t\t\t\t\tCASE\n\t\t\t\t\t\tWHEN J.latitude = J.Homelat and J.longitude = J.Homelong THEN 1\n\t\t\t... | [
"0.8160978",
"0.78488797",
"0.7793435",
"0.7471113",
"0.73085314",
"0.7147013",
"0.7104958",
"0.6948201",
"0.67802286",
"0.6777022",
"0.6769666",
"0.67549616",
"0.6740057",
"0.67323506",
"0.67101157",
"0.6645782",
"0.6604185",
"0.6591461",
"0.6571291",
"0.6565868",
"0.6499772... | 0.6374396 | 24 |
Get the list of all jobs owned by user | def get(self, user_id):
user = UserModel.find_by_id(user_id)
jobs = [job.json() for job in user.posted_jobs]
return {"jobs": jobs} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queryset(self):\n qs = Job.objects.filter(user=self.request.user)\n return qs",
"def list_jobs(user_data, cache):\n user = cache.ensure_user(user_data)\n\n jobs = []\n for job in cache.get_jobs(user):\n try:\n if job.project_id:\n job.project = cach... | [
"0.74576366",
"0.7313575",
"0.71735066",
"0.70125955",
"0.70085806",
"0.69305784",
"0.6763451",
"0.66647565",
"0.66647565",
"0.6635297",
"0.663202",
"0.662919",
"0.6612873",
"0.65772283",
"0.65222675",
"0.6484244",
"0.6477744",
"0.6405315",
"0.63975054",
"0.6392879",
"0.63916... | 0.6504865 | 15 |
Get a list of jobs the user has volunteered for | def get(self, user_id):
user = UserModel.find_by_id(user_id)
print("Getting volunteered jobs")
jobs = [job.json() for job in user.volunteered_jobs]
return {"jobs": jobs} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_job_list(self):\n return self.job_list",
"def get_job_list(self):\n return self.job_list",
"def get(self):\n # TODO: auth\n return list(self.app.db.jobs.find())",
"def get_job_query(self):\n context = aq_inner(self.context)\n catalog = getToolByName(context, 'portal_... | [
"0.6712661",
"0.6712661",
"0.66783905",
"0.6636779",
"0.6613315",
"0.65323234",
"0.6438695",
"0.64050114",
"0.63789976",
"0.6336263",
"0.63244027",
"0.6301153",
"0.6282709",
"0.62449884",
"0.61884457",
"0.61836964",
"0.6181903",
"0.61756855",
"0.61736864",
"0.6167379",
"0.614... | 0.7515113 | 0 |
Allocate a 2dimensional array, with the specified initial value. May do weird things with objects, I'm not sure. >>> alloc2d(2,5) [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]] >>> alloc2d(2,2,"x") [['x', 'x'], ['x', 'x']] | def alloc2d(x,y,iv=0):
return [[iv for j in range(int(x))] for i in range(int(y))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_two_d_array(dimens, val):\n w, x = dimens\n return [[val for j in range(x)] for i in range(w)]",
"def create2d(row_count, col_count, value=None):\n a = [None] * row_count\n for row in range(row_count):\n a[row] = [value] * col_count\n return a",
"def init_one_d_array(len, val):\n... | [
"0.65265894",
"0.645137",
"0.6148947",
"0.60284287",
"0.5584389",
"0.5562695",
"0.5459762",
"0.544923",
"0.54422444",
"0.54183143",
"0.5393952",
"0.53860515",
"0.5328383",
"0.5234134",
"0.5222009",
"0.51992697",
"0.51929575",
"0.51736486",
"0.5124553",
"0.5068666",
"0.5011701... | 0.6807487 | 0 |
Swap around the keys and values of a dictionary (i.e. flip on the diagonal) | def swapdict(d):
x = {}
for k, v in d.iteritems():
x[v] = k
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dictflip(dictionary):\n\n return {v: k for k, v in dictionary.items()}",
"def InvertDict(dict_in):\n return dict(zip(dict_in.values(), dict_in.keys()))",
"def reverse(dictionary):\n return {b: a for a, b in dictionary.items()}",
"def invert(d):\n if d:\n return [dict(zip(d, i)) for i i... | [
"0.74185795",
"0.6716613",
"0.6570254",
"0.6523662",
"0.63917285",
"0.6351405",
"0.6295982",
"0.62575823",
"0.6197628",
"0.6113169",
"0.60507005",
"0.5998684",
"0.5996646",
"0.59498805",
"0.59498805",
"0.5944426",
"0.5940815",
"0.59240943",
"0.59042305",
"0.5894332",
"0.58929... | 0.6341142 | 6 |
Swap the values and indices of a list. Values default to None if something is doubled up and not specified. Values should be numbers, because they will become indices! >>> el = [0,4,1,3,2] basic list >>> swaplist(el) [0, 2, 4, 3, 1] >>> swaplist(swaplist(el)) == el invertable True >>> swaplist([0, 1, 2]) already match ... | def swaplist(l, base=0):
r = [None] * len(l)
for i, v in enumerate(l):
r[v - base] = i + base
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def swap(in_list: List, index1: int, index2: int) -> List:\n\n in_list[index1], in_list[index2] = in_list[index2], in_list[index1] \n\n return in_list",
"def swap(lst: list, index_1: int, index_2: int) -> None:\n lst[index_1], lst[index_2] = lst[index_2], lst[index_1]",
"def _swap(mylist, a, b):\n ... | [
"0.7364025",
"0.72524476",
"0.72344494",
"0.72169846",
"0.71410453",
"0.71264017",
"0.7103082",
"0.683433",
"0.68322676",
"0.67205346",
"0.65408766",
"0.6530119",
"0.6401396",
"0.63965213",
"0.62192625",
"0.6189153",
"0.61377716",
"0.59910136",
"0.5957726",
"0.59556746",
"0.5... | 0.62726593 | 14 |
Subtract the list b from a, return a copy >>> sublist([1, 2, 3, 4, 5], [2, 3]) [1, 4, 5] | def sublist(a, b):
r = a[:]
for i in b:
r.remove(i)
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def listSubtract(alist,blist):\n result = []\n for item in alist:\n if item not in blist:\n result.append(item)\n return result",
"def list_subtract(a, b):\n a_only = list(a)\n for x in b:\n if x in a_only:\n a_only.remove(x)\n return a_only",
"def sub_list... | [
"0.7625603",
"0.75862557",
"0.70652115",
"0.7039867",
"0.69050086",
"0.6803992",
"0.66484016",
"0.66435206",
"0.6537795",
"0.6537795",
"0.6537795",
"0.64460796",
"0.6338398",
"0.62913436",
"0.6228029",
"0.61968637",
"0.61660093",
"0.6100752",
"0.6035787",
"0.60106146",
"0.600... | 0.7964486 | 0 |
Recursively mkdir() when necessary to ensure a path exists Kinda like mkdir p | def rmkdir(path):
t = []
sep = os.path.sep
if sep != "/":
parts = path.replace(os.path.sep, "/").split("/")
else:
parts = path.split(sep)
if path[0] == "/":
t = ["/" + parts[0]]
parts = parts[1:]
for p in parts:
t.append(p)
# I chose ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mkdir(path):\n\tif not Path(path).exists():\n\t\tPath(path).mkdir(parents=True, exist_ok=True)",
"def _mkdir_p(path):\n if not osp.exists(path):\n os.makedirs(path)",
"def mkdir(path):",
"def mkdir_p(path):\n try:\n os.makedirs(path) # , exist_ok=True\n except OSError:\n pas... | [
"0.82731116",
"0.8173715",
"0.80575997",
"0.8045974",
"0.8042844",
"0.8042844",
"0.80413026",
"0.80393386",
"0.80019957",
"0.7990324",
"0.7987171",
"0.7981489",
"0.7981489",
"0.7964019",
"0.7953215",
"0.7949716",
"0.79429233",
"0.7914269",
"0.78956777",
"0.78757656",
"0.78671... | 0.0 | -1 |
Adds a RgbdSensor to to the scene_graph at (fixed) pose X_PC relative to the parent_frame. If depth_camera is None, then a default camera info will be used. If renderer is None, then we will assume the name 'my_renderer', and create a VTK renderer if a renderer of that name doesn't exist. If parent_frame is None, then ... | def AddRgbdSensor(
builder,
scene_graph,
X_PC,
depth_camera=None,
renderer=None,
parent_frame_id=None,
):
if sys.platform == "linux" and os.getenv("DISPLAY") is None:
from pyvirtualdisplay import Display
virtual_display = Display(visible=0, size=(1400, 900))
virtual_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def AddRgbdSensors(\n builder,\n plant,\n scene_graph,\n also_add_point_clouds=True,\n model_instance_prefix=\"camera\",\n depth_camera=None,\n renderer=None,\n):\n if sys.platform == \"linux\" and os.getenv(\"DISPLAY\") is None:\n from pyvirtualdisplay import Display\n\n virt... | [
"0.6333064",
"0.5002681",
"0.4995963",
"0.4986556",
"0.4950906",
"0.4458174",
"0.44040585",
"0.43817294",
"0.43758163",
"0.43542552",
"0.43490773",
"0.43313876",
"0.43151295",
"0.4292971",
"0.42469728",
"0.4221219",
"0.4216358",
"0.42138645",
"0.4201191",
"0.4180696",
"0.4163... | 0.8106876 | 0 |
Adds a RgbdSensor to the first body in the plant for every model instance with a name starting with model_instance_prefix. If depth_camera is None, then a default camera info will be used. If renderer is None, then we will assume the name 'my_renderer', and create a VTK renderer if a renderer of that name doesn't exist... | def AddRgbdSensors(
builder,
plant,
scene_graph,
also_add_point_clouds=True,
model_instance_prefix="camera",
depth_camera=None,
renderer=None,
):
if sys.platform == "linux" and os.getenv("DISPLAY") is None:
from pyvirtualdisplay import Display
virtual_display = Display(v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def AddRgbdSensor(\n builder,\n scene_graph,\n X_PC,\n depth_camera=None,\n renderer=None,\n parent_frame_id=None,\n):\n if sys.platform == \"linux\" and os.getenv(\"DISPLAY\") is None:\n from pyvirtualdisplay import Display\n\n virtual_display = Display(visible=0, size=(1400, 90... | [
"0.60445213",
"0.47997555",
"0.47449347",
"0.46184856",
"0.45942456",
"0.43920726",
"0.43797317",
"0.4326893",
"0.42549992",
"0.42535293",
"0.4234432",
"0.42307407",
"0.42210782",
"0.42094594",
"0.41918367",
"0.4191364",
"0.41856608",
"0.41717416",
"0.41657764",
"0.41477117",
... | 0.7247001 | 0 |
Adds illustration geometry representing the coordinate frame, with the xaxis drawn in red, the yaxis in green and the zaxis in blue. The axes point in +x, +y and +z directions, respectively. | def AddTriad(
source_id,
frame_id,
scene_graph,
length=0.25,
radius=0.01,
opacity=1.0,
X_FT=RigidTransform(),
name="frame",
):
# x-axis
X_TG = RigidTransform(
RotationMatrix.MakeYRotation(np.pi / 2), [length / 2.0, 0, 0]
)
geom = GeometryInstance(
X_FT.mul... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_geometry(self):\n import matplotlib.pyplot as plt\n fig_geom = plt.figure()\n ax_geom = fig_geom.add_subplot(111)\n rectangle = []\n for i in range(len(self.coordinates)):\n rectangle.append(plt.Rectangle((self.coordinates[i][0],\n ... | [
"0.60328215",
"0.5996463",
"0.5956841",
"0.58766353",
"0.584359",
"0.5682301",
"0.5665153",
"0.5662804",
"0.5646933",
"0.5517312",
"0.54503894",
"0.54486495",
"0.54443985",
"0.54315335",
"0.540777",
"0.54059607",
"0.53843856",
"0.53843856",
"0.53731394",
"0.53583723",
"0.5347... | 0.0 | -1 |
Do not return anything, modify nums1 inplace instead. | def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
# nums1 = [1,2,3,0,0,0], m = 3
# nums2 = [2,5,6], n = 3
i = 0
for num2 in nums2:
n -= 1
while i <= m - 1:
if nums1[i] < num2:
i += 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge1(self, nums1, m, nums2, n): \n nums1[:m].extend(nums2[:n]) # 此方法改变了nums1的指向,无效\n # extend没改变指向，但是切片改了 \n nums1[:m] + nums2[:n] # 此方法改变了nums1的指向,无效\n # +号改变了指向\n\n nums1.sort()",
"def merge(self, nums1, m, nums2, n):\n nums1.extend([0]*... | [
"0.7024941",
"0.7011506",
"0.700616",
"0.6987223",
"0.6916323",
"0.68455774",
"0.68288964",
"0.68022573",
"0.6770004",
"0.67557144",
"0.67438185",
"0.67422545",
"0.6737672",
"0.6709356",
"0.6707213",
"0.6683853",
"0.6668475",
"0.6639533",
"0.6638752",
"0.6636657",
"0.6634697"... | 0.66302735 | 22 |
Given a participant_id, return a participant_id. If we can claim the given participant_id, we will. Otherwise we'll find a random one that isn't taken yet. Whichever we return is guaranteed to be claimed in the database. | def claim_id(participant_id):
seatbelt = 0
while 1:
try:
db.execute( "INSERT INTO participants (id) VALUES (%s)"
, (participant_id,)
)
except IntegrityError: # Collision, try again with a random value.
participant_id = hex(int... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getParticipant(self, discordId):\n if discordId in participants:\n return participants[discordId]\n else:\n return None",
"def participant_id(self):\n return self.data[\"id\"]",
"def get_authorized_user(p):\n if Participant.objects.filter(psid=p).count() == 0:\... | [
"0.586102",
"0.57109445",
"0.55985445",
"0.5515024",
"0.53133464",
"0.52435404",
"0.51992923",
"0.5119271",
"0.51169336",
"0.50899434",
"0.5082975",
"0.50726396",
"0.50724584",
"0.5045251",
"0.49716988",
"0.49658343",
"0.496167",
"0.4956202",
"0.49425507",
"0.49274588",
"0.49... | 0.7340709 | 0 |
Given two str, return a participant_id. | def resolve(login):
FETCH = """\
SELECT participant_id
FROM social_network_users
WHERE network='github'
AND user_info -> 'login' = %s
""" # XXX Uniqueness constraint on login?
rec = db.fetchone(FETCH, (login,))
if rec is Non... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_id(self):\n\t\tx , y = self.id.split(':')\n\t\treturn int(x), int(y)",
"def create_id(uid, begintime, endtime):\n allowed_chars = string.ascii_lowercase[:22] + string.digits\n temp = re.sub('[^{}]'.format(allowed_chars), '', uid.lower())\n return re.sub('[^{}]'.format(allowed_chars), '', uid.lo... | [
"0.5985564",
"0.5962005",
"0.5810053",
"0.5755434",
"0.54641163",
"0.5442869",
"0.53757674",
"0.5325997",
"0.5302757",
"0.52820987",
"0.5280876",
"0.526967",
"0.52021563",
"0.5186585",
"0.51583683",
"0.51234263",
"0.5106121",
"0.5097307",
"0.50853866",
"0.506013",
"0.50570905... | 0.49279866 | 35 |
Given str, unicode, unicode, and dict, return unicode and boolean. Network is the name of a social network that we support (ASCII blah). User_id is an immutable unique identifier for the given user on the given social network. Username is the user's login/user_id on the given social network. We will try to claim that f... | def upsert(network, user_id, username, user_info, claim=False):
typecheck( network, str
, user_id, (int, unicode)
, user_info, dict
)
user_id = unicode(user_id)
# Record the user info in our database.
# =====================================
INSERT = """\
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def username(provider, username):\n\n if provider == 'alditalk':\n if username.isdigit(): # only mobile number\n return True\n else:\n return False\n elif provider == 'netzclub': # mobile number and email\n if ((username.isdigit()) or (... | [
"0.51669383",
"0.5083092",
"0.49614066",
"0.49047366",
"0.48961347",
"0.4839635",
"0.47655556",
"0.4718195",
"0.47101656",
"0.46781144",
"0.46727902",
"0.46368912",
"0.46256196",
"0.46220523",
"0.46210793",
"0.4603513",
"0.45982912",
"0.45585674",
"0.45509598",
"0.45504412",
... | 0.60893 | 0 |
Load initial simulation data | def loadSimData(datafile):
global dt, ti, Lx, Ly, nsamp, N, M, L, B, totalStep, Fmc, Kbend, kT, \
dtSamp, T, box_area, nt, body_length, Pe, persistence, flexure
datafile = open(datafile,"r")
for line in datafile:
A = line.split()
if A[0] == "dt": # Time interval... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_test_data(self):\n self._save_test_data()",
"def load_data(self) -> None:",
"def load_data(self):\n if self.debug:\n print(\"Loading data\")",
"def initialise_sim(self):\n pass",
"def initialize_simulation(self) -> Simulation:\n pass",
"def load_data(self)... | [
"0.68683255",
"0.67498815",
"0.67211765",
"0.6705084",
"0.66544074",
"0.6615124",
"0.65464187",
"0.6518159",
"0.6498119",
"0.64464325",
"0.6364063",
"0.6356504",
"0.63125604",
"0.63113856",
"0.6292319",
"0.6265532",
"0.6231823",
"0.6209781",
"0.61972326",
"0.61970484",
"0.619... | 0.6294475 | 14 |
Assign colors to beads indices based on the cluster they belong | def colorToBeads(clidx, filament_list, color, part_list_x, part_list_y, part_list_phi):
cl_beads_x = []
cl_beads_y = []
cl_beads_p = []
for i in filament_list:
for j in range(N):
ind = int(i*N+j)
clidx[ind] = color
cl_beads_x.append(part_list_x[ind])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_cluster(self, cluster):\n for patch in cluster:\n patch.config(fill=\"red\")",
"def node_colors(self, nodes):\n zmin, zmax = nodes[:, 2].min(), nodes[:, 2].max()\n start_color = np.array(self.background) + 5\n end_color = np.array(self.nodeColor)\n z = (node... | [
"0.6752229",
"0.6413582",
"0.6365808",
"0.62394375",
"0.62341064",
"0.6156939",
"0.60395414",
"0.5976058",
"0.5893515",
"0.5878506",
"0.5829808",
"0.5804872",
"0.57884765",
"0.57642937",
"0.5725985",
"0.57257324",
"0.5701969",
"0.5693013",
"0.5686574",
"0.5674862",
"0.5640789... | 0.59784216 | 7 |
Find the indices of the largest 5 clusters in the system | def findIndex(cluster_size, cluster_idx, tracked_clusters, index_tracked_clusters):
print 'Update is conducting'
# Calculate the largest 5 clusters
size_arr = np.asarray(cluster_size)
maxs = -bot.partsort(-size_arr, 5)[:5] # 5 largest clusters
maxs = sorted(maxs, reverse=True)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clusters(self):\n return np.argmax(self.alpha[:, :, 0], axis=0)",
"def get_cluster_indices(self,dataset, cluster_number):\n\t\tself.__init__(dataset, self.k)\n\t\tself.e_step() #got responsibilities\n\t\tmax_cluster = np.argmax(self.w, axis = 1)\n\t\tindices = []\n\t\tfor i in range(dataset.shape[0]):... | [
"0.6519562",
"0.65038353",
"0.64770246",
"0.64451647",
"0.64059144",
"0.63642323",
"0.6343986",
"0.6262098",
"0.61906475",
"0.6190452",
"0.6188377",
"0.61648357",
"0.61436564",
"0.61352074",
"0.61263",
"0.61253023",
"0.609048",
"0.6041876",
"0.6037949",
"0.6018775",
"0.601396... | 0.66095847 | 0 |
Find the indices of the largest cluster in the system | def findSpecificIndex(cluster_size, cluster_idx, tracked_clusters, index_tracked_clusters, indi):
# Calculate the largest cluster
maxi = max(cluster_size)
# Index the largest cluster
for i, cs in enumerate(cluster_size):
if cs == maxi:
index_tracked_clusters[indi] = i ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_largest_cluster(self) -> tuple:\n flat_cluster = self.cluster.reshape(-1)\n true_clusters = np.extract(flat_cluster > 0, flat_cluster)\n counts = np.bincount(true_clusters)\n largest = np.argmax(counts)\n size = counts[largest]\n return largest, size",
"def maxCl... | [
"0.7134205",
"0.6980508",
"0.6905988",
"0.69008315",
"0.67803144",
"0.6777812",
"0.67298543",
"0.6696416",
"0.6619129",
"0.65645915",
"0.65588987",
"0.6476951",
"0.6383289",
"0.63413584",
"0.6317239",
"0.631608",
"0.62252176",
"0.62064445",
"0.62033117",
"0.6182841",
"0.61767... | 0.6476292 | 12 |
Find the array index of cluster indices to access elements of the cluster information | def findArrayIndex(cluster_idx, tracked_clusters, index_tracked_clusters):
found = np.zeros(5, dtype=int)
# Index the clusters again since the unique cluster ids may be changed
for i, indi in enumerate(cluster_idx):
if indi == tracked_clusters[0]:
index_tracked_clusters[0] = i
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cluster_indices(self,dataset, cluster_number):\n\t\tself.__init__(dataset, self.k)\n\t\tself.e_step() #got responsibilities\n\t\tmax_cluster = np.argmax(self.w, axis = 1)\n\t\tindices = []\n\t\tfor i in range(dataset.shape[0]):\n\t\t\tif max_cluster[i] == cluster_number:\n\t\t\t\tindices.append(i)\n\t\tret... | [
"0.716429",
"0.71586674",
"0.6817519",
"0.6754379",
"0.66942763",
"0.66888386",
"0.6679992",
"0.6642885",
"0.6531381",
"0.6458431",
"0.6403385",
"0.6389278",
"0.6359146",
"0.6343633",
"0.62577176",
"0.624503",
"0.62423474",
"0.6216787",
"0.61988443",
"0.61608666",
"0.6144706"... | 0.7065493 | 2 |
Greedy algorithm which finds a probable mutation subgraph for given nodes. This algorithm chooses splits within the tree based on which mutation occurs most frequently, weighted by the prior probabilities of each mutation state for each character. Strings with NA ('') as a state in the split character are segregated wi... | def greedy_build(nodes, priors=None, cutoff=200, considered=set(), uniq='', targets=[]):
# Tracks frequency of states for each character in nodes
character_mutation_mapping = defaultdict(int)
# G models the network that is returned recursively
G = nx.DiGraph()
root = root_finder(nodes)
# Base case check for r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def greedy_learn(self,node,db,labels,ids):\n if node.depth >= self.maxdepth or len(ids) <= self.minexamples:\n #terminate recursion\n node.pick_best_label(db,labels,ids)\n err = misclassification_error([labels[id] for id in ids])\n if err > 0:\n pri... | [
"0.590502",
"0.5824857",
"0.58222175",
"0.5818163",
"0.5810747",
"0.5779823",
"0.57535565",
"0.572609",
"0.5676844",
"0.5671201",
"0.5649606",
"0.56414163",
"0.5636852",
"0.5616348",
"0.56067246",
"0.5597054",
"0.55416656",
"0.5537339",
"0.55193657",
"0.55169916",
"0.5503138"... | 0.7791946 | 0 |
If class' attribute is accessed and it does not exist, this method will be called. | def __getattr__(self, name):
def func(*args, **kwargs):
# Python gives arguments as a tuple, convert them to list.
f = getattr(self.obj, name)
if not callable(f):
return f
# Print the function call as it would be written in code.
a = '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_class_attribute(self):\n return self.class_attr",
"def class_attr(self, attr, ignore_protected):\n protected = False if not ignore_protected else self.protected_attr(attr)\n return re.match('^(?!__).*', attr) and not callable(getattr(self, attr)) and not protected",
"def identify_c... | [
"0.64051455",
"0.6383376",
"0.6280858",
"0.6135352",
"0.61144465",
"0.6098986",
"0.60924375",
"0.60924375",
"0.6068345",
"0.6041043",
"0.6018358",
"0.6006583",
"0.5995561",
"0.595049",
"0.5933787",
"0.591861",
"0.59055686",
"0.59027994",
"0.5867237",
"0.5861424",
"0.5860365",... | 0.0 | -1 |
return all columns as a dictionary, data presented in sql format | def _getValues(self):
res = {}
for colname, column in self._iterNameColumn():
res[colname] = column.toSql(self._values[colname])
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _as_dict(self):\r\n values = self._dynamic_columns or {}\r\n for name, col in self._columns.items():\r\n values[name] = col.to_database(getattr(self, name, None))\r\n return values",
"def as_dict(self):\r\n values = {}\r\n for name, col in self._columns.items():\... | [
"0.7897001",
"0.7752987",
"0.7322894",
"0.7274344",
"0.72569364",
"0.72569364",
"0.72569364",
"0.72569364",
"0.7232694",
"0.7187313",
"0.718492",
"0.7174157",
"0.7159821",
"0.7130308",
"0.7062997",
"0.7037842",
"0.7029279",
"0.7029279",
"0.699056",
"0.699056",
"0.699056",
"... | 0.75123715 | 2 |
return all columns as a dictionary, data presented as strings | def _getStrValues(self):
res = {}
for colname in self._iterName():
res[colname] = str(self._values[colname])
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _as_dict(self):\r\n values = self._dynamic_columns or {}\r\n for name, col in self._columns.items():\r\n values[name] = col.to_database(getattr(self, name, None))\r\n return values",
"def as_dict(self) -> Dict[str, Any]:\n return {\n column_title: cell.value\... | [
"0.7178168",
"0.70843846",
"0.70544076",
"0.7044062",
"0.70232564",
"0.68531674",
"0.6817989",
"0.6817989",
"0.6817989",
"0.6817989",
"0.6817989",
"0.6794319",
"0.678346",
"0.678346",
"0.678346",
"0.678346",
"0.67630386",
"0.6753806",
"0.67057407",
"0.6687591",
"0.66824704",
... | 0.70319206 | 4 |
Compares the weather forecast of two cities passed in | def get_weather_forecast_comparison(user_city, explored_city, days=7):
user_city_forecast = weather_client.getForecastWeather(q=user_city, days=days)['forecast']['forecastday']
explored_city_forecast = weather_client.getForecastWeather(q=explored_city, days=days)['forecast']['forecastday']
weather_forecast_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_weather_forecast_comparison(user_city=\"lagos\", explored_city=\"london\", days=7):\n user_city_forecast = weather_client.getForecastWeather(q=user_city, days=days)['forecast']['forecastday']\n explored_city_forecast = weather_client.getForecastWeather(q=explored_city, days=days)['forecast']['forecas... | [
"0.71536994",
"0.6245935",
"0.6226744",
"0.60275173",
"0.5958302",
"0.57983166",
"0.5735847",
"0.56872874",
"0.5631134",
"0.5619025",
"0.5510218",
"0.5439192",
"0.5397346",
"0.53896284",
"0.5317874",
"0.52734953",
"0.5242966",
"0.5232327",
"0.521958",
"0.5216427",
"0.5195094"... | 0.7030591 | 1 |
This returns a dictionary of relevant weather info | def get_weather_info(forecast):
day_forecast = {}
try:
day_forecast['condition_text'] = forecast['day']['condition']['text']
# this icon is a url to an image that describes the weather condition
day_forecast['condition_icon_url'] = forecast['day']['condition']['icon']
day_forecas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_weather(self):\n with urllib.request.urlopen(self.url) as response:\n json_data = response.read().decode('utf-8')\n\n data = json.loads(json_data)\n\n weather = {}\n weather['current'] = {\n 'temp': round(data['current']['temp_f']),\n 'humidity':... | [
"0.75960606",
"0.7591139",
"0.759041",
"0.75648737",
"0.74014914",
"0.7290076",
"0.72553915",
"0.7060927",
"0.6992882",
"0.69674724",
"0.69420385",
"0.69393855",
"0.6929554",
"0.6903778",
"0.68632424",
"0.680844",
"0.6804196",
"0.67913526",
"0.670719",
"0.66605264",
"0.665604... | 0.6845341 | 15 |
Convert pixels of the image to world coordinates | def get_world_coords(self):
# get pixel cordinates
(H, W, _) = self.shape
i, j = numpy.indices((H, W), dtype=numpy.float32)
# Rescale to UV coordinates. u is to the right, v is up.
u = rescale(0, W - 1, -1, 1, j)
v = rescale(0, H - 1, 1, -1, i)
# Because I alway... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pointToWorld( nImageX, nImageY, rDepth, rMaxX = 320, rMaxY = 240, rFieldOfViewX = 60, rFieldOfViewY = 40 ):\n # convert to [-0.5,0.5]\n rCenteredX = ( nImageX / rMaxX ) - 0.5;\n rCenteredY = ( nImageY / rMaxY ) - 0.5;",
"def Pixel2World(geoMatrix, x, y):\r\n ulX = geoMatrix[0]\r\n ulY = geoMat... | [
"0.75094324",
"0.7325349",
"0.7322535",
"0.7198944",
"0.7048137",
"0.7047548",
"0.69544333",
"0.66800016",
"0.6670515",
"0.665026",
"0.6632581",
"0.6566683",
"0.65048647",
"0.63582677",
"0.63332766",
"0.6328008",
"0.6324152",
"0.6288652",
"0.62716603",
"0.6234238",
"0.6233980... | 0.6962051 | 6 |
Convert world space coordinates to pixel coordinates | def to_indices(self, world_coords):
(x, y, z) = world_coords
(cx, cy, cz) = self.center
px = x - cx
py = y - cy
pz = z - cz
# project u and v
# TODO: Can this be done with some built-in Numpy operation?
(ux, uy, uz) = self.u_dir
(vx, vy, vz) = se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def world2Pixel(geoMatrix, x, y):\r\n ulX = geoMatrix[0]\r\n ulY = geoMatrix[3]\r\n xDist = geoMatrix[1]\r\n yDist = geoMatrix[5]\r\n rtnX = geoMatrix[2]\r\n rtnY = geoMatrix[4]\r\n # pixel = int((x - ulX) / xDist)\r\n # line = int((ulY - y) / xDist)\r\n # Floor for x and ceiling for y s... | [
"0.7813827",
"0.7644184",
"0.7641467",
"0.75160825",
"0.73816305",
"0.72449976",
"0.71286684",
"0.71147805",
"0.7101196",
"0.7005821",
"0.69036907",
"0.68787587",
"0.6874656",
"0.68495816",
"0.6820127",
"0.68121105",
"0.6807642",
"0.6774522",
"0.6698339",
"0.66840273",
"0.666... | 0.63809294 | 38 |
Returns True if the given term tuple (fieldname, text) is in this reader. | def __contains__(self, term):
fieldname, text = term
query = dict(fieldname=fieldname, text=text)
return bool(self.index.collection.find(query).count()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def contains(self, term):\n\t\tif term in self.textFile:\n\t\t\treturn True\n\t\t\n\t\treturn False",
"def _is_term_exist(self, term):\n return term in self.postingDict",
"def __contains__(self, doc_label):\n return doc_label in self.docs",
"def __contains__(self, item):\n return item in... | [
"0.7650702",
"0.68390197",
"0.6475184",
"0.6443119",
"0.6418949",
"0.63440895",
"0.63410914",
"0.6325038",
"0.6281455",
"0.6252877",
"0.6130331",
"0.6100055",
"0.60711753",
"0.5990042",
"0.5925225",
"0.59213024",
"0.59145826",
"0.5882695",
"0.58655465",
"0.58621746",
"0.58379... | 0.7103255 | 1 |
Yields (fieldname, text, docfreq, indexfreq) tuples for each term in the reader, in lexical order. | def __iter__(self):
fields = 'fieldname', 'text', 'docfreq', 'indexfreq'
cur = self.index.collection.find(fields=fields).sort('fieldname')
return (tuple(rec[field] for field in fields) for rec in cur) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter_from(self, fieldname, text):\n\t\tfields = 'fieldname', 'text', 'docfreq', 'indexfreq'\n\t\tcur = self.index.collection.find(fields=fields).sort('fieldname')\n\t\treturn (tuple(rec[field] for field in fields) for rec in cur\n\t\t\tif rec['fieldname'] >= fieldname)",
"def docTermCountMapper( (docname, te... | [
"0.6394344",
"0.63895833",
"0.63554066",
"0.6069107",
"0.59565014",
"0.595314",
"0.58934623",
"0.5815445",
"0.5812689",
"0.5799563",
"0.5794913",
"0.57896703",
"0.57124174",
"0.56017923",
"0.5583592",
"0.55833954",
"0.5558156",
"0.5510152",
"0.54602987",
"0.5457762",
"0.54360... | 0.61912984 | 3 |
Yields (field_num, text, doc_freq, index_freq) tuples for all terms in the reader, starting at the given term. | def iter_from(self, fieldname, text):
fields = 'fieldname', 'text', 'docfreq', 'indexfreq'
cur = self.index.collection.find(fields=fields).sort('fieldname')
return (tuple(rec[field] for field in fields) for rec in cur
if rec['fieldname'] >= fieldname) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def docTermCountMapper( (docname, term), (payload, n)):\n yield docname, (term, payload, n)",
"def corpusTermCountMapper( (term, docname), (payload, n, N) ):\n yield term, (docname, payload, n, N, 1)",
"def terms(self) -> Tuple[Term, ...]:\n ...",
"def corpusTermCountReducer(term, values):\n ... | [
"0.68192494",
"0.6475116",
"0.61195904",
"0.5971918",
"0.59598106",
"0.5913069",
"0.58945346",
"0.5879545",
"0.5876062",
"0.5830351",
"0.5784476",
"0.57442003",
"0.5735431",
"0.56609225",
"0.56596565",
"0.5655239",
"0.5642833",
"0.56098855",
"0.5602108",
"0.56014043",
"0.5596... | 0.63166904 | 2 |
Returns the stored fields for the given document number. | def stored_fields(self, docnum):
return self.index.collection.get(docnum).keys() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stored_fields(self, docnum):\r\n return self.doc_reader[docnum]",
"def getFieldNumbers():\n return _getCampaignDict()[\"field_numbers\"]",
"def field_by_number(self, number):\r\n return self._by_number[number]",
"def field_by_number(cls, number):\n return cls.__by_number[number]",... | [
"0.83763015",
"0.68768024",
"0.6653822",
"0.621729",
"0.6031412",
"0.5998559",
"0.5727719",
"0.5719909",
"0.5710211",
"0.56648844",
"0.5622993",
"0.5617283",
"0.5602116",
"0.558327",
"0.5546262",
"0.5530749",
"0.5526932",
"0.5522419",
"0.5505145",
"0.5499001",
"0.5497499",
... | 0.83722156 | 1 |
Returns the total number of documents, DELETED OR UNDELETED, in this reader. | def doc_count_all(self):
return self.index.collection.count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_total_number_of_documents(self):\n return self.total_number_of_documents",
"def doc_count(self):\n\t\treturn self.index.collection.count()",
"def count_deleted(self):\n count = 0\n for _, e in self.contents.items():\n count = count + e.count_deleted()\n return cou... | [
"0.7694914",
"0.7510874",
"0.7456718",
"0.74369824",
"0.7400394",
"0.7376454",
"0.7318653",
"0.70306486",
"0.6979551",
"0.69476104",
"0.6910956",
"0.68551785",
"0.6845533",
"0.67889684",
"0.67852783",
"0.67809534",
"0.675962",
"0.6714335",
"0.6646297",
"0.66243535",
"0.661896... | 0.7317203 | 7 |
Returns the total number of UNDELETED documents in this reader. | def doc_count(self):
return self.index.collection.count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_deleted(self):\n count = 0\n for _, e in self.contents.items():\n count = count + e.count_deleted()\n return count",
"def count_deleted(self): # EntryList.count_deleted\n count=0\n for name, e in self.contents.iteritems():\n count = co... | [
"0.774052",
"0.7685259",
"0.7200083",
"0.71623373",
"0.6974863",
"0.69508916",
"0.68825483",
"0.6874336",
"0.67723584",
"0.65331846",
"0.6532005",
"0.64764756",
"0.64342594",
"0.6419995",
"0.64097446",
"0.639157",
"0.63764316",
"0.6351271",
"0.63395876",
"0.62947416",
"0.6248... | 0.65769726 | 9 |
Returns the number of terms in the given field in the given document. This is used by some scoring algorithms. | def doc_field_length(self, docnum, fieldname, default=0):
doc = self.index.collection.get(docnum, fields=[fieldname])
field = doc['field']
return len(field) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def doc_frequency(self, fieldname, text):\n\t\tquery = {fieldname: text}\n\t\treturn self.index.collection.find(query).count()",
"def count_term_in_document(self, term, document):\n doc = self.get_document(document)\n for docterm, value in doc.get_terms():\n if docterm == term:\n ... | [
"0.72676206",
"0.7165055",
"0.70114183",
"0.66553545",
"0.64877266",
"0.6448544",
"0.64057785",
"0.6239052",
"0.62141967",
"0.6161071",
"0.6133754",
"0.61203957",
"0.61141217",
"0.6107903",
"0.6076252",
"0.60743505",
"0.60632855",
"0.6061969",
"0.6047227",
"0.60395795",
"0.60... | 0.613099 | 11 |
Returns how many documents the given term appears in. | def doc_frequency(self, fieldname, text):
query = {fieldname: text}
return self.index.collection.find(query).count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_term_in_document(self, term, document):\n doc = self.get_document(document)\n for docterm, value in doc.get_terms():\n if docterm == term:\n return value\n return 0",
"def count_term_distinct_documents(self, term):\n term_entry = self.get_term(term)... | [
"0.8144007",
"0.7901063",
"0.7805863",
"0.7593704",
"0.7337906",
"0.72929275",
"0.70913726",
"0.7029171",
"0.700253",
"0.69935983",
"0.6934074",
"0.6844122",
"0.68305665",
"0.6751197",
"0.6741464",
"0.67233396",
"0.66798115",
"0.6657282",
"0.6632745",
"0.6621583",
"0.66213256... | 0.65604246 | 24 |
Returns the total number of terms in the given field. This is used by some scoring algorithms. | def field_length(self, fieldname):
# todo: is this right?
query = {fieldname: {'$exists': 1}}
return self.index.collection.find(query).count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_term(self, term):\n term_entry = self.get_term(term)\n if term_entry:\n return term_entry.count\n else:\n return 0",
"def all_for_field(self, field):\n sum_ = 0\n for cat, cat_name in self.CATEGORIES:\n val = getattr(self, '%s_%s' % (c... | [
"0.6676837",
"0.65731615",
"0.64483917",
"0.6415971",
"0.6294213",
"0.61543",
"0.6123947",
"0.6059807",
"0.60554504",
"0.60289246",
"0.59715825",
"0.59456694",
"0.59362334",
"0.5894546",
"0.5893738",
"0.5855221",
"0.58436567",
"0.5833092",
"0.5828044",
"0.5794682",
"0.5728545... | 0.5903449 | 13 |
This function takes a ply that does not contain colored faces and convert it to a colored file format. Note that if you want to work with the colors | def colorize(filename):
# Read data from existing ply
plydata = PlyData.read(filename)
# Return false if the file already contains colored faces
properties = str(plydata['face'].properties)
if "red" and "green" and "blue" and "counter" in properties:
return True
faces = plydata['face'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_pointcloud(rgb_file, mask_file,depth_file,ply_file):\n rgb = Image.open(rgb_file)\n # depth = Image.open(depth_file)\n depth = Image.open(depth_file).convert('I')\n mask = Image.open(mask_file).convert('I')\n\n # if rgb.size != depth.size:\n # raise Exception(\"Color and depth im... | [
"0.58714455",
"0.57085764",
"0.56858146",
"0.54114306",
"0.5275804",
"0.5268924",
"0.5008679",
"0.49845684",
"0.4942795",
"0.49143073",
"0.4902455",
"0.4884634",
"0.48557335",
"0.48439094",
"0.48289695",
"0.48243293",
"0.48167127",
"0.47649246",
"0.47608292",
"0.4744698",
"0.... | 0.72984517 | 0 |
Calculate distance between two vectors. | def distance(self, vector1, vector2, type_):
if type_ == "braycurtis":
return distance.braycurtis(vector1, vector2)
elif type_ == "canberra":
return distance.canberra(vector1, vector2)
elif type_ == "chebyshev":
return distance.chebyshev(vector1, vector2)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _vector_dist(self, vec1, vec2):\r\n return sqrt(sum([(float(v1) - float(v2)) ** 2 for v1, v2 in\r\n zip(vec1, vec2)]))",
"def dist(v1: vect2d, v2: vect2d) -> float:\n d = ((v2.x - v1.x)**2 + (v2.y - v1.y)**2) ** 0.5\n return d",
"def distance(v1, v2):\r\n return magnit... | [
"0.84512544",
"0.7946819",
"0.7885775",
"0.77465785",
"0.77394795",
"0.76349956",
"0.7605549",
"0.7579331",
"0.754522",
"0.7451612",
"0.7417736",
"0.7382795",
"0.7381552",
"0.73787606",
"0.7359042",
"0.7357606",
"0.73309225",
"0.73192996",
"0.72966",
"0.7295556",
"0.72912675"... | 0.0 | -1 |
Use trained model to classify a document. | def classify(self, document, k, distance_type="sqeuclidean"):
if k == 0:
raise ValueError("Must enter positive value for k parameter.")
# If only one neighbor, do more optimal calculation
if k == 1:
return self.__classify_nearest_neighbor(document... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def model(self):\n filePath = self.config['data_path']['train_data']\n data = self.loadCSV(filePath)\n cleandata = self.preprocess(data)\n X, y = self.dataSplit(cleandata)\n X = self.CountVect(X, self.config['transform_path']['transform_model_path'])\n X_train, X_test, y_t... | [
"0.6856484",
"0.6855123",
"0.65202457",
"0.64663416",
"0.6446124",
"0.62844443",
"0.62707925",
"0.6240914",
"0.619588",
"0.61694115",
"0.61624026",
"0.6160073",
"0.6160073",
"0.6157931",
"0.61330557",
"0.6119248",
"0.60993385",
"0.60628384",
"0.60483456",
"0.6022452",
"0.6005... | 0.0 | -1 |
Special case of knearest neighbors where k= = 1. | def __classify_nearest_neighbor(self, document, distance_type):
min_distance = sys.float_info.max
min_class = ""
for index in self.vectors.shape[0]:
vector = self.vectors[index:].data.tolist()
distance = self.distance(document, vector, distance_type)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_nearest_neighbors_idx(X, x, k):\n ## homework:start\n result = \n ## homework:end\n return result",
"def k_nearest_neighbors(x_test, df_training, k):\n\n return np.argpartition(distance_to_each_training_point(x_test,\n df_training)... | [
"0.746246",
"0.7261196",
"0.7228868",
"0.72147983",
"0.7099051",
"0.709009",
"0.6993821",
"0.6966697",
"0.69588214",
"0.6923221",
"0.69164014",
"0.690752",
"0.68625754",
"0.6857904",
"0.68447673",
"0.68146485",
"0.6767023",
"0.6753044",
"0.669507",
"0.668546",
"0.66382563",
... | 0.0 | -1 |
This method is used to convert a given pd.Series object into a list | def series_to_list(series: pd.Series) -> List:
list_cols = []
for item in series:
list_cols.append(item)
return list_cols | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_list(self):\n return SeriesDefault.register(pandas.Series.to_list)(self)",
"def _to_list(series: Union[TimeSeries, Sequence[TimeSeries]]) -> Sequence[TimeSeries]:\n\n return [series] if not isinstance(series, Sequence) else series",
"def to_real_series(self, data: pd.Series) -> pd.Series:\n ... | [
"0.8163235",
"0.8084659",
"0.67696327",
"0.6688192",
"0.6478346",
"0.6332372",
"0.63315487",
"0.63113815",
"0.6291304",
"0.6289916",
"0.6243208",
"0.6221836",
"0.62096226",
"0.6204572",
"0.6184458",
"0.6167135",
"0.6163509",
"0.61454004",
"0.61151385",
"0.6111333",
"0.608589"... | 0.80512226 | 2 |
This method is used to gather the X (features) and y (targets) from a given dataframe based on a given target name | def get_X_y(df: pd.DataFrame, name_target: str) -> Tuple[List, List]:
X_list = []
y_list = []
for index, record in df.iterrows():
fl = series_to_list(record.drop(name_target))
X_list.append(fl)
y_list.append(int(record[name_target]))
return X_list, y_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_feat_and_target(df, target):\n x = df.drop(target, axis = 1)\n y = df[target]\n return x, y",
"def get_targets(self, df):\n return df.iloc[:, self.target_col]",
"def __get_x_y_from_data(\n logger, df, predictors, target):\n if df is not None:\n df_X = df[predictors]\n ... | [
"0.7217679",
"0.6761475",
"0.6600984",
"0.6574773",
"0.636862",
"0.63467455",
"0.6319424",
"0.62599015",
"0.617897",
"0.6085072",
"0.60718614",
"0.6002464",
"0.59024835",
"0.5899294",
"0.5896933",
"0.58856267",
"0.5781165",
"0.5759055",
"0.5751264",
"0.5698898",
"0.5694174",
... | 0.6518206 | 4 |
This method is used to perform Label Encoding on a given list | def label_encode(data: List) -> [np.ndarray, List[LabelEncoder]]:
labels_encoded = []
data_encoded = np.array(data)
for i in range(data_encoded.shape[1]):
le = preprocessing.LabelEncoder()
le.fit(data_encoded[:, i])
labels_encoded.append(le)
data_encoded[:, i] = le.transform(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_labels(labels_list: np.ndarray, label_encoder) -> np.ndarray:\n labels = label_encoder.fit_transform(labels_list)\n if label_encoder.classes_.size == 2:\n return labels\n else:\n return to_categorical(labels)",
"def one_hot_encoding((uri, label), all_labels):\n labels = [0]*N... | [
"0.7562382",
"0.6891295",
"0.6828393",
"0.67302644",
"0.67219895",
"0.65855664",
"0.655393",
"0.6548483",
"0.65094924",
"0.64900345",
"0.64831984",
"0.6471565",
"0.6455571",
"0.64494634",
"0.6426103",
"0.6385746",
"0.62811464",
"0.62680995",
"0.622862",
"0.6193661",
"0.617948... | 0.75347763 | 1 |
Check whether sequence str contains ALL of the items in set. | def containsAll(str, set):
return 0 not in [c in str for c in set] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def containsAny(str, set):\n return 1 in [c in str for c in set]",
"def containsAny(str, set):\n return 1 in [c in str for c in set]",
"def containsAny(str, set):\n return 1 in [c in str for c in set]",
"def all_unique_set(string):\n return len(string) == len(set(string))",
"def all_in_set(the_... | [
"0.75599706",
"0.75599706",
"0.75599706",
"0.73432213",
"0.7040939",
"0.69977653",
"0.67504674",
"0.65502936",
"0.6536207",
"0.64373004",
"0.63491184",
"0.6310514",
"0.6302475",
"0.6282493",
"0.6272134",
"0.62464535",
"0.62243676",
"0.6215836",
"0.62083054",
"0.6190645",
"0.6... | 0.8373326 | 1 |
Loads a snippet from a dictionary. If an existing snippet with this date is found, that one is updated, committed to the database, and returned. Otherwise a new instance is populated, committed to the database, and returned. | def load_from_json(user_id, json):
year = json["year"]
week = json["week"]
text = json.get("text", "")
tags = json.get("tags", [])
return Snippet.update(user_id, year, week, text, tags) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n if not os.path.isfile(self.DBFILE):\n self.snippets = {}\n return\n\n with open(self.DBFILE) as fobj:\n content = fobj.read()\n if not content.strip():\n content = \"{}\"\n\n self.snippets = {\n ... | [
"0.5525752",
"0.5340668",
"0.52998114",
"0.5021224",
"0.49906397",
"0.48999608",
"0.47908178",
"0.47714812",
"0.47337997",
"0.4732373",
"0.47303945",
"0.47028187",
"0.4698919",
"0.46946174",
"0.4689702",
"0.46578616",
"0.46578616",
"0.46391878",
"0.4634687",
"0.4631234",
"0.4... | 0.57506377 | 0 |
Serializes this snippet to a dictionary. | def to_json(self):
json = {
"url": url_for(
"api.get_week",
year=self.year,
week=self.week,
),
"year": self.year,
"week": self.week,
"text": self.text or "",
"tags": [tag.text for tag in self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(self):\n return {\n 'title': self.title,\n 'description': self.description,\n 'id': self.id,\n }",
"def serialize(self):\n return {\n 'id': self.id,\n 'title': self.title,\n 'description': self.description,\n ... | [
"0.6837822",
"0.66297317",
"0.6602671",
"0.6591415",
"0.65640765",
"0.6554913",
"0.65533537",
"0.65455",
"0.64985853",
"0.64985853",
"0.64985853",
"0.6452853",
"0.6409583",
"0.640126",
"0.6401137",
"0.6398112",
"0.6344605",
"0.6341496",
"0.6340976",
"0.6338145",
"0.633426",
... | 0.0 | -1 |
Returns the specified snippet (or None if it does not exist). | def get_by_week(user_id: str, year: int, week: int) -> Optional[Snippet]:
snippet = Snippet.query.filter_by(
user_id=user_id, year=year, week=week
)
return snippet.first() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_snippet(self, title=None):\n for snippet in self.snippets:\n if snippet[\"title\"] == title:\n return snippet\n return None",
"def get_snippet(res_type, snippet_name):\n\treturn get_settings_resource(res_type, snippet_name, 'snippets');",
"def get(name):\n # c... | [
"0.7803083",
"0.7509804",
"0.68043727",
"0.6783305",
"0.64907616",
"0.5895668",
"0.5698813",
"0.5681696",
"0.5681696",
"0.5670628",
"0.5629642",
"0.55866885",
"0.5575976",
"0.5484937",
"0.5417822",
"0.53710085",
"0.5361792",
"0.5350893",
"0.5321844",
"0.5257878",
"0.5215702",... | 0.55412996 | 13 |
Returns a query for all the specified snippets. | def get_all(user_id, tag_text=None) -> Query:
query = Snippet.query.filter_by(user_id=user_id)
if tag_text:
tag = Tag.query.filter_by(text=tag_text).first()
tag_id = tag and tag.id
query = query.join(tagged_snippets).filter_by(tag_id=tag_id)
return query.order... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSnippets(self, folderpath):\n print(\"Getting snippets for {}\".format(folderpath))\n # s2q = self.helper.loadJson(os.path.join(folderpath, 'final',\n # 'subject2svoqueries.json'))\n queries = self.helper.loadCsv(\n folderpath+\"... | [
"0.6417341",
"0.5955669",
"0.5799018",
"0.5799018",
"0.57882434",
"0.56366897",
"0.56245464",
"0.56226546",
"0.55856466",
"0.55196714",
"0.5429914",
"0.54079545",
"0.53793526",
"0.53777164",
"0.5342365",
"0.534001",
"0.53096443",
"0.5303962",
"0.5249011",
"0.5232009",
"0.5195... | 0.58999836 | 2 |
Reads ident and direction from packet, and returns the associated struct description from structs global. Normalises return to be a ((str, str), ...) | def get_struct(self, packet):
o = structs[packet.ident]
if isinstance(o, dict):
o = o[packet.direction]
if len(o) and not isinstance(o[0], tuple):
o = (o),
return o | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def struct_handler(rdr: TextIO) -> str:\n # What is the indent level?\n line = rdr.readline()\n spaces = 0\n for c in line:\n if c != ' ':\n break\n spaces += 1\n if spaces < 4: # this would be a false positive exit early\n return line\n # define an exit condition\... | [
"0.60142964",
"0.5952989",
"0.5886524",
"0.55371803",
"0.5497203",
"0.5459148",
"0.5436307",
"0.53541756",
"0.529343",
"0.5292839",
"0.5251687",
"0.5219966",
"0.5216221",
"0.5205466",
"0.51578975",
"0.50616544",
"0.5050829",
"0.50503224",
"0.5029179",
"0.50224257",
"0.5017213... | 0.71432406 | 0 |
Reads buff (consuming bytes) and returns the unpacked value according to the given type. | def unpack(self, data_type):
if data_type in data_types:
format = data_types[data_type]
return self.unpack_real(format[0], format[1])
if data_type == "string8":
length = self.unpack('short')
if length < 0:
raise Exception("Negative length for string")
if len(self.buff) < length:
raise Inco... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unpack_real(self, data_type, length):\n\t\tif len(self.buff) < length:\n\t\t\traise IncompleteData()\n\t\to = struct.unpack_from('!'+data_type, self.buff)[0]\n\t\tself.buff = self.buff[length:]\n\t\treturn o",
"def recv_type(self, type_):\n msg = self.recv()\n assert msg and msg['type'] == type... | [
"0.6121442",
"0.6102325",
"0.6010905",
"0.59326094",
"0.59165037",
"0.57921314",
"0.57729095",
"0.5755466",
"0.5736085",
"0.5672907",
"0.5606049",
"0.5564489",
"0.5529752",
"0.5459146",
"0.54543996",
"0.5428361",
"0.5421578",
"0.5403828",
"0.53911126",
"0.5365144",
"0.5348785... | 0.6249607 | 0 |
A helper function for unpack(), it handles any data type that is understood by the struct module. | def unpack_real(self, data_type, length):
if len(self.buff) < length:
raise IncompleteData()
o = struct.unpack_from('!'+data_type, self.buff)[0]
self.buff = self.buff[length:]
return o | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_type(fobj, data_type):\n if data_type == \"Boolean\": ## False if 0x00 else True\n return bool(fobj.read(1))\n elif data_type == \"Byte\": ## 1 byte int\n return fobj.read(1)[0]\n elif data_type == \"DateTime\": ## 8 bytes signed int\n return struct.unpack(\"<q\", fobj.read(... | [
"0.7574141",
"0.7300555",
"0.7035982",
"0.6990688",
"0.6908454",
"0.6716404",
"0.6593183",
"0.65563977",
"0.64701086",
"0.64119905",
"0.63946146",
"0.6381894",
"0.63355225",
"0.6306007",
"0.6268735",
"0.6262881",
"0.6244263",
"0.62122506",
"0.6211503",
"0.6190626",
"0.616264"... | 0.69019985 | 5 |
Reads the bytestring in self.buff, and returns the first packet contained within it. Sets self.buff to remaining bytestring. If packet is incomplete, returns None. But may raise if it thinks a real malformed packet has been recieved. | def read_packet(self):
#self.debug("READ BUFFER SIZE: %d" % len(self.buff))
backup = self.buff[:]
packet = Packet()
try:
packet.direction = self.node
packet.ident = self.unpack('ubyte')
#Defined structs from huge dict
for datatype, name in self.get_struct(packet):
# this populates packet.da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recv_packet(self):\r\n self.recv_bytes()\r\n\r\n packet_length_index = 0\r\n \r\n amount_data = len(self.recvBuffer) # available amount of data to read\r\n \r\n if amount_data <= packet_length_index: # just 0's in the buffer\r\n return None\r\n\r\n ... | [
"0.7178027",
"0.67700803",
"0.6706211",
"0.66330725",
"0.645455",
"0.6333611",
"0.62824416",
"0.6110825",
"0.6101818",
"0.60921735",
"0.60903865",
"0.60903865",
"0.6066746",
"0.60435694",
"0.60384893",
"0.6006668",
"0.5956292",
"0.5912572",
"0.5874441",
"0.5867553",
"0.585880... | 0.6022976 | 15 |
Takes a packet, and returns the encoded bytestring representing it. | def encode_packet(self, packet):
try:
output = self.pack('ubyte', packet.ident)
append = ''
#0x17
if packet.ident == 0x17:
if packet.data['unknown'] > 0:
for i in ('x2','y2','z2'):
append += self.pack('short', packet.data[i])
#0x33
if packet.ident in (0x33, 0x34):
packet.data['da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_packet(self, packet, b64=False):\n if packet.binary and not b64:\n bytes = six.int2byte(packet.type)\n else:\n bytes = six.binary_type(packet.type)\n if packet.binary and b64:\n bytes = 'b' + bytes\n\n if packet.binary and b64:\n ... | [
"0.7865717",
"0.6886599",
"0.67298377",
"0.6656107",
"0.63058937",
"0.62062097",
"0.61510146",
"0.6113067",
"0.6092784",
"0.60803",
"0.60527766",
"0.6038609",
"0.6027137",
"0.6022875",
"0.59639084",
"0.5963516",
"0.5936586",
"0.59108037",
"0.58827156",
"0.5860486",
"0.5859598... | 0.7339893 | 1 |
A wrapper about the normal objects, that lets you unpack encoded packets easily. Returns (packet, remaining_buff), where remaining_buff is the given buffer without the bytes eaten by the packet. If no more packets can be read from buff, returns (None, buff). | def stateless_unpack(buff, to_server):
decoder = PacketDecoder(to_server)
decoder.buff = buff
packet = decoder.read_packet()
return packet, decoder.buff | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_packet(self):\n\n\t\t#self.debug(\"READ BUFFER SIZE: %d\" % len(self.buff))\n\t\tbackup = self.buff[:]\n\t\tpacket = Packet()\n\t\ttry:\n\t\t\tpacket.direction = self.node\n\t\t\tpacket.ident = self.unpack('ubyte')\n\t\t\t\n\t\t\t#Defined structs from huge dict\n\t\t\tfor datatype, name in self.get_struct... | [
"0.6680396",
"0.6446139",
"0.635691",
"0.61377084",
"0.60597813",
"0.59214246",
"0.59068066",
"0.5846877",
"0.5788773",
"0.57825875",
"0.5771481",
"0.5694871",
"0.5669175",
"0.5655013",
"0.5589426",
"0.55781716",
"0.5572244",
"0.5557182",
"0.55246246",
"0.55121374",
"0.551061... | 0.72920316 | 0 |
A wrapper about the normal objects, that lets you pack decoded packets easily. Returns the bytestring that represents the packet. | def stateless_pack(packet, to_server):
decoder = PacketDecoder(to_server)
return decoder.encode_packet(packet) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def packetize(self):\n byte_str = b''\n\n # Bit string to accumulate bit values until we are ready to convert it into bytes\n bit_str = \"\"\n\n for field in self.fields:\n #if the current field is a special type, the bit_str value to the byte string and clear the accumulated... | [
"0.6658192",
"0.6616389",
"0.661359",
"0.6557513",
"0.6539478",
"0.65270644",
"0.63207364",
"0.62352747",
"0.62149036",
"0.6198456",
"0.6153788",
"0.613428",
"0.6095934",
"0.605854",
"0.60508865",
"0.6032792",
"0.60198796",
"0.5980188",
"0.5960326",
"0.5957138",
"0.59558177",... | 0.64134574 | 6 |
Lift a sampling function to one that draws multiple iid samples. | def iid_sample(sample_fn, sample_shape):
sample_shape = distribution_util.expand_to_vector(
ps.cast(sample_shape, np.int32), tensor_name='sample_shape')
n = ps.cast(ps.reduce_prod(sample_shape), dtype=np.int32)
static_n = tf.get_static_value(tf.convert_to_tensor(n))
def unflatten(x):
sample_dims = 0 ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iid_sample_fn(*args, **kwargs):\n\n with tf.name_scope('iid_sample_fn'):\n\n seed = kwargs.pop('seed', None)\n if samplers.is_stateful_seed(seed):\n kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())\n def pfor_loop_body(_):\n with tf.name_scope('iid_sample_fn... | [
"0.6780334",
"0.6380335",
"0.5978483",
"0.59762675",
"0.5962528",
"0.5962528",
"0.59488493",
"0.58723915",
"0.5839884",
"0.5820229",
"0.5768919",
"0.5750288",
"0.5728591",
"0.57276875",
"0.5725391",
"0.57026887",
"0.5686771",
"0.5677376",
"0.56756586",
"0.5674957",
"0.5672077... | 0.6582716 | 1 |
Draws iid samples from `fn`. | def iid_sample_fn(*args, **kwargs):
with tf.name_scope('iid_sample_fn'):
seed = kwargs.pop('seed', None)
if samplers.is_stateful_seed(seed):
kwargs = dict(kwargs, seed=SeedStream(seed, salt='iid_sample')())
def pfor_loop_body(_):
with tf.name_scope('iid_sample_fn_stateful_bod... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iid_sample(sample_fn, sample_shape):\n sample_shape = distribution_util.expand_to_vector(\n ps.cast(sample_shape, np.int32), tensor_name='sample_shape')\n n = ps.cast(ps.reduce_prod(sample_shape), dtype=np.int32)\n static_n = tf.get_static_value(tf.convert_to_tensor(n))\n\n def unflatten(x):\n samp... | [
"0.64719844",
"0.5108194",
"0.5058195",
"0.5022143",
"0.5005775",
"0.49909416",
"0.49430317",
"0.4896238",
"0.48929828",
"0.4841593",
"0.48388526",
"0.48310915",
"0.48164558",
"0.481505",
"0.48034382",
"0.47747755",
"0.4774165",
"0.47662959",
"0.47544459",
"0.474792",
"0.4742... | 0.6562505 | 0 |
Wraps `fn` to take only those args with non`None` core ndims. | def _lock_in_non_vectorized_args(fn, arg_structure, flat_core_ndims, flat_args):
# Extract the indices and values of args where core_ndims is not `None`.
(vectorized_arg_indices,
vectorized_arg_core_ndims,
vectorized_args) = [], [], []
if any(nd is not None for nd in flat_core_ndims):
vectorized_arg_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_keepdims(func):\n @functools.wraps(func)\n def wrapped(a, axis, **kwargs):\n res = func(a, axis=axis, **kwargs)\n if axis is None:\n axis = 0 # res is now a scalar, so we can insert this anywhere\n return np.expand_dims(res, axis=axis)\n return wrapped",
"def ar... | [
"0.60580367",
"0.5733432",
"0.5674461",
"0.5585218",
"0.55187184",
"0.537419",
"0.5331399",
"0.5270151",
"0.5239943",
"0.52073294",
"0.50932014",
"0.5054553",
"0.50446254",
"0.50378776",
"0.5035789",
"0.50340813",
"0.4959851",
"0.49438873",
"0.4940812",
"0.49344712",
"0.49254... | 0.50251055 | 16 |
Lift a function to one that vectorizes across arbitraryrank inputs. | def make_rank_polymorphic(fn, core_ndims, name=None):
def vectorized_fn(*args):
"""Vectorized version of `fn` that accepts arguments of any rank."""
with tf.name_scope(name or 'make_rank_polymorphic'):
# If we got a single value for core_ndims, tile it across all args.
core_ndims_structure = (
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper",
"def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vecto... | [
"0.71565306",
"0.71565306",
"0.6703871",
"0.62867755",
"0.6109641",
"0.60993487",
"0.60616183",
"0.5936452",
"0.59198844",
"0.5880423",
"0.57778794",
"0.57708",
"0.5769331",
"0.57459575",
"0.57459575",
"0.5743964",
"0.5737575",
"0.5717322",
"0.57160723",
"0.5654426",
"0.56408... | 0.6002288 | 7 |
Vectorized version of `fn` that accepts arguments of any rank. | def vectorized_fn(*args):
with tf.name_scope(name or 'make_rank_polymorphic'):
# If we got a single value for core_ndims, tile it across all args.
core_ndims_structure = (
core_ndims
if tf.nest.is_nested(core_ndims)
else tf.nest.map_structure(lambda _: core_ndims, args))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vectorize(f)(input)\r\n return f(input)\r\n return wrapper",
"def autovectorized(f):\r\n def wrapper(input):\r\n if N.isscalar(input)==False:\r\n return N.vecto... | [
"0.6786364",
"0.6786364",
"0.6500684",
"0.5944921",
"0.5887587",
"0.5769011",
"0.5756932",
"0.55749714",
"0.5569364",
"0.5535822",
"0.55204463",
"0.5485098",
"0.5388941",
"0.5376015",
"0.53529257",
"0.53529257",
"0.53479564",
"0.53440005",
"0.5334205",
"0.529618",
"0.5241454"... | 0.65664375 | 2 |
Adds master file location for each page to the metadata_local.xml saf output file. | def add_page_admin_data(self, top, record):
# type: (Element, Element) -> None
cdm_struc = Fields.cdm_structural_elements
dspace_local = Fields.dspace_local_field
structure_el = record.find(cdm_struc['compound_object_container'])
pages_el = structure_el.iterfind('.//' + cdm_stru... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_local_metadata_file(files, home=''):\n filepaths = [os.path.join(home, f) for f in files]\n shas = [_get_sha_metadata(f) for f in filepaths]\n metadata = dict(zip(files, shas))\n\n with open(LOCAL_METADATA_FILE, 'w') as f:\n f.write(json.dumps(metadata))",
"def master_archive(f, e):... | [
"0.5722937",
"0.5389413",
"0.5272536",
"0.5261582",
"0.52335477",
"0.5231832",
"0.5230986",
"0.5189005",
"0.5180332",
"0.5165523",
"0.5151534",
"0.5123532",
"0.51147246",
"0.50322574",
"0.50167596",
"0.4984998",
"0.49717563",
"0.49513733",
"0.49408144",
"0.4935451",
"0.493191... | 0.4666643 | 61 |
Returns full text extracted from cdm compound object pages. | def extract_text(self, record):
# type: (Element) -> str
cdm_struc = Fields.cdm_structural_elements
structure_el = record.find(cdm_struc['compound_object_container'])
pages_el = structure_el.iterfind('.//' + cdm_struc['compound_object_page'])
fulltext = ''
for page in pag... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def raw_text(self):\n\t\t\n\t\t #eliminating more headers\n\t\traw_text = re.sub(r\".*OPERATIONS O[PF].*\",r\"\",self.doc)\n\t\traw_text = re.sub(r\"Page \\d+\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*B[lL]OCK.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*WEST GULF.*\",r\"\",raw_text)\n\t\traw_text = re.sub(... | [
"0.6273365",
"0.62023115",
"0.6014343",
"0.59526193",
"0.5892059",
"0.5881646",
"0.5855388",
"0.58526736",
"0.58320683",
"0.58169097",
"0.5788491",
"0.5753858",
"0.57474256",
"0.5684555",
"0.56561995",
"0.5646933",
"0.5620174",
"0.5598048",
"0.55893654",
"0.5587107",
"0.55830... | 0.7681376 | 0 |
Get the list of chromosome names from a fasta file | def _chrom_names(fasta_file):
from pysam import FastaFile
with FastaFile(fasta_file) as fa:
chroms = list(fa.references)
return chroms | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readFasta(self, fastaFile):\t\n\t\tname, seq = None, []\n\t\tfor line in fastaFile:\n\t\t\tline = line.rstrip()\n\t\t\tif (line.startswith(\">\")):\n\t\t\t\tif name: yield (name, ''.join(seq))\n\t\t\t\tname, seq = line, []\n\t\t\telse:\n\t\t\t\tseq.append(line)\n\t\tif name: yield (name, ''.join(seq))",
"def... | [
"0.6546648",
"0.64621747",
"0.63865525",
"0.63529944",
"0.63245755",
"0.63238037",
"0.6276679",
"0.6252582",
"0.62015104",
"0.6200787",
"0.6186508",
"0.6152302",
"0.6124569",
"0.60324305",
"0.60317713",
"0.60203993",
"0.60121757",
"0.6001881",
"0.60012823",
"0.59866214",
"0.5... | 0.79199076 | 0 |
Get the chromosome sizes for a fasta file | def _chrom_sizes(fasta_file):
from pysam import FastaFile
fa = FastaFile(fasta_file)
chrom_lens = OrderedDict([(name, l) for name, l in zip(fa.references, fa.lengths)])
if len(chrom_lens) == 0:
raise ValueError(f"no chromosomes found in fasta file: {fasta_file}. "
"Make ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expected_readlen(bedfile, bedHeader, annoList):\n\n #chromosomes from project bed\n with open(bedfile, 'r') as f:\n if bedHeader=='yes':\n chroms = [key for key in dict(Counter([line.split('\\t')[0] for il, line in enumerate(f) if il>0])).keys()]\n else:\n chroms = [ke... | [
"0.6612106",
"0.65703803",
"0.6373489",
"0.6340387",
"0.629946",
"0.62345374",
"0.6110134",
"0.60759944",
"0.6062779",
"0.6048343",
"0.60378957",
"0.60344946",
"0.6015284",
"0.59918827",
"0.59908766",
"0.59731734",
"0.5965608",
"0.5897269",
"0.58564174",
"0.58517754",
"0.5796... | 0.7949907 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.