def test_contains(self): self.assertRaises(TypeError, operator.contains) self.assertRaises(TypeError, operator.contains, None, None) self.assertTrue(operator.contains(range(4), 2)) self.assertFalse(operator.contains(range(4), 5)) self.assertTrue(operator.sequenceIncludes(range(4), 2)) self.assertFalse(operator.sequenceIncludes(range(4), 5))
def evaluate(cond): # Method to evaluate the conditions if isinstance(cond,bool): return cond left, oper, right = cond if not model or not left in model.mgroup.fields: #check that the field exist return False oper = self.OPERAND_MAPPER.get(oper.lower(), oper) if oper == '=': res = operator.eq(model[left].get(model),right) elif oper == '!=': res = operator.ne(model[left].get(model),right) elif oper == '<': res = operator.lt(model[left].get(model),right) elif oper == '>': res = operator.gt(model[left].get(model),right) elif oper == '<=': res = operator.le(model[left].get(model),right) elif oper == '>=': res = operator.ge(model[left].get(model),right) elif oper == 'in': res = operator.contains(right, model[left].get(model)) elif oper == 'not in': res = operator.contains(right, model[left].get(model)) res = operator.not_(res) return res
def test_contains(self): self.assertRaises(TypeError, operator.contains) self.assertRaises(TypeError, operator.contains, None, None) self.assertTrue(operator.contains(list(range(4)), 2)) self.assertFalse(operator.contains(list(range(4)), 5)) self.assertTrue(operator.contains(list(range(4)), 2)) self.assertFalse(operator.contains(list(range(4)), 5))
def message(self, args): line = [] # Üldvorming # aeg 14*14DIGIT if contains(args, 'timestamp'): line = [args['timestamp']] else: line = [time.strftime("%Y%m%d%H%M%S")] # Hääle räsi 28*28BASE64-CHAR if not contains(args, 'haal_rasi'): if contains(args, 'haal'): args['haal_rasi'] = ksum.votehash(args['haal']) line.append(args['haal_rasi']) # omavalitsuse-number 1*10DIGIT line.append(str(args['ringkond_omavalitsus'])) # suhteline-ringkonna-number 1*10DIGIT line.append(str(args['ringkond'])) # omavalitsuse-number 1*10DIGIT line.append(str(args['jaoskond_omavalitsus'])) # suhteline-valimisjaoskonna-number 1*10DIGIT line.append(str(args['jaoskond'])) if args['tyyp'] in [1, 2, 3]: #*1valija-andmed = #isikukood 11*11DIGIT line.append(str(args['isikukood'])) if args['tyyp'] == 2: # pohjus 1*100UTF-8-CHAR line.append(args['pohjus']) logstring = "\t".join(line) + "\n" return logstring
def test_contains(self): self.failUnlessRaises(TypeError, operator.contains) self.failUnlessRaises(TypeError, operator.contains, None, None) self.failUnless(operator.contains(range(4), 2)) self.failIf(operator.contains(range(4), 5)) self.failUnless(operator.sequenceIncludes(range(4), 2)) self.failIf(operator.sequenceIncludes(range(4), 5))
def sort_clusters(clusters, tag_index, ground_truth_clusters): def measure(cluster): tag_match = cluster.tag_accuracy cluster_size = cluster.cluster.number_of_sources lo = len(cluster.cluster.label_overlap) so = len(cluster.cluster.source_overlap) wc = cluster.cluster.number_of_words return wc + ((so + 1) * 10) + ((lo + 1) * 100) + ((cluster_size + 1) * 1000) + \ ((tag_match + 1) * 1000000) + ((cluster.ground_truth_best_match + 1) * 10000000) measured_clusters = [] for cluster in clusters: measured_cluster = MeasuredCluster() measured_cluster.cluster = cluster tag_list = [] for source in cluster.sources: tag_list.append(string_to_phrase(tag_index[source].replace('-', ' '))) measured_cluster.tag_accuracy = len(common(map(lambda cluster: cluster, tag_list))) for y in ground_truth_clusters.keys(): ## iterate through all tags if contains(cluster.sources, ground_truth_clusters[y]) and \ contains(ground_truth_clusters[y], cluster.sources): ## and vice versa?? tag_list = [] for source in cluster.sources: tag_list.append(string_to_phrase(tag_index[source].replace('-', ' '))) tag_list.append(string_to_phrase(y.replace('-', ' '))) d = len(common(map(lambda cluster: cluster, tag_list))) if d > measured_cluster.ground_truth_best_match: measured_cluster.ground_truth_best_match = d measured_clusters.append(measured_cluster) measured_clusters.sort(reverse=True, key=measure) return measured_clusters
def test_contains(self): self.assertRaises(TypeError, operator.contains) self.assertRaises(TypeError, operator.contains, None, None) self.assertTrue(operator.contains(range(4), 2)) self.assertFalse(operator.contains(range(4), 5)) with test_support.check_py3k_warnings(): self.assertTrue(operator.sequenceIncludes(range(4), 2)) self.assertFalse(operator.sequenceIncludes(range(4), 5))
def in_(a, b): if isinstance(a, (list, tuple)): if isinstance(b, (list, tuple)): return any(operator.contains(b, x) for x in a) else: return operator.contains(a, b) else: return operator.contains(b, a)
def main(args): global OUTPUT_FOLDER_NAME, DOWNLOAD_DIRECTORY, FILE_FORMATS url = urlp.urlparse(args.url) if not url.scheme: print_formatted("Invalid url, exiting...", ERROR) return 1 if args.folder: OUTPUT_FOLDER_NAME = args.folder DOWNLOAD_DIRECTORY = DOWNLOAD_DIRECTORY = ( (os.getcwd() if not os.getcwd().endswith("/") else os.getcwd()[:-1]) + "/" + OUTPUT_FOLDER_NAME + "/" ) print_formatted("Downloading images from thread: " + str(args.url).split("/")[-1], DEFAULT) if contains(os.listdir(os.getcwd()), OUTPUT_FOLDER_NAME): choice = save_choices() if choice: pass else: print_formatted("Exiting...", DEFAULT) return 1 else: print_formatted("Creating directory " + OUTPUT_FOLDER_NAME + "...", DEFAULT) os.makedirs(OUTPUT_FOLDER_NAME) print_formatted('Using "\\' + OUTPUT_FOLDER_NAME + '\\" as the output folder', DEFAULT) try: response = urllib2.urlopen(args.url) except: print_formatted("Cannot open url, exiting...", ERROR) sys.exit(1) soup = BeautifulSoup(response) image_a_tags = soup.findAll("a", {"class": "fileThumb"}) total = len(image_a_tags) print_formatted("found " + str(total) + " images", DEFAULT) for file_format in FILE_FORMATS: count = count_extensions(file_format, image_a_tags) print "---" + str(count) + " " + str(file_format) + " " + pluralize(count) + " found" existing_files = os.listdir(os.getcwd() + "/" + OUTPUT_FOLDER_NAME) to_download_files = [] for img_href in image_a_tags: href = img_href["href"] if not contains(existing_files, href.split("/")[-1]): to_download_files.append(img_href) if not to_download_files: print_formatted('No new files to download to directory "\\' + OUTPUT_FOLDER_NAME + '\\", exiting...') return 0 download_files(to_download_files) print_formatted("Finished downloading images", DEFAULT)
def discover(): print textwrap.dedent( """ fuzz [discover | test] url OPTIONS COMMANDS: discover Output a comprehensive, human-readable list of all discovered inputs to the system. Techniques include both crawling and guessing. test Discover all inputs, then attempt a list of exploit vectors on those inputs. Report potential vulnerabilities. OPTIONS: --custom-auth=string Signal that the fuzzer should use hard-coded authentication for a specific application (e.g. dvwa). Optional. Discover options: --common-words=file Newline-delimited file of common words to be used in page guessing and input guessing. Required. Test options: --vectors=file Newline-delimited file of common exploits to vulnerabilities. Required. --sensitive=file Newline-delimited file data that should never be leaked. It's assumed that this data is in the application's database (e.g. test data), but is not reported in any response. Required. --random=[true|false] When off, try each input to each page systematically. When on, choose a random page, then a random input field and test all vectors. Default: false. --slow=500 Number of milliseconds considered when a response is considered "slow". Default is 500 milliseconds """ ) link = raw_input('Please Enter Command: ') info = link.split() command = info[0].lower() url = info[1].lower() options = info[2:] for x in options: if operator.contains(x, '--custom-auth='): print ('Custom Authentication: ') custAuth(x.split('=')[1]) if operator.contains(x, '--common-words='): print('Searching Common Words: ') guessPages(x.split('=')[1], url) if operator.eq(command, 'discover'): #discover functionality print('Discovering Links: ') getLinks(url) print('Parse URLs: ') parseURL(url) print('Discovering Cookies: ') getCookies(url) print('Get Inputs: ') getInputs(url) else: #test functionality print ('Discovering All Inputs: ') getInputs(url) print ('Checking For Sensitive Data: ') for x in options: if operator.contains(x, '--vectors='): print('Looking For Potential Threats In Vectors: ') #senseData(url, x.split('=')[1]) if operator.contains(x, '--sensitive='): print('Looking For Potential Sensitive Information: ') senseData(url, x.split('=')[1]) print ('Checking For Sanitized Data: ') lackSanitize(url, 'escape_chars.txt')
def test_operator(self): import operator self.assertIs(operator.truth(0), False) self.assertIs(operator.truth(1), True) self.assertIs(operator.not_(1), False) self.assertIs(operator.not_(0), True) self.assertIs(operator.contains([], 1), False) self.assertIs(operator.contains([1], 1), True) self.assertIs(operator.lt(0, 0), False) self.assertIs(operator.lt(0, 1), True) self.assertIs(operator.is_(True, True), True) self.assertIs(operator.is_(True, False), False) self.assertIs(operator.is_not(True, True), False) self.assertIs(operator.is_not(True, False), True)
def apply_filters(self, records, filters): """Filter the specified records, using basic iteration. """ operators = { COMPARISON.LT: operator.lt, COMPARISON.MAX: operator.le, COMPARISON.EQ: operator.eq, COMPARISON.NOT: operator.ne, COMPARISON.MIN: operator.ge, COMPARISON.GT: operator.gt, COMPARISON.IN: operator.contains, COMPARISON.EXCLUDE: lambda x, y: not operator.contains(x, y), } for record in records: matches = True for f in filters: left = record.get(f.field) right = f.value if f.operator in (COMPARISON.IN, COMPARISON.EXCLUDE): right = left left = f.value matches = matches and operators[f.operator](left, right) if matches: yield record
def __iter__(self): """This method is a way to sort and filter an object easily. The keyword arguments, order_by and cmp are used for sorting while everything else is used by __checker__ for filtering. The order_by keyword may be either a string or a function. If it is a string then we create a function which gets that key from the entities in obj and uses that as the key function in sorting. All other keywords are used as described in __checker__. If no keywords are given then the object is simply returned. :obj: An iterable to filter and sort :kwargs: Keyword arguments for filtering and sorting. """ filtered = iter(self.obj) for key, value in self.options.items(): if key == '_': filtered = it.ifilter(value, filtered) elif callable(value): filtered = it.ifilter(self.__callable_filter__(key, value), filtered) elif isinstance(value, (list, set, tuple)): func = self.__basic_filter__(key, set(value), lambda a, b: op.contains(b, a)) filtered = it.ifilter(func, filtered) else: func = self.__basic_filter__(key, value, op.eq) filtered = it.ifilter(func, filtered) return filtered
def visitInfixOperatorNode( self, node ): lhs = self._contextUnwrap( node.leftOperand.accept( self ) ) rhs = self._contextUnwrap( node.rightOperand.accept( self ) ) if node.operator == 'and': return bool(lhs) and bool(rhs) elif node.operator == 'or': return bool(lhs) or bool(rhs) elif node.operator == 'in': # TODO: deep unwrap return operator.contains( self._deepContextUnwrap(rhs), self._deepContextUnwrap(lhs) ) else: func = { '|': operator.or_, '&': operator.and_, '^': operator.xor, '+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.div, '%': operator.mod, '<': operator.lt, '>': operator.gt, '<=': operator.le, '>=': operator.ge, '==': operator.eq, '!=': operator.ne, '<<': operator.lshift, '>>': operator.rshift, }[node.operator] return func( lhs, rhs )
def get_avalide_inavalide_shipping_values_from_lines(shipping_lines): """"将输入的数据 进行检查,并返回有效和无效的数据""" inavalide_shipping_lines = [] avalide_shipping_lines = [] avalide_shipping_out_sid = [] for ship_line in shipping_lines.split('\n'): shipping_values = get_avalide_shipping_line_data(ship_line) if shipping_values: #去除重复项,并将其放到错误数据中 if contains(avalide_shipping_out_sid, shipping_values[0]): avalide_shipping_out_sid.remove(shipping_values[0]) for sp_value in avalide_shipping_lines: if sp_value[0] == shipping_values[0]: avalide_shipping_lines.remove(sp_value) inavalide_shipping_lines.append( u'重复项 %s' % str(sp_value)) inavalide_shipping_lines.append( u'重复项 %s' % str(shipping_values)) #如果没有重复项,则添加out_sid到avalide_shipping_out_sid中 else: avalide_shipping_out_sid.append(shipping_values[0]) avalide_shipping_lines.append(shipping_values) else: inavalide_shipping_lines.append(ship_line) return avalide_shipping_lines, inavalide_shipping_lines
def encode(cls, iterable, result): '''Given an `iterable` string, send each character in a printable form to `result`.''' # construct a transformer that writes characters to result escape = internal.utils.character.escape(result); next(escape) # send the key prefix result.send(cls.prefix) # now we can actually process the string for ch in iterable: # first check if character has an existing key mapping if operator.contains(cls.mappings, ch): for ch in operator.getitem(cls.mappings, ch): result.send(ch) # otherwise pass it to the regular escape function else: escape.send(ch) continue # submit the suffix and we're good result.send(cls.suffix) return
def apply_filters(self, records, filters): """Filter the specified records, using basic iteration. """ operators = { COMPARISON.LT: operator.lt, COMPARISON.MAX: operator.le, COMPARISON.EQ: operator.eq, COMPARISON.NOT: operator.ne, COMPARISON.MIN: operator.ge, COMPARISON.GT: operator.gt, COMPARISON.IN: operator.contains, COMPARISON.EXCLUDE: lambda x, y: not operator.contains(x, y), } for record in records: matches = True for f in filters: left = record.get(f.field) right = f.value if f.operator in (COMPARISON.IN, COMPARISON.EXCLUDE): right = left left = f.value else: # Python3 cannot compare None to other value. if left is None: if f.operator in (COMPARISON.GT, COMPARISON.MIN): matches = False continue elif f.operator in (COMPARISON.LT, COMPARISON.MAX): continue # matches = matches and True matches = matches and operators[f.operator](left, right) if matches: yield record
def filtered_list(l, key, value, op='eq'): '''Filter list items based on their value in a specific key/attr. ''' if not l: return l op_map = { 'ne': operator.ne, 'eq': operator.eq, 'le': operator.ge, 'lt': operator.gt, 'ge': operator.le, 'gt': operator.lt, '!=': operator.ne, '==': operator.eq, '<=': operator.ge, '<': operator.gt, '>=': operator.le, '>': operator.lt, 'in': operator.contains, 'not-in': lambda a, b: not operator.contains(a, b) } op = op_map.get(str(op).lower(), operator.eq) items_are_dicts = operator.isMappingType(l[0]) if items_are_dicts: def pred(x): return op(value, x.get(key)) else: def pred(x): return op(value, getattr(x, key, None)) return filter(pred, l)
def get_operator_function(name): lookup = { 'And': and_operator, 'Or': or_operator, 'Add': add_operator, 'In': operator.contains, 'NotIn': lambda x, y: not operator.contains(x, y), 'Div': operator.truediv, 'FloorDiv': operator.floordiv, 'BitAnd': operator.and_, 'BitXor': operator.xor, 'Invert': operator.invert, 'BitOr': operator.or_, 'Pow': operator.pow, 'Is': operator.is_, 'IsNot': operator.is_not, 'LShift': operator.lshift, 'Mod': mod_operator, 'Mult': operator.mul, 'USub': operator.neg, 'Not': operator.not_, 'UAdd': operator.pos, 'RShift': operator.rshift, 'Repeat': operator.repeat, # special 'Sub': operator.sub, 'Lt': comparison(operator.lt), 'LtE': comparison(operator.le), 'Eq': operator.eq, 'NotEq': operator.ne, 'GtE': comparison(operator.ge), 'Gt': comparison(operator.gt), } return lookup.get(name)
def contains(self, thing): ''' if `thing` is found in incoming things @param thing: some thing ''' with self._context(): return self._append(contains(self._iterable, thing))
def final(self, priority_name): base_hostlist = self.base_hostlist if priority_name: base_hostlist = sorted( base_hostlist, key=lambda x: contains(x[0], priority_name), reverse=True) return base_hostlist
def enabledDomaen(domaen): domaens = ["000.net", "00.com", "0000000.net","gbicom.cn"] if os.path.exists("domaens.txt"): fh = open("domaens.txt","r") for line in fh: domaens.append(line.replace("\n","")) fh.close() return operator.contains(domaens, domaen)
def add_object(self, name, instance): from operator import contains from Exceptions import GlobalStoreObjectExistsError if contains(self.__object_dictionary.keys(), name): raise GlobalStoreObjectExistsError from utils import generate_random_number object_id = generate_random_number(map(lambda x: x[1],self.__object_dictionary.values())) self.__object_dictionary[name] = instance, object_id return object_id
def calculateProbs(self): # Start with P(F) and P(H) fluTweets = list() healthTweets = list() # Split tweets into two lists. Flu and not Flu data.numFluTweets = 0 for tweetNum, cat in data.categorization.iteritems(): data.numFluTweets += cat if(cat == 0): healthTweets.append(data.tweets[tweetNum]) else: fluTweets.append(data.tweets[tweetNum]) data.numHealthyTweets = data.tweetsStored - data.numFluTweets data.probOfFlu = float(data.numFluTweets) / float(data.tweetsStored) print(data.probOfFlu) # Create a list of all words that occur in the training data for tweet in data.tweets: words = re.findall(r'\w+', tweet) for word in words: if(not word in data.words): data.words.append(word) # For each word: for word in data.words: # Get prob word given flu isWordInFluTweets = map(lambda x: operator.contains(x, word)/float(data.numFluTweets), fluTweets) probWordGivenFlu = reduce(operator.add, isWordInFluTweets) # Get prob word given healthy isWordInHealthTweets = map(lambda x: operator.contains(x, word)/float(data.numHealthyTweets), healthTweets) probWordGivenHealth = reduce(operator.add, isWordInHealthTweets) # Updata data in data data.probabilities[word] = probWordGivenFlu, probWordGivenHealth print("Probabilities calculated!!!")
def p_toggleDso(self, enable): jvmArgList = self.getGenericJvmArguments() self.p_info("Original value of genericJvmArguments: " + str(jvmArgList)) if enable: for dsoArg in self.dsoArgs: if not operator.contains(jvmArgList, dsoArg): jvmArgList.append(dsoArg) else: jvmArgList = filter(self.p_filterOutDsoArgs, jvmArgList) self.p_setGenericJvmArguments(jvmArgList) self.p_info("New value of genericJvmArguments: " + str(self.getGenericJvmArguments()))
def _all(base, files, exp, negate=truth, expansion=""): for e in exp: abs_e = base + e + expansion # print abs_e, files if negate(contains(files, abs_e)): continue else: print "Failed on ", e return False return True
def test_operator(self): import operator self.assertIs(operator.truth(0), False) self.assertIs(operator.truth(1), True) self.assertIs(operator.isNumberType(None), False) self.assertIs(operator.isNumberType(0), True) self.assertIs(operator.not_(1), False) self.assertIs(operator.not_(0), True) self.assertIs(operator.isSequenceType(0), False) self.assertIs(operator.isSequenceType([]), True) self.assertIs(operator.contains([], 1), False) self.assertIs(operator.contains([1], 1), True) self.assertIs(operator.isMappingType(1), False) self.assertIs(operator.isMappingType({}), True) self.assertIs(operator.lt(0, 0), False) self.assertIs(operator.lt(0, 1), True) self.assertIs(operator.is_(True, True), True) self.assertIs(operator.is_(True, False), False) self.assertIs(operator.is_not(True, True), False) self.assertIs(operator.is_not(True, False), True)
def run_trial(experiment, trial): phases = experiment.experiment_data.get('phases', ('outbound', 'return')) trial.data['height'] += trial.data['lowest_height_not_afforded'] show_trial(trial.data) results = {'time': datetime.now()} for phase in phases: results[phase] = RESULTS_BY_CODE[get_input( trial_prompt(phase, max(len(phase_) for phase_ in phases)), contains(set(RESULTS_BY_CODE.keys())), single_key=True )] return results
def test_updates_on_node_removal(self): # Ensure that nodes removed after the holder has been instantiated are # removed as attributes on the settings holder. self.client.create("/DEBUG", json.dumps(True)) self.assertTrue(self.holder.DEBUG) # sanity check event = self.get_child_node_event("/DEBUG", comparator=lambda *a: not operator.contains(*a)) self.client.delete("/DEBUG") event.wait(self.TIMEOUT) with self.assertRaises(AttributeError): self.holder.DEBUG
def visit_Compare(self, node): if len(node.comparators) > 1: raise SyntaxError("mutliple comparison is not supported") left = self.visit(node.left) right = self.visit(node.comparators[0]) op = node.ops[0] if op.__class__ == ast.In: return Import(operator.contains(right, left)) elif op.__class__ == ast.NotIn: return Import(operator.not_)(Import(operator.contains)(right, left)) else: return Import(self.COMPARE_MAP[op.__class__])(left, right)
return get_url(uri = "/app/{0}/view/report/{1}".format(quoted(slug(doctype)), quoted(name))) else: return get_url(uri = "/app/query-report/{0}".format(quoted(name))) def get_url_to_report_with_filters(name, filters, report_type = None, doctype = None): if report_type == "Report Builder": return get_url(uri = "/app/{0}/view/report?{1}".format(quoted(doctype), filters)) else: return get_url(uri = "/app/query-report/{0}?{1}".format(quoted(name), filters)) operator_map = { # startswith "^": lambda a, b: (a or "").startswith(b), # in or not in a list "in": lambda a, b: operator.contains(b, a), "not in": lambda a, b: not operator.contains(b, a), # comparison operators "=": lambda a, b: operator.eq(a, b), "!=": lambda a, b: operator.ne(a, b), ">": lambda a, b: operator.gt(a, b), "<": lambda a, b: operator.lt(a, b), ">=": lambda a, b: operator.ge(a, b), "<=": lambda a, b: operator.le(a, b), "not None": lambda a, b: a and True or False, "None": lambda a, b: (not a) and True or False } def evaluate_filters(doc, filters): '''Returns true if doc matches filters'''
class DummyStorage(HealthcareStorage): "In-memory storage. This should only be used for testing." _patients = {} _patient_ids = {} _providers = {} _comparison_mapping = { comparisons.EQUAL: operator.eq, # operator.contains reverses the operands # http://docs.python.org/2/library/operator.html#operator.contains # field_value contains value comparisons.LIKE: operator.contains, # value contains field_value comparisons.IN: lambda a, b: operator.contains(b, a), comparisons.LT: operator.lt, comparisons.LTE: operator.le, comparisons.GT: operator.gt, comparisons.GTE: operator.ge, } def _lookup_to_filter(self, lookup): def filter_func(item): field, operator, value = lookup comparison_func = self._comparison_mapping[operator] field_value = item.get(field) if field_value is None: return False return comparison_func(field_value, value) return filter_func def _build_source_id(self, source_id, source_name): return '{0}-{1}'.format(source_id, source_name) def get_patient(self, id, source=None): "Retrieve a patient record by ID." patient = None if source: uid = self._build_source_id(id, source) patient_id = self._patient_ids.get(uid) if patient_id: patient = self._patients.get(patient_id) else: patient = self._patients.get(id) return patient def create_patient(self, data): "Create a patient record." uid = uuid.uuid4().int data['created_date'] = now() data['updated_date'] = now() if 'status' not in data: data['status'] = 'A' self._patients[uid] = data data['id'] = uid return data def update_patient(self, id, data): "Update a patient record by ID." if id in self._patients: data['updated_date'] = now() self._patients[id].update(data) return True return False def delete_patient(self, id): "Delete a patient record by ID." if id in self._patients: del self._patients[id] return True return False def filter_patients(self, *lookups): "Find patient records matching the given lookups." filters = map(self._lookup_to_filter, lookups) return filter(lambda t: all(f(t) for f in filters), self._patients.values()) def link_patient(self, id, source_id, source_name): "Associated a source/id pair with this patient." uid = self._build_source_id(source_id, source_name) if uid in self._patient_ids: return False if id not in self._patients: return False self._patient_ids[uid] = id return True def unlink_patient(self, id, source_id, source_name): "Remove association of a source/id pair with this patient." uid = self._build_source_id(source_id, source_name) if uid in self._patient_ids: del self._patient_ids[uid] return True return False def get_provider(self, id): "Retrieve a provider record by ID." return self._providers.get(id) def create_provider(self, data): "Create a provider record." uid = uuid.uuid4().int data['created_date'] = now() data['updated_date'] = now() if 'status' not in data: data['status'] = 'A' self._providers[uid] = data data['id'] = uid return data def update_provider(self, id, data): "Update a provider record by ID." if id in self._providers: data['updated_date'] = now() self._providers[id].update(data) return True return False def delete_provider(self, id): "Delete a provider record by ID." if id in self._providers: del self._providers[id] return True return False def filter_providers(self, *lookups): "Find provider records matching the given lookups." filters = map(self._lookup_to_filter, lookups) return filter(lambda t: all(f(t) for f in filters), self._providers.values())
class CompositeDecider(xapian.MatchDecider): # operators map op_map = { 'exact': operator.eq, 'iexact': i(operator.eq), 'startswith': startswith, 'istartswith': i(startswith), 'endswith': endswith, 'iendswith': i(endswith), 'contains': operator.contains, 'icontains': i(operator.contains), 'regex': regex, 'iregex': iregex, 'in': lambda a, b: operator.contains(b, a), 'gt': operator.gt, 'gte': operator.ge, 'lt': operator.lt, 'lte': operator.le, } def __init__(self, model, tags, filter, exclude): xapian.MatchDecider.__init__(self) self._model = model self._tags = tags self._values_map = dict([(t.prefix, t.number) for t in tags]) self._filter = filter self._exclude = exclude def __call__(self, document): if self._filter and not self._do_x(self._filter, document): return False if self._exclude and self._do_x(self._exclude, document): return False return True def get_tag(self, index): for tag in self._tags: if tag.number == index: return tag raise ValueError("No tag with number '%s'" % index) def _do_x(self, field, document): for child in field.children: if isinstance(child, X): result = self._do_x(child, document) else: result = self._do_field(child[0], child[1], document) if (result and field.connector == 'OR')\ or (not result and field.connector == 'AND'): break if field.negated: return not result else: return result def _do_field(self, lookup, value, document): if '__' in lookup: field, op = lookup.split('__', 1) else: field, op = lookup, 'exact' if op not in self.op_map: raise ValueError("Unknown lookup operator '%s'" % op) op = self.op_map[op] doc_value = document.get_value(self._values_map[field]) # mod #convert = curry( #self.get_tag(self._values_map[field]).convert, #model=self._model #) convert = self.get_tag(self._values_map[field]).convert if isinstance(value, (list, tuple)): value = map(convert, value) else: value = convert(value) operands = [ doc_value, value, ] return reduce(op, operands)
METRIC_STRING_LIMIT= 4096, # Trim string value of metric to 4096 unicode characters # For trigger and metrics CONDITIONS_NUMBERIC={'gt', 'gte', 'lt', 'lte', 'eq', 'neq'}, CONDITIONS_STRINGS={'contains', 'ncontains', 'exact'}, CONDITIONS_BOOLEAN={'isTrue', 'isFalse'}, CONDITIONS_CMP_FUNCTIONS={ 'gt': operator.gt, 'gte': operator.ge, 'lt': operator.lt, 'lte': operator.le, 'eq': operator.eq, 'neq': operator.ne, 'contains': operator.contains, 'ncontains': lambda x, y: not operator.contains(x, y), 'exact': operator.eq, 'isTrue': lambda x, y: x is True, 'isFalse': lambda x, y: x is False, }, SHARD_CONFIG={ "retentionPolicy": "60d", "shardDuration": "7d", "regex": "/.*/", "replicationFactor": 1, "split": 1 }, LOGGING_SHARD_CONFIG={ "retentionPolicy": "7d", "shardDuration": "1d", "regex": "/.*/",
from collections import OrderedDict res = list(OrderedDict.fromkeys(test_list)) print ("The new list is : " + str(res)) print "Number of values greater than k in list" k=4 res = filter(lambda x:x>k, test_list) print ("the Number of items greater than K in the list :" + str(len(res))) print "find substr in string" test_str ="GeeksforGeeks" res = test_str.find("eek") res2 = test_str.index("eek") import operator res3 = operator.contains(test_str, "eek") print res print res2 print res3 print "intresection of 2 lists" # initializing lists test_list1 = [ [1, 2], [3, 4], [5, 6] ] test_list2 = [ [3, 4], [5, 7], [1, 2] ] # printing both lists print ("The original list 1 : " + str(test_list1)) print ("The original list 2 : " + str(test_list2))
def __item_match_partial__(cls, x, y): ''' ''' return contains(y, x)
print("{:*^30}".format("math模块")) import math print(abs(-10)) #取绝对值 print(math.floor(4.65)) #返回数字的下舍整数 print(math.ceil(4.65)) #返回数字的上舍整数 print("{:*^30}".format("operator模块")) import operator print(operator.eq(10, 20)) #等于True,不等于False print(operator.ne(10, 20)) #不等于 print(operator.lt(10, 20)) #小于 print(operator.le(10, 20)) #小于等于 print(operator.gt(10, 20)) #大于 print(operator.ge(10, 20)) #大于等于 print("contains:", operator.contains("abcde", "abcd")) #contains(a,b),如果b in a 则True print("concat:", operator.concat("ab", "cd")) #字符串拼接 print("is:", operator.is_("ab", "ab")) #识别字符串 list2 = {"a": "b", "k": "d"} operator.setitem(list2, "k", "v") #索引赋值 print("索引赋值obj[k]=v:{}".format(list2)) operator.delitem(list2, "k") #删除赋值 print("删除赋值 obj[k]:{}".format(list2)) operator.getitem(list2, "a") #删除赋值 print("索引 obj[a]:{}".format(operator.getitem(list2, "a")))
operator.setitem(li, slice(0, 2), ["sachin", "kumar"]) print(" After modify the list :") for i in range(0, len(li)): print(li[i], end=" ") print("\r") # use of getitems with slice ass = operator.getitem(li, slice(0, 2)) print(" The use of getitems :\t", ass) # use of delitems operator.delitem(li, slice(0, 2)) print(" The use delitem :") for i in range(0, len(li)): print(li[i], end=" ") print("\r") #\\\\\\\\\ s1 = "greeksfor" s2 = " greek" print("the use of concatenate method :") print(operator.concat(s1, s2)) if (operator.contains(s1, s2)): print("greekfor conatain greek.") else: print("greekfor doesnot conatain greek ")
import operator as op print(op.add(4, 5)) print(op.mul(6, 7)) print(op.contains([1, 2, 3], 4)) x = [1, 2, 3] f = op.itemgetter(-1) print(f(x))
def in_words(word: str) -> bool: return contains(words, word)
# http://www.lightningsafety.noaa.gov/odds.shtml # Chance of being struck by lightning in your lifetime. lightning_strike = Distribution({'Struck by lightning': 1/13500, 'Safe': REST}) # http://news.nationalgeographic.com/2016/02/160209-meteorite-death-india-probability-odds/ # Chance of being killed by meteorite in your lifetime. meteorite = Distribution({'Killed by meteorite': 1/700000, 'Safe': REST}) # Common filters and maps. import operator lt = lambda s: operator.lt(*s) le = lambda s: operator.le(*s) eq = equal = equals = lambda s: operator.eq(*s) ne = not_equal = not_equals = lambda s: operator.ne(*s) gt = lambda s: operator.gt(*s) ge = lambda s: operator.ge(*s) contains = lambda s: operator.contains(*s) add = sum sub = lambda s: operator.sub(*s) difference = lambda s: abs(s[0]-s[1]) from functools import reduce mul = product = lambda s: reduce(operator.mul, s) first = lambda s: s[0] second = lambda s: s[1] third = lambda s: s[2] last = lambda s: s[-1] class Solution(Distribution): """ Uses the Distribution algorithms to model concentration of solutions.
class OpCode: cmp_op = (lt, le, eq, ne, gt, ge, lambda a, b: contains(b, a), lambda a, b: not_(contains(b, a)), is_, is_not) # 支持的比较运算符 def __init__(self, frame): self.frame = frame self.stack = frame.stack self.co_code = frame.co_code self.co_consts = frame.co_consts self.co_cellvars = frame.co_cellvars self.co_freevars = frame.co_freevars self.co_consts = frame.co_consts self.co_name = frame.co_name self.co_names = frame.co_names self.co_nlocals = frame.co_nlocals self.co_argcount = frame.co_argcount self.global_ = frame.global_ self.local = frame.local self.builtin = frame.builtin self.dict = frame.dict self.co_varnames = frame.co_varnames self.blocks = frame.blocks self.if_return = False self.opcode_dict = { '1': 'POP_TOP', '2': 'ROT_TWO', '3': 'ROT_THREE', '4': 'DUP_TOP', '5': 'DUP_TOP_TWO', '9': 'NOP', '10': 'UNARY_POSITIVE', '11': 'UNARY_NEGATIVE', '12': 'UNARY_NOT', '15': 'UNARY_INVERT', '16': 'BINARY_MATRIX_MULTIPLY', '17': 'INPLACE_MATRIX_MULTIPLY', '19': 'BINARY_POWER', '20': 'BINARY_MULTIPLY', '22': 'BINARY_MODULO', '23': 'BINARY_ADD', '24': 'BINARY_SUBTRACT', '25': 'BINARY_SUBSCR', '26': 'BINARY_FLOOR_DIVIDE', '27': 'BINARY_TRUE_DIVIDE', '28': 'INPLACE_FLOOR_DIVIDE', '29': 'INPLACE_TRUE_DIVIDE', '50': 'GET_AITER', '51': 'GET_ANEXT', '52': 'BEFORE_ASYNC_WITH', '55': 'INPLACE_ADD', '56': 'INPLACE_SUBTRACT', '57': 'INPLACE_MULTIPLY', '59': 'INPLACE_MODULO', '60': 'STORE_SUBSCR', '61': 'DELETE_SUBSCR', '62': 'BINARY_LSHIFT', '63': 'BINARY_RSHIFT', '64': 'BINARY_AND', '65': 'BINARY_XOR', '66': 'BINARY_OR', '67': 'INPLACE_POWER', '68': 'GET_ITER', '69': 'GET_YIELD_FROM_ITER', '70': 'PRINT_EXPR', '71': 'LOAD_BUILD_CLASS', '72': 'YIELD_FROM', '73': 'GET_AWAITABLE', '75': 'INPLACE_LSHIFT', '76': 'INPLACE_RSHIFT', '77': 'INPLACE_AND', '78': 'INPLACE_XOR', '79': 'INPLACE_OR', '80': 'BREAK_LOOP', '81': 'WITH_CLEANUP_START', '82': 'WITH_CLEANUP_FINISH', '83': 'RETURN_VALUE', '84': 'IMPORT_STAR', '85': 'SETUP_ANNOTATIONS', '86': 'YIELD_VALUE', '87': 'POP_BLOCK', '88': 'END_FINALLY', '89': 'POP_EXCEPT', '90': 'STORE_NAME', '91': 'DELETE_NAME', '92': 'UNPACK_SEQUENCE', '93': 'FOR_ITER', '94': 'UNPACK_EX', '95': 'STORE_ATTR', '96': 'DELETE_ATTR', '97': 'STORE_GLOBAL', '98': 'DELETE_GLOBAL', '100': 'LOAD_CONST', '101': 'LOAD_NAME', '102': 'BUILD_TUPLE', '103': 'BUILD_LIST', '104': 'BUILD_SET', '105': 'BUILD_MAP', '106': 'LOAD_ATTR', '107': 'COMPARE_OP', '108': 'IMPORT_NAME', '109': 'IMPORT_FROM', '110': 'JUMP_FORWARD', '111': 'JUMP_IF_FALSE_OR_POP', '112': 'JUMP_IF_TRUE_OR_POP', '113': 'JUMP_ABSOLUTE', '114': 'POP_JUMP_IF_FALSE', '115': 'POP_JUMP_IF_TRUE', '116': 'LOAD_GLOBAL', '119': 'CONTINUE_LOOP', '120': 'SETUP_LOOP', '121': 'SETUP_EXCEPT', '122': 'SETUP_FINALLY', '124': 'LOAD_FAST', '125': 'STORE_FAST', '126': 'DELETE_FAST', '127': 'STORE_ANNOTATION', '130': 'RAISE_VARARGS', '131': 'CALL_FUNCTION', '132': 'MAKE_FUNCTION', '133': 'BUILD_SLICE', '135': 'LOAD_CLOSURE', '136': 'LOAD_DEREF', '137': 'STORE_DEREF', '138': 'DELETE_DEREF', '141': 'CALL_FUNCTION_KW', '142': 'CALL_FUNCTION_EX', '143': 'SETUP_WITH', '144': 'EXTENDED_ARG', '145': 'LIST_APPEND', '146': 'SET_ADD', '147': 'MAP_ADD', '148': 'LOAD_CLASSDEREF', '149': 'BUILD_LIST_UNPACK', '150': 'BUILD_MAP_UNPACK', '151': 'BUILD_MAP_UNPACK_WITH_CALL', '152': 'BUILD_TUPLE_UNPACK', '153': 'BUILD_SET_UNPACK', '154': 'SETUP_ASYNC_WITH', '155': 'FORMAT_VALUE', '156': 'BUILD_CONST_KEY_MAP', '157': 'BUILD_STRING', '158': 'BUILD_TUPLE_UNPACK_WITH_CALL', '257': 'EXCEPT_HANDLER' } def opcode_1(self, oparg): """弹出栈顶元素.""" # define POP_TOP 1 self.stack.pop() def opcode_2(self, oparg): """交换栈顶和第二个的位置.""" # define ROT_TWO 2 top = self.stack.top() second = self.stack.second() self.stack.set_top(second) self.stack.set_second(top) def opcode_3(self, oparg): """栈顶三个元素之间交换.""" # define ROT_THREE 3 top = self.stack.pop() second = self.stack.pop() third = self.stack.pop() self.stack.push(top) self.stack.push(third) self.stack.push(second) def opcode_4(self, oparg): """复制栈顶并压入栈.""" # define DUP_TOP 4 top = self.stack.top() self.stack.push(top) def opcode_5(self, oparg): """复制栈顶两个元素并压入栈, 顺序不变.""" # define DUP_TOP_TWO 5 top = self.stack.top() second = self.stack.second() self.stack.push(second) self.stack.push(top) def opcode_9(self, oparg): # define NOP 9 code = "NOP" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_10(self, oparg): # define UNARY_POSITIVE 10 code = "UNARY_POSITIVE" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_11(self, oparg): """针对 -a 运算的字节码.""" # define UNARY_NEGATIVE 11 value = self.stack.pop() res = -value self.stack.push(res) def opcode_12(self, oparg): # define UNARY_NOT 12 code = "UNARY_NOT" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_15(self, oparg): # define UNARY_INVERT 15 value = self.stack.pop() res = ~value self.stack.push(res) def opcode_16(self, oparg): # define BINARY_MATRIX_MULTIPLY 16 code = "BINARY_MATRIX_MULTIPLY" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_17(self, oparg): # define INPLACE_MATRIX_MULTIPLY 17 code = "INPLACE_MATRIX_MULTIPLY" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_19(self, oparg): """乘方运算.""" # define BINARY_POWER 19 right = self.stack.pop() left = self.stack.pop() res = left**right self.stack.push(res) def opcode_20(self, oparg): """乘法运算.""" # define BINARY_MULTIPLY 20 rigth = self.stack.pop() left = self.stack.pop() res = left * rigth self.stack.push(res) def opcode_22(self, oparg): """取模运算.""" # define BINARY_MODULO 22 divisor = self.stack.pop() dividend = self.stack.pop() res = dividend % divisor self.stack.push(res) def opcode_23(self, oparg): """加法运算.""" # define BINARY_ADD 23 right = self.stack.pop() left = self.stack.pop() res = left + right self.stack.push(res) def opcode_24(self, oparg): """减法运算.""" # define BINARY_SUBTRACT 24 right = self.stack.pop() left = self.stack.pop() res = left - right self.stack.push(res) def opcode_25(self, oparg): """如果 index 是数字的话就是按照索引取值,如果是 slice 就是取子序列.""" # define BINARY_SUBSCR 25 index = self.stack.pop() list_ = self.stack.pop() value = list_[index] self.stack.push(value) def opcode_26(self, oparg): """除法运算.""" # define BINARY_FLOOR_DIVIDE 26 right = self.stack.pop() left = self.stack.pop() res = left // right self.stack.push(res) def opcode_27(self, oparg): """真除法运算.""" # define BINARY_TRUE_DIVIDE 27 right = self.stack.pop() left = self.stack.pop() res = left / right self.stack.push(res) def opcode_28(self, oparg): """就地除法运算.""" # define INPLACE_FLOOR_DIVIDE 28 right = self.stack.pop() left = self.stack.pop() left //= right self.stack.push(left) def opcode_29(self, oparg): """就地真除法运算.""" # define INPLACE_TRUE_DIVIDE 29 right = self.stack.pop() left = self.stack.pop() left /= right self.stack.push(left) def opcode_50(self, oparg): # define GET_AITER 50 code = "GET_AITER" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_51(self, oparg): # define GET_ANEXT 51 code = "GET_ANEXT" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_52(self, oparg): # define BEFORE_ASYNC_WITH 52 code = "BEFORE_ASYNC_WITH" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_55(self, oparg): """就地加法运算.""" # define INPLACE_ADD 55 right = self.stack.pop() left = self.stack.pop() left += right self.stack.push(left) def opcode_56(self, oparg): """就地减法运算.""" # define INPLACE_SUBTRACT 56 right = self.stack.pop() left = self.stack.pop() left -= right self.stack.push(left) def opcode_57(self, oparg): """就地乘法运算.""" # define INPLACE_MULTIPLY 57 right = self.stack.pop() left = self.stack.pop() left *= right self.stack.push(left) def opcode_59(self, oparg): """就地取模运算.""" # define INPLACE_MODULO 59 right = self.stack.pop() left = self.stack.pop() left %= right self.stack.push(left) def opcode_60(self, oparg): """将一个序列插入另外一个序列 a[1:2] = [1,2,3,4,5,6].""" # define STORE_SUBSCR 60 s = self.stack.pop() x = self.stack.pop() other_list = self.stack.pop() x[s] = other_list def opcode_61(self, oparg): # define DELETE_SUBSCR 61 code = "DELETE_SUBSCR" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_62(self, oparg): """左移运算""" # define BINARY_LSHIFT 62 right = self.stack.pop() left = self.stack.pop() res = left << right self.stack.push(res) def opcode_63(self, oparg): """右移运算""" # define BINARY_RSHIFT 63 rigth = self.stack.pop() left = self.stack.pop() res = left >> rigth self.stack.push(res) def opcode_64(self, oparg): """与运算""" # define BINARY_AND 64 rigth = self.stack.pop() left = self.stack.pop() res = left & rigth self.stack.push(res) def opcode_65(self, oparg): """异或运算""" # define BINARY_XOR 65 rigth = self.stack.pop() left = self.stack.pop() res = left ^ rigth self.stack.push(res) def opcode_66(self, oparg): """或运算""" # define BINARY_OR 66 rigth = self.stack.pop() left = self.stack.pop() res = left | rigth self.stack.push(res) def opcode_67(self, oparg): """就地乘方运算.""" # define INPLACE_POWER 67 right = self.stack.pop() left = self.stack.pop() left **= right self.stack.push(left) def opcode_68(self, oparg): """获取可迭代对象的迭代器.""" # define GET_ITER 68 a = self.stack.pop() it = iter(a) self.stack.push(it) def opcode_69(self, oparg): # define GET_YIELD_FROM_ITER 69 code = "GET_YIELD_FROM_ITER" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_70(self, oparg): # define PRINT_EXPR 70 code = "PRINT_EXPR" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_71(self, oparg): # define LOAD_BUILD_CLASS 71 # code = "LOAD_BUILD_CLASS" # raise RuntimeError("使用到未实现的字节码:"+code) print(self.stack) def opcode_72(self, oparg): # define YIELD_FROM 72 code = "YIELD_FROM" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_73(self, oparg): # define GET_AWAITABLE 73 code = "GET_AWAITABLE" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_75(self, oparg): # define INPLACE_LSHIFT 75 code = "INPLACE_LSHIFT" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_76(self, oparg): # define INPLACE_RSHIFT 76 code = "INPLACE_RSHIFT" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_77(self, oparg): """按位与运算""" # define INPLACE_AND 77 right = self.stack.pop() left = self.stack.pop() left &= right self.stack.push(left) def opcode_78(self, oparg): # define INPLACE_XOR 78 code = "INPLACE_XOR" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_79(self, oparg): """按位或运算""" # define INPLACE_OR 79 right = self.stack.pop() left = self.stack.pop() left |= right self.stack.push(left) def opcode_80(self, oparg): """循环结束.""" # define BREAK_LOOP 80 self.frame.index = self.forend self.stack.pop() def opcode_81(self, oparg): # define WITH_CLEANUP_START 81 code = "WITH_CLEANUP_START" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_82(self, oparg): # define WITH_CLEANUP_FINISH 82 code = "WITH_CLEANUP_FINISH" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_83(self, oparg): """返回值.""" # define RETURN_VALUE 83 value = self.stack.pop() index = frames.index(self.frame) if (index != 0): frame = frames[index - 1] frame.stack.push(value) self.if_return = True else: exit(0) def opcode_84(self, oparg): # define IMPORT_STAR 84 code = "IMPORT_STAR" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_85(self, oparg): # define SETUP_ANNOTATIONS 85 code = "SETUP_ANNOTATIONS" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_86(self, oparg): # define YIELD_VALUE 86 code = "YIELD_VALUE" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_87(self, oparg): """这个我只针对了 for 进行的处理.""" # define POP_BLOCK 87 p = self.blocks.pop() index = len(self.stack) while index > p: self.stack.pop() index -= 1 def opcode_88(self, oparg): # define END_FINALLY 88 code = "END_FINALLY" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_89(self, oparg): # define POP_EXCEPT 89 code = "POP_EXCEPT" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_90(self, oparg): """给相应对象设置名字.""" # define STORE_NAME 90 value = self.stack.pop() name = self.co_names[oparg] self.local[name] = value def opcode_91(self, oparg): # define DELETE_NAME 91 code = "DELETE_NAME" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_92(self, oparg): """从堆栈中获取一个可迭代的对象然后对它进行拆包然后倒序压入栈""" # define UNPACK_SEQUENCE 92 sequence = self.stack.pop() for item in sequence[::-1]: self.stack.push(item) def opcode_93(self, oparg): # define FOR_ITER 93 it = self.stack.top() try: value = next(it) self.stack.push(value) except StopIteration: self.stack.pop() self.frame.index += oparg def opcode_94(self, oparg): # define UNPACK_EX 94 code = "UNPACK_EX" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_95(self, oparg): # define STORE_ATTR 95 code = "STORE_ATTR" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_96(self, oparg): # define DELETE_ATTR 96 code = "DELETE_ATTR" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_97(self, oparg): # define STORE_GLOBAL 97 name = self.co_names[oparg] value = self.stack.pop() self.global_[name] = value def opcode_98(self, oparg): # define DELETE_GLOBAL 98 code = "DELETE_GLOBAL" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_100(self, oparg): # define LOAD_CONST 100 value = self.co_consts[oparg] self.stack.push(value) def opcode_101(self, oparg): # define LOAD_NAME 101 name = self.co_names[oparg] value = None if name in self.local: value = self.local[name] if not value: if name in self.global_: value = self.global_[name] if not value: if name in self.builtin: value = self.builtin[name] self.stack.push(value) def opcode_102(self, oparg): # define BUILD_TUPLE 102 list_ = [] for _ in range(oparg): a = self.stack.pop() list_.append(a) res = tuple(list_[::-1]) self.stack.push(res) def opcode_103(self, oparg): # define BUILD_LIST 103 list_ = [] for i in range(oparg): value = self.stack.pop() list_.append(value) self.stack.push(list_[::-1]) def opcode_104(self, oparg): # define BUILD_SET 104 code = "BUILD_SET" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_105(self, oparg): # define BUILD_MAP 105 res = {} values = [] keys = [] for _ in range(oparg): values.append(self.stack.pop()) keys.append(self.stack.pop()) for key, value in zip(keys[::-1], values[::-1]): res[key] = value self.stack.push(res) def opcode_106(self, oparg): """屏蔽所以 LOAD_ATTR 中以 __ 开头的并且不是 __init__ 的所有属性""" # define LOAD_ATTR 106 c = self.stack.pop() name = self.co_names[oparg] assert not (name.startswith("__") and name != "__init__") res = getattr(c, name) self.stack.push(res) def opcode_107(self, oparg): # define COMPARE_OP 107 right = self.stack.pop() left = self.stack.pop() cmp_ = self.cmp_op[oparg] res = cmp_(left, right) self.stack.push(res) def opcode_108(self, oparg): # define IMPORT_NAME 108 code = "IMPORT_NAME" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_109(self, oparg): # define IMPORT_FROM 109 code = "IMPORT_FROM" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_110(self, oparg): # define JUMP_FORWARD 110 self.frame.index += oparg def opcode_111(self, oparg): # define JUMP_IF_FALSE_OR_POP 111 cond = self.stack.top() if cond is True: self.stack.pop() else: self.frame.index = oparg def opcode_112(self, oparg): # define JUMP_IF_TRUE_OR_POP 112 cond = self.stack.top() if cond is True: self.frame.index = oparg else: self.stack.pop() def opcode_113(self, oparg): # define JUMP_ABSOLUTE 113 self.frame.index = oparg def opcode_114(self, oparg): # define POP_JUMP_IF_FALSE 114 a = self.stack.pop() if a: pass else: self.frame.index = oparg def opcode_115(self, oparg): # define POP_JUMP_IF_TRUE 115 a = self.stack.pop() if a: self.frame.index = oparg def opcode_116(self, oparg): # define LOAD_GLOBAL 116 name = self.co_names[oparg] if name in self.global_: value = self.global_[name] else: value = self.builtin[name] self.stack.push(value) def opcode_119(self, oparg): # define CONTINUE_LOOP 119 code = "CONTINUE_LOOP" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_120(self, oparg): # define SETUP_LOOP 120 p = len(self.stack) self.blocks.push(p) # 将当前运行时栈长度压入 blocks 栈 self.forend = self.frame.index + oparg def opcode_121(self, oparg): # define SETUP_EXCEPT 121 code = "SETUP_EXCEPT" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_122(self, oparg): # define SETUP_FINALLY 122 code = "SETUP_FINALLY" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_124(self, oparg): # define LOAD_FAST 124 name = self.co_varnames[oparg] try: value = self.dict[self.co_varnames[oparg]] except KeyError as e: raise TypeError("missing " + name) self.stack.push(value) def opcode_125(self, oparg): # define STORE_FAST 125 name = self.co_varnames[oparg] value = self.stack.pop() self.dict[name] = value def opcode_126(self, oparg): # define DELETE_FAST 126 code = "DELETE_FAST" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_127(self, oparg): # define STORE_ANNOTATION 127 code = "STORE_ANNOTATION" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_130(self, oparg): # define RAISE_VARARGS 130 code = "RAISE_VARARGS" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_131(self, oparg): # define CALL_FUNCTION 131 args = [] for _ in range(oparg): args.append(self.stack.pop()) func = self.stack.pop() if callable(func): res = func(*args[::-1]) self.stack.push(res) elif (isinstance(func, Function)): frame = new_frame(func) if oparg > frame.co_argcount: raise TypeError( f"{frame.co_name}() takes {frame.co_argcount} positional \ arguments but {oparg} were given") if oparg < frame.co_argcount: raise TypeError( f"{frame.co_name}() missing {frame.co_argcount - oparg} \ required positional arguments: " + ",".join(frame.co_varnames[oparg:])) for name, value in zip(func.varnames, args[::-1]): frame.dict[name] = value frames.append(frame) run(frame) frames.pop() else: raise RuntimeError("有些事情没有考虑到") def opcode_132(self, oparg): # define MAKE_FUNCTION 132 name = self.stack.pop() mycode = self.stack.pop() f = Function(name, mycode) for i in f.freevars: f.dict[i] = self.dict[i] self.stack.push(f) def opcode_133(self, oparg): # define BUILD_SLICE 133 args = [] for _ in range(oparg): args.append(self.stack.pop()) value = slice(*args[::-1]) self.stack.push(value) def opcode_135(self, oparg): # define LOAD_CLOSURE 135 key = self.co_cellvars[oparg] value = self.dict[key] self.stack.push(value) def opcode_136(self, oparg): # define LOAD_DEREF 136 cell = self.co_freevars[oparg] value = self.dict[cell] self.stack.push(value) def opcode_137(self, oparg): # define STORE_DEREF 137 value = self.stack.pop() key = self.co_cellvars[oparg] self.dict[key] = value def opcode_138(self, oparg): # define DELETE_DEREF 138 code = "DELETE_DEREF" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_141(self, oparg): # define CALL_FUNCTION_KW 141 code = "CALL_FUNCTION_KW" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_142(self, oparg): # define CALL_FUNCTION_EX 142 code = "CALL_FUNCTION_EX" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_143(self, oparg): # define SETUP_WITH 143 code = "SETUP_WITH" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_144(self, oparg): """计算下一条字节码的参数""" # define EXTENDED_ARG 144 oldoparg = oparg oparg = self.frame.co_code[self.frame.index + 1] oparg |= oldoparg << 8 self.frame.co_code[self.frame.index + 1] = oparg def opcode_145(self, oparg): # define LIST_APPEND 145 v = self.stack.pop() list_ = self.stack.peek(oparg) list_.append(v) def opcode_146(self, oparg): # define SET_ADD 146 code = "SET_ADD" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_147(self, oparg): # define MAP_ADD 147 key = self.stack.pop() value = self.stack.pop() map_ = self.stack.peek(oparg) map_[key] = value def opcode_148(self, oparg): # define LOAD_CLASSDEREF 148 code = "LOAD_CLASSDEREF" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_149(self, oparg): # define BUILD_LIST_UNPACK 149 code = "BUILD_LIST_UNPACK" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_150(self, oparg): # define BUILD_MAP_UNPACK 150 code = "BUILD_MAP_UNPACK" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_151(self, oparg): # define BUILD_MAP_UNPACK_WITH_CALL 151 code = "BUILD_MAP_UNPACK_WITH_CALL" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_152(self, oparg): # define BUILD_TUPLE_UNPACK 152 code = "BUILD_TUPLE_UNPACK" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_153(self, oparg): # define BUILD_SET_UNPACK 153 code = "BUILD_SET_UNPACK" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_154(self, oparg): # define SETUP_ASYNC_WITH 154 code = "SETUP_ASYNC_WITH" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_155(self, oparg): # define FORMAT_VALUE 155 code = "FORMAT_VALUE" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_156(self, oparg): # define BUILD_CONST_KEY_MAP 156 keys = self.stack.pop() values = [] for _ in range(oparg): t = self.stack.pop() values.append(t) values = values[::-1] res = dict(zip(keys, values)) self.stack.push(res) def opcode_157(self, oparg): # define BUILD_STRING 157 code = "BUILD_STRING" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_158(self, oparg): # define BUILD_TUPLE_UNPACK_WITH_CALL 158 code = "BUILD_TUPLE_UNPACK_WITH_CALL" raise RuntimeError("使用到未实现的字节码:" + code) def opcode_257(self, oparg): # define EXCEPT_HANDLER 25 code = "EXCEPT_HANDLER" raise RuntimeError("使用到未实现的字节码:" + code)
from startup import get_url base_url = get_url() except ImportError: base_url = get_request_site_address() if not label: label = name return """<a href="%(base_url)s/app.html#!Form/%(doctype)s/%(name)s">%(label)s</a>""" % locals() import operator operator_map = { # startswith "^": lambda (a, b): (a or "").startswith(b), # in or not in a list "in": lambda (a, b): operator.contains(b, a), "not in": lambda (a, b): not operator.contains(b, a), # comparison operators "=": lambda (a, b): operator.eq(a, b), "!=": lambda (a, b): operator.ne(a, b), ">": lambda (a, b): operator.gt(a, b), "<": lambda (a, b): operator.lt(a, b), ">=": lambda (a, b): operator.ge(a, b), "<=": lambda (a, b): operator.le(a, b), } def compare(val1, condition, val2): if condition in operator_map: return operator_map[condition]((val1, val2))
def test_contains(self): self.assertRaises(TypeError, operator.contains) self.assertRaises(TypeError, operator.contains, None, None) self.assertTrue(operator.contains(range(4), 2)) self.assertFalse(operator.contains(range(4), 5))
def not_contains(container, element): """Antonym of :func:`operator.contains`""" return not operator.contains(container, element)
def test_contains(self): self.failUnless(operator.contains(range(4), 2)) self.failIf(operator.contains(range(4), 5)) self.failUnless(operator.sequenceIncludes(range(4), 2)) self.failIf(operator.sequenceIncludes(range(4), 5))
def evaluate(expression): return contains(transite(store, expression))
'is': operator.is_, 'is_not': operator.is_not, '+': operator.add, '&': operator.and_, '/': operator.truediv, '//': operator.floordiv, '<<': operator.lshift, '%': operator.mod, '*': operator.mul, '|': operator.or_, '**': operator.pow, '>>': operator.rshift, '-': operator.sub, '^': operator.xor, 'in': operator.contains, 'not_in': lambda x, y: not operator.contains(x, y), 'and': operator.and_, 'or': operator.or_, } # shamelessly copied from Cython compile_time_unary_operators = { 'not': operator.not_, '~': operator.inv, '-': operator.neg, '+': operator.pos, } ast_to_binary_operator = { ast.Add: '+', ast.Sub: '-',
COMPARATORS = { 'count_eq': lambda x, y: safe_length(x) == y, 'lt': operator.lt, 'less_than': operator.lt, 'le': operator.lt, 'less_than_or_equal': operator.lt, 'eq': operator.eq, 'equals': operator.eq, 'str_eq': lambda x, y: operator.eq(str(x), str(y)), 'ne': operator.ne, 'not_equals': operator.ne, 'ge': operator.ge, 'greater_than_or_equal': operator.ge, 'gt': operator.gt, 'greater_than': operator.gt, 'contains': lambda x, y: x and operator.contains(x, y), # is y in x 'contained_by': lambda x, y: y and operator.contains(y, x), # is x in y 'regex': lambda x, y: regex_compare(str(x), str(y)), 'type': lambda x, y: test_type(x, y) } COMPARATORS['length_eq'] = COMPARATORS['count_eq'] # Allow for testing basic types in comparators TYPES = { 'null': type(None), 'none': type(None), 'number': (int, long, float), 'int': (int, long), 'float': float, 'boolean': bool, 'string': basestring,
def open_proto_file(main_file, package_name): new_proto_single_file = main_file.replace("raw_protos.proto", "POGOProtos.Rpc.proto") # Add licenses head = '/*\n' head += '* Copyright 2016-2020 --=FurtiF=-- Co., Ltd.\n' head += '*\n' head += '* Licensed under the\n' head += '* Educational Community License, Version 2.0 (the "License"); you may\n' head += '* not use this file except in compliance with the License. You may\n' head += '* obtain a copy of the License at\n' head += '*\n' head += '* http://www.osedu.org/licenses/ECL-2.0\n' head += '*\n' head += '* Unless required by applicable law or agreed to in writing,\n' head += '* software distributed under the License is distributed on an "AS IS"\n' head += '* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\n' head += '* or implied. See the License for the specific language governing\n' head += '* permissions and limitations under the License.\n' head += '*/\n\n' head += 'syntax = "proto3";\n' head += 'package %s;\n\n' % package_name if os.path.exists(new_proto_single_file): os.unlink(new_proto_single_file) open_for_new = open(new_proto_single_file, 'a') if not gen_only: # Add options by language if java_multiple_files and lang == "java": head += 'option java_multiple_files = true;\n\n' elif lang == "cpp": head += 'option optimize_for = CODE_SIZE;\n\n' open_for_new.writelines(head) messages = '' is_enum = False enum_name = '' is_one_off = False refs = [] is_ignored = False fixed_messages = '' with open(main_file, 'r') as proto_file: for proto_line in proto_file.readlines(): if is_ignored and operator.contains(proto_line, "}"): is_ignored = False if operator.contains(proto_line, "//ignored_"): messages += proto_line is_ignored = True continue if is_ignored: messages += proto_line continue if proto_line.startswith("syntax"): continue if proto_line.startswith("package"): continue # Ignore file licenses if proto_line.startswith("/*"): continue if proto_line.startswith("*"): continue if proto_line.startswith("*/"): continue # --- if is_blank(proto_line): continue if proto_line.startswith("enum"): is_enum = True enum_name = re.split(r'\s', proto_line)[1].upper() # refs if operator.contains(proto_line, "// ref:"): refs.append(proto_line.replace("// ref:", "").strip()) if operator.contains(proto_line, "}") and refs: refs.pop() # OneOf stuff here if operator.contains(proto_line, "//oneof"): is_one_off = True # --- if operator.contains(proto_line, "//") and is_one_off: if gen_one_off: if operator.contains(proto_line, "none = 0;"): continue proto_line = proto_line.replace("//", "") if not operator.contains(proto_line, "{") and not operator.contains( proto_line, "}"): field = proto_line.split("=")[0].strip() refName = "/".join(refs[-1].split("/")[:-1]) proto_line = "#" + refName + "#" + field + "#" else: continue if is_one_off and operator.contains(proto_line, "}"): is_one_off = False if is_enum: if not proto_line.startswith("enum"): if not proto_line.startswith("}"): e = proto_line.replace( re.split(r'(\W+)', proto_line)[2], enum_name + "_" + re.split(r'(\W+)', proto_line)[2]) proto_line = e if not is_one_off and gen_one_off and operator.contains( proto_line, "=") and refs: split = proto_line.strip().split(" ", 2) field = split[1].strip() target = "#" + refs[-1] + "#" + field + "#" if target in messages: messages = messages.replace(target, "\t" + proto_line) continue messages += proto_line if not proto_line.startswith("}") and operator.contains( proto_line, "}"): messages += "\n" is_one_off = False is_enum = False if proto_line.startswith("}"): messages += "\n" is_enum = False enum_name = '' is_one_off = False if gen_one_off: messagesNew = "" lastLine = "" refs = [] is_one_off = False skip = False setSkipFalse = False removeLast = False refsCount = {} for proto_line in messages.split("\n"): if operator.contains(proto_line, "// ref:"): refs.append(proto_line.replace("// ref:", "").strip()) if operator.contains(proto_line, "}") and refs: refs.pop() if operator.contains(proto_line, "oneof") and refs: is_one_off = True count = len(messages.split("// ref: " + refs[-1] + "\n")) - 1 if not refs[-1] in refsCount: refsCount[refs[-1]] = 0 refsCount[refs[-1]] += 1 if not count == refsCount[refs[-1]]: skip = True removeLast = True if is_one_off and operator.contains(proto_line, "}"): is_one_off = False setSkipFalse = True if not skip and not ( (operator.contains(proto_line, "// ref:") or operator.contains(proto_line, "//----")) and gen_only): if not removeLast: messagesNew += lastLine removeLast = False lastLine = proto_line + "\n" elif skip: removeLast = False if setSkipFalse: skip = False setSkipFalse = False messages = messagesNew message_for_fix = None for fix_line in messages.split("\n"): # ignore refs if fix_line.startswith("message"): match = re.split(r'\s', fix_line) message_for_fix = match[1] elif fix_line.startswith("enum"): match = re.split(r'\s', fix_line) message_for_fix = match[1] ## Check for all bytes refs # if operator.contains(fix_line, "\tbytes"): # byte = fix_line.split("=") # byte_fix = byte[0].replace("\t","")[:-1] # print('elif message_for_fix == "' + message_for_fix + '" and operator.contains(fix_line, "' + byte_fix +'"):') # print('\tfix_line = fix_line.replace("bytes", "Good_Proto_Here")') # Replace bytes for good proto here by condition if message_for_fix == "ClientGameMasterTemplateProto" and operator.contains( fix_line, "bytes data"): fix_line = fix_line.replace("bytes", "PBMGHIOCLGG") # elif message_for_fix == "BackgroundToken" and operator.contains(fix_line, "bytes token"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "BackgroundToken" and operator.contains(fix_line, "bytes iv"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "InventoryItemProto" and operator.contains(fix_line, "bytes deleted_item_key"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") elif message_for_fix == "InventoryItemProto" and operator.contains( fix_line, "bytes item"): fix_line = fix_line.replace("bytes", "MKBNBGHGGBA") # elif message_for_fix == "ProxyRequestProto" and operator.contains(fix_line, "bytes payload"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "ProxyResponseProto" and operator.contains(fix_line, "bytes payload"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "AEECDHCIKCM" and operator.contains(fix_line, "bytes eafbmckfnli"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "ANOMPFPBIPM" and operator.contains(fix_line, "bytes lfcpdhhaefn"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "ANOMPFPBIPM" and operator.contains(fix_line, "bytes lakniimfnlb"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "BBAJDEEEDEF" and operator.contains(fix_line, "bytes cpijocndncp"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "CEHDJEMNBBC" and operator.contains(fix_line, "bytes pjnecadedfi"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "FitnessReportProto" and operator.contains(fix_line, "bytes game_data"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "GADPHKHAIMJ" and operator.contains(fix_line, "bytes pjnecadedfi"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "GPHLJOLGGMF" and operator.contains(fix_line, "bytes jjfjedaecam"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "GPHLJOLGGMF" and operator.contains(fix_line, "bytes edilgaoikmd"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "HAAJDBDDIIJ" and operator.contains(fix_line, "bytes bdlohknpdhl"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "IFPNMHEPBGF" and operator.contains(fix_line, "bytes dcongihbmfb"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "JFJNABPPJLH" and operator.contains(fix_line, "bytes kaiamlgepej"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "JHDOEDMJKHI" and operator.contains(fix_line, "bytes moljgjghggp"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "JMOJFCBHMPO" and operator.contains(fix_line, "bytes bdlohknpdhl"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "LDBLNDNGEEC" and operator.contains(fix_line, "bytes gbddmbdejfj"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "LMJMNIKIMMF" and operator.contains(fix_line, "bytes kaiamlgepej"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "MKOOLBIJEBG" and operator.contains(fix_line, "bytes pjnecadedfi"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "NEJJFPEMFAP" and operator.contains(fix_line, "bytes kaiamlgepej"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "NNFGPFNNGNB" and operator.contains(fix_line, "bytes moljgjghggp"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "PHEGKNLDPFP" and operator.contains(fix_line, "bytes pjnecadedfi"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "PlatformClientApiSettingsProto" and operator.contains(fix_line, "bytes payload"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "RedeemPasscodeResponseProto" and operator.contains(fix_line, "bytes acquired_items_proto"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "AddLoginActionProto" and operator.contains(fix_line, "bytes inner_message"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") elif message_for_fix == "DownloadSettingsResponseProto" and operator.contains( fix_line, "bytes values"): fix_line = fix_line.replace("bytes", "PGBOCBAKEJG") # elif message_for_fix == "FriendDetailsProto" and operator.contains(fix_line, "bytes friend_visible_data"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "FriendDetailsProto" and operator.contains(fix_line, "bytes data_with_me"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "GetFriendsListOutProto" and operator.contains(fix_line, "bytes data_with_me"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "GetFriendsListOutProto" and operator.contains(fix_line, "bytes shared_data"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "GetFriendsListOutProto" and operator.contains(fix_line, "bytes data_from_me"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "GetFriendsListOutProto" and operator.contains(fix_line, "bytes data_to_me"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "PlayerSummaryProto" and operator.contains(fix_line, "bytes public_data"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "TemplateVariable" and operator.contains(fix_line, "bytes byte_value"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "ClientTelemetryRecordProto" and operator.contains(fix_line, "bytes encoded_message"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") # elif message_for_fix == "MapTileDataProto" and operator.contains(fix_line, "bytes tile_data"): # fix_line = fix_line.replace("bytes", "Good_Proto_Here") fixed_messages += fix_line + "\n" messages = fixed_messages[:-1] open_for_new.writelines(messages[:-1]) open_for_new.close() add_command_for_new_proto_file(new_proto_single_file)
" make something too long.") return a + b ######################################## # Defaults for the evaluator: DEFAULT_OPERATORS = {ast.Add: safe_add, ast.Sub: op.sub, ast.Mult: safe_mult, ast.Div: op.truediv, ast.FloorDiv: op.floordiv, ast.Pow: safe_power, ast.Mod: op.mod, ast.Eq: op.eq, ast.NotEq: op.ne, ast.Gt: op.gt, ast.Lt: op.lt, ast.GtE: op.ge, ast.LtE: op.le, ast.Not: op.not_, ast.USub: op.neg, ast.UAdd: op.pos, ast.In: lambda x, y: op.contains(y, x), ast.NotIn: lambda x, y: not op.contains(y, x), ast.Is: lambda x, y: x is y, ast.IsNot: lambda x, y: x is not y, } DEFAULT_FUNCTIONS = {"rand": random, "randint": random_int, "int": int, "float": float, "str": str if PYTHON3 else unicode} DEFAULT_NAMES = {"True": True, "False": False, "None": None} ATTR_INDEX_FALLBACK = True ########################################
def RelationalExpression(e, ctx): expr = e.expr other = e.other op = e.op # because of the way the add-expr production handled operator precedence # we sometimes have nothing to do if other is None: return expr ops = dict([('>', lambda x, y: x.__gt__(y)), ('<', lambda x, y: x.__lt__(y)), ('=', lambda x, y: x.eq(y)), ('!=', lambda x, y: x.neq(y)), ('>=', lambda x, y: x.__ge__(y)), ('<=', lambda x, y: x.__le__(y)), ('IN', pyop.contains), ('NOT IN', lambda x, y: not pyop.contains(x, y))]) if op in ('IN', 'NOT IN'): res = (op == 'NOT IN') error = False if other == RDF.nil: other = [] for x in other: try: if x == expr: return Literal(True ^ res) except SPARQLError as e: error = e if not error: return Literal(False ^ res) else: raise error if not op in ('=', '!=', 'IN', 'NOT IN'): if not isinstance(expr, Literal): raise SPARQLError( "Compare other than =, != of non-literals is an error: %r" % expr) if not isinstance(other, Literal): raise SPARQLError( "Compare other than =, != of non-literals is an error: %r" % other) else: if not isinstance(expr, Node): raise SPARQLError('I cannot compare this non-node: %r' % expr) if not isinstance(other, Node): raise SPARQLError('I cannot compare this non-node: %r' % other) if isinstance(expr, Literal) and isinstance(other, Literal): if expr.datatype is not None and expr.datatype not in XSD_DTs and other.datatype is not None and other.datatype not in XSD_DTs: # in SPARQL for non-XSD DT Literals we can only do =,!= if op not in ('=', '!='): raise SPARQLError( 'Can only do =,!= comparisons of non-XSD Literals') try: r = ops[op](expr, other) if r == NotImplemented: raise SPARQLError('Error when comparing') except TypeError as te: raise SPARQLError(*te.args) return Literal(r)
elif "chdir " in command: dirpath = command.replace("chdir ", "") dirpath = dirpath.replace("\n", "") ftph.cwd(dirpath) print "Directory changed to " + dirpath continue elif command == "up": dir = ftph.pwd() temp = dir index = len(dir) - 1 for i in range(index, 0, -1): if temp[i] == "/" and i != len(dir): ftph.cwd(temp) print "One directory back." continue if (operator.contains(charset, dir[i])): temp = temp[:-1] if temp == "/": ftph.cwd(temp) print "One directory back." elif command == "rename": fromname = raw_input("Current file name: ") toname = raw_input("To be changed to: ") ftph.rename(fromname, toname) print "Successfully renamed." continue elif "delete " in command: delfile = command.replace("delete ", "") delfile = delfile.replace("\n", "") ftph.delete(delfile) print "File successfully deleted."
def in_usecase(x, y): return operator.contains(y, x)
class Condition(): ''' Condition represents a single condition. It is modified based on the selector class from Orange package. (in particualr, Orange.classification.rule) ''' OPERATORS = { # discrete, nominal variables # '==': operator.eq, # '=': operator.eq, # '!=': operator.ne, 'in': lambda x, y: operator.contains(y, x), # note the reverse order of argument in the contains function # continuous variables '<=': operator.le, '>=': operator.ge, '<': operator.lt, '>': operator.gt, } def __init__(self, column, values=None, min_value=None, max_value=None, type='categorical'): ''' differs in the number of arguments as for categorical feature and continuous features ''' self.type = type if type == 'categorical': # for categorical features self.column = column # value_1 is a set of possible values self.values = values elif type == 'continuous': # for continuous features self.column = column self.min = min_value self.max = max_value else: print( "critical error. Type of selector unspecified. Must be one of categorical or continuous " ) def filter_instance(self, x): """ Filter a single instance. Returns true or false """ if self.type == 'categorical': return Condition.OPERATORS['in'](x[self.column], self.values) elif self.type == 'continuous': return Condition.OPERATORS['<=']( x[self.column], self.max) and Condition.OPERATORS['>=']( x[self.column], self.min) def filter_data(self, X): """ Filter several instances concurrently. Retunrs array of bools """ if self.type == 'categorical': # return np.logical_or.reduce( # [np.equal(X[:,self.column], v) for v in self.values ] # ) tmp = np.stack( [np.equal(X[:, self.column], v) for v in self.values]) return np.any(tmp, axis=0) elif self.type == 'continuous': return np.logical_and( Condition.OPERATORS['<='](X[:, self.column], self.max), Condition.OPERATORS['>='](X[:, self.column], self.min)) def __deepcopy__(self, memodict={}): # copy_object = Condition() # copy_object.value = self.value if self.type == 'categorical': column = self.column values = self.values[:] return Condition(column=column, values=values, type='categorical') # return Condition(column=deepcopy(self.column,memodict),values=deepcopy(self.values,memodict),type='categorical') elif self.type == 'continuous': return Condition(column=self.column, min_value=self.min, max_value=self.max, type='continuous') else: print( "critical error. deep copy error! __deepcopy__ for Condition ") quit() def sample(self, batch_size=10): if self.type == 'categorical': synthetic_column = np.random.choice(self.values, size=batch_size) print("all possible values", self.values) print("generated values", synthetic_instances) print("check this categorical generation!") quit() return synthetic_instances elif self.type == 'continuous': synthetic_column = np.random.uniform(low=self.min, high=self.max, size=batch_size) return synthetic_column def __eq__(self, other): # return self.conditions == other.conditions if self.type != other.type: raise Exception( 'two selector should have the same type. The value of s1 was: {0} and the type of s2 was: {1}' .format(self.type, other.type)) return if self.type == 'categorical': return self.values == other.values elif self.type == 'continuous': return self.min == other.min and self.max == other.max else: raise Exception('critical error: unknown selector type {}'.format( self.type)) return
def not_in_usecase(x, y): return not operator.contains(y, x)
from urllib.request import urlopen from bs4 import BeautifulSoup import requests import operator st = "http://www.burjeel.com/abu-dhabi/dr/" page = requests.get("http://www.burjeel.com/abu-dhabi/doctors/") dr1 = [] soup = BeautifulSoup(page.content, 'html.parser') list1 = ((soup.find_all('h4'))) dr2 = [name1.get_text() for name1 in list1] dr1 = [name for name in dr2 if name.startswith("Dr.")] for jj in range(0, len(dr1)): dr1[jj] = dr1[jj].lower() dr1[jj] = dr1[jj].replace(" ", "-") dr1[jj] = dr1[jj].replace(".", "") dr1[jj] = dr1[jj][:-1] link = st + dr1[jj] + "/" page1 = requests.get(link) dr11 = [] soup = BeautifulSoup(page1.content, 'html.parser') list11 = ((soup.find_all('h3'))) dr11 = [name12.get_text() for name12 in list11] dr21 = [ name11 for name11 in dr11 if operator.contains(name11, "Specialist") or operator.contains(name11, "Consultant") or operator.contains( name11, "General") or operator.contains(name11, "Chief") ] print(dr1[jj], end=" -> ") print(dr21)
def in_(a, b): if isinstance(a, (list, tuple)): return any(operator.contains(b, x) for x in a) else: return operator.contains(b, a)
print operator.and_(1, 1) #按位或 即 a|b print operator.or_(1, 8) print operator.or_(1, 3) #按位异或 即 a^b print operator.xor(1, 8) print operator.xor(1, 3) #合并,不过只能用于序列 print operator.concat([1, 2], [3, 4]) print operator.concat(("one", ), ("two", )) #是否包含,同样是序列 print operator.contains([1, 2, 3], 2) print operator.contains([1, 2, 3], 0) #包含位置,同样是序列 print operator.indexOf([1, 2, 3], 2) #如果没有,则会抛出一个异常 # print operator.indexOf([1,2,3],0) #包含 同 in print operator.sequenceIncludes([1, 2, 3], 1) print operator.sequenceIncludes("123", "1") #计数,计算某个值在序列中出现的次数 print operator.countOf([1, 2, 1, 3, 1], 1) #set序列可以去重 print operator.countOf(set([1, 2, 1, 3, 1]), 1)
def in_impl(a, b): return operator.contains(b, a)