def _decoder(self): symbol_table = self.symbol_table.table decoder = functools.partial( self._object_decoder, symbol_table=symbol_table.__getitem__ if symbol_table else self._as_type, ) return JSONDecoder(object_hook=decoder, strict=True)
def from_json(cls, json: str): """ Deserialize from json :param str json: the json string :return: a board :rtype: Board """ # step 1 - init object board = Board(1, 1, 0) obj = JSONDecoder().decode(json) # step 2 - load the data into the board object obj["_is_mine"] = np.array(obj["_is_mine"]) obj["_is_open"] = np.array(obj["_is_open"]) obj["_adj_mines"] = np.array(obj["_adj_mines"]) obj["_marker"] = np.array(obj["_marker"]) board.__dict__ = obj # step 3 - load exposed squares exposed = [] for x in range(board.x): for y in range(board.y): if board._is_open[x, y]: board._append_mine(x, y, exposed) # step 4 - load markers markers = [] for x in range(board.x): for y in range(board.y): if board._marker[x, y] != Marker.clear and not board._is_open[x, y]: markers.append((x, y, board._marker[x, y])) return board, exposed, markers
def find_JSON_format_data_structure( string, name, found, not_found, cannot_parse_JSON ): """Finds a named JSON-format data structure in the string. The name can be any string. The pattern "name = " will be looked for in the string, and the data structure following it parsed and returned as a python data structure. """ try: name_start = string.index(name) except ValueError: not_found(name, string) else: name_length = len(name) name_end = name_start + name_length _, remaining = re.Scanner([ (r"\s*=\s*", lambda scanner, token: None) ]).scan( string[name_end:] ) try: data, end_position = JSONDecoder().raw_decode(remaining) except ValueError, value_error: cannot_parse_JSON(remaining) else:
def _geolocate(networks): if networks: p = '/maps/api/browserlocation/json?browser=sploitego&sensor=true' for n in networks: p += '&%s' % urlencode({ 'wifi': 'mac:%s|ssid:%s|ss:%s' % (_fullmac(n['mac']), n['ssid'], n['ss']) }) print p c = HTTPSConnection('maps.googleapis.com') c.request('GET', p) r = c.getresponse() if r.status == 200 and r.getheader('Content-Type').startswith( 'application/json'): j = JSONDecoder() d = j.decode(r.read()) if d['status'] == 'OK': l = d['location'] return { 'latitude': l['lat'], 'longitude': l['lng'], 'accuracy': d['accuracy'] } raise GeoLocateError('Unable to geolocate.')
def __init__(self, json_record): decoder = JSONDecoder() values = decoder.decode(json_record) self.state_code = values['stateCode'] self.country_code = values['countryCode'] self.site_num = values['siteNum'] self.parameter_code = values['parameterCode'] self.poc = values['poc'] self.lat = values['latitude'] self.lon = values['longitude'] self.datum = values['datum'] self.parameter_name = values['parameterName'] self.date_local = values['dateLocal'] self.time_local = values['timeLocal'] self.date_gmt = values['dateGMT'] self.time_gmt = values['timeGMT'] self.sample_measurement = values['sampleMeasurement'] self.units_of_measure = values['unitsOfMeasure'] self.mdl = values['mdl'] self.uncertainty = values['uncertainty'] self.qualifier = values['qualifier'] self.method_type = values['methodType'] self.method_code = values['methodCode'] self.method_name = values['methodName'] self.state_name = values['stateName'] self.county_name = values['countyName'] self.date_of_last_change = values['dateOfLastChange'] self.prediction = float(values['prediction']) self.error = float(values['error']) self.anomaly = float(values['anomaly']) self.prediction_next = float(values['predictionNext'])
def testGetBasicRecForbResFromBZ(bzList): ''' in this function, bzList must be the dic--confBZRes's keys ''' rfCacheFilePath = ROOT_PATH.auto_config_root( ) + u'model_cache/find_cache/bzRecForbDics.json' recommend_start = time.clock() rfCacheFile = open(rfCacheFilePath, 'r') line = rfCacheFile.readline() bzRecForbDics = JSONDecoder().decode(line) rfCacheFile.close() recSCList = [] forbSCList = [] for bz in bzList: if bz in bzRecForbDics.keys(): recSCList.extend(bzRecForbDics[bz]['0']) forbSCList.extend(bzRecForbDics[bz]['1']) recSCList = list(set(recSCList)) # de-duplication, same below forbSCList = list(set(forbSCList)) recommend_end = time.clock() print('recommend foods run time: %f s' % (recommend_end - recommend_start)) print('推荐食材(基础):') for sc in recSCList: print(sc + ', '), print('\n----------------------------------------------------------') print('禁忌食材(基础):') for sc in forbSCList: print(sc + ', '), print('\n----------------------------------------------------------')
def change_logs(self): result = list() try: change_logs = CITaskHistoryService.get_change_log( self.ci_task_history.ChangeLog) json_decoder = JSONDecoder() if change_logs: all_resp_changes = json_decoder.decode( change_logs['change_log']) index = 1 for resp_changes in all_resp_changes: repo = resp_changes['repo'] for changes in resp_changes['changes']: temp_changelog = VM_CITaskChangeLog( changes, index, repo) result.append(temp_changelog) index = index + 1 elif self.ci_task_history.CodeVersion: all_changes = json_decoder.decode( self.ci_task_history.CodeVersion) temp_changelog = VM_CITaskChangeLog(all_changes[0], 0, "") result.append(temp_changelog) except Exception as ex: SimpleLogger.exception(ex) return result
def new_decoder(): from json.decoder import JSONDecoder from json.scanner import py_make_scanner decoder = JSONDecoder() decoder.parse_object = NBDecoder decoder.scan_once = py_make_scanner(decoder) return decoder
def _refresh_window_state(self): """ The alerts and other required data for managing alerts are stored as a Javascript array in window.STATE. Returns: The parsed value of window.STATE """ alerts_url = 'https://www.' + _GOOGLE_DOMAIN + '/alerts?hl=en&gl=us' response = self.opener.open(alerts_url) resp_code = response.getcode() body = response.read() if resp_code != 200: raise UnexpectedResponseError(resp_code, [], body) soup = BeautifulSoup(body, convertEntities=BeautifulSoup.HTML_ENTITIES) # the alerts data is stored in window.STATE defined in one of the # <script> tags script = soup.find('script', text=re.compile(r'window\.STATE\s*=')) state_value_match = re.search(r'window\.STATE\s*=\s*(.*)', script.string) if state_value_match is None: raise ParseFailureError( "Couldn't find the definition of window.STATE in the Google Alerts page" ) state_value_string = state_value_match.group(1) state_value = JSONDecoder().raw_decode(state_value_string)[0] self.window_state = WindowState(state_value) self.account = self.window_state.accounts[self.email]
def loads(s): decoder = JSONDecoder(object_hook=_object_hook, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None) return decoder.decode(s)
def loadModelFromDisk(self, modelDiskPath): ''' ''' modelReadObj = open(modelDiskPath, 'r') modelLines = modelReadObj.readlines() modelCntDic = { 'start_p': None, 'emit_p': None, 'tag_states': None, 'trans_p': None } for line in modelLines: label, element = line[:line.find('@')], JSONDecoder().decode( line[line.find('@') + 1:]) modelCntDic[label] = element if None in modelCntDic.values(): print('model with some errors, please check!') return None modelReadObj.close() model = self.__init__(modelCntDic['start_p'], modelCntDic['emit_p'], modelCntDic['tag_states'], modelCntDic['trans_p']) return model
def _readTrackedLayerFile(self, filename): with open(filename) as f: lines = f.readlines() trackInfo = JSONDecoder(object_hook=decoder).decode("\n".join(lines)) return trackInfo
def getjobinfo(servername, joburl): conn = httplib2.HTTPConnectionWithTimeout(servername) conn.request("GET", joburl + "api/json") r1 = conn.getresponse() data1 = r1.read() json_decoder = JSONDecoder() conn.close() return json_decoder.decode(data1.decode())
def getjenkinsjobs(jenkinsserver): conn = httplib2.HTTPConnectionWithTimeout(jenkinsserver) conn.request("GET", "/jenkins/api/json") r1 = conn.getresponse() data1 = r1.read() json_decoder = JSONDecoder() conn.close() return json_decoder.decode(data1.decode())
def get_document(): """Dato un URL come *querystring*, restituisce l'html del documento corrispondente""" if request.method == 'POST': doc_url = JSONDecoder().decode(request.data)['url'] return add_document_to_fuseki(doc_url) elif request.method == 'GET': doc_url = request.args.get('url') return get_doc(doc_url)
def getJSON(xml_string): """ Will return JSON tree only from OpenAPIv3 response. params: xml_string: OpenAPIv3 response XML string. """ tree = ElementTree.fromstring(xml_string) return JSONDecoder().decode(tree.text)
def perform_destroy(self, instance): form_data = self.request.POST.get('models', None) if form_data != None: json_decoder = JSONDecoder() validate_data = json_decoder.decode(form_data) task_dependency_id = int(validate_data.get('id', 0)) else: task_dependency_id = int(self.kwargs['id']) TaskService.delete_task_dependency(int(task_dependency_id))
def parseCredentials(pwd, file="secret_credentials.json"): jsondec = JSONDecoder() text = encryption.decrypt(password=pwd) or "{}" data = jsondec.decode(text) print("Opening credential file...") return data.get("SERVER", "example.com"), data.get("PORT", "0"), data.get( "USER", "*****@*****.**"), data.get("PASSWORD", "admin")
def readFrom(cls, fileName): if os.path.exists(fileName): with open(fileName) as f: lines = f.readlines() jsonstring = "\n".join(lines) else: return if jsonstring: return JSONDecoder(object_hook=decoder).decode(jsonstring)
def modify_annotations(): annotations = JSONDecoder().decode(request.data)['items'] turtle = [] for a in annotations: turtle.append(generateGraphFromJSON(a)) turtle = ''.join(turtle) if request.method == 'PUT': return edit_graph(turtle, action='INSERT') elif request.method == 'POST': return edit_graph(turtle, action='DELETE')
def _loadScript(fn): try: fp = open(fn, 'r') except: fp.close() return s = fp.readline() s.replace('\n', '') d = JSONDecoder().decode(s) return [(e['checker'], e['command']) for e in d['commandsFlow']]
def get_object(self): form_data = self.request.POST.get('models', None) if form_data != None: json_decoder = JSONDecoder() validate_data = json_decoder.decode(form_data) task_id = int(validate_data.get('id', 0)) else: task_id = int(self.kwargs['task_id']) task = models.Task.objects.get(task_id) return task
def make_semester(courses) -> list: courses = JSONDecoder().decode(courses) ret = [] for semester in courses: sem = {} for course in semester: sem[course] = random.Random().randint(35, 100) ret.append(sem) return ret
def _decoder(self): symbol_table = self.symbol_table.table() decoder = functools.partial(self._object_decoder, symbol_table=symbol_table.__getitem__ if symbol_table else self._as_type) kwargs = { 'object_hook': decoder, 'strict': True, } if PY2: kwargs['encoding'] = 'UTF-8' return JSONDecoder(**kwargs)
def make_decoder(): json.decoder.scanstring = record_parser_name(py_scanstring) decoder = JSONDecoder() decoder.parse_object = record_parser_name(decoder.parse_object) decoder.parse_array = record_parser_name(decoder.parse_array) decoder.parse_string = record_parser_name(py_scanstring) decoder.parse_object = record_parser_name(decoder.parse_object) decoder.scan_once = py_make_scanner(decoder) return decoder
def readTrackedLayers(): try: global tracked filename = os.path.join(userFolder(), "trackedlayers") if os.path.exists(filename): with open(filename) as f: lines = f.readlines() jsonstring = "\n".join(lines) if jsonstring: tracked = JSONDecoder(object_hook=decoder).decode(jsonstring) except KeyError: pass
def testToString(self): newMapping = FileMapping() newMapping.addItem(u'c:/temp/x1.txt', u'Temp/x1.txt') newMapping.addItem(u'c:/temp/x2.txt', u'Temp/x2.txt') str = newMapping.toString() self.assert_(str <> None, 'No string returned') items = JSONDecoder().decode(str) self.assert_(items <> None, 'String could not be decoded by JSON') self.assert_(len(items) == 2, 'Nb of items mappings not OK') self.assert_(items[u'c:/temp/x1.txt'] == u'Temp/x1.txt', 'Mapping item not OK')
def readFrom(cls, filename): if os.path.exists(filename): with open(filename) as f: lines = f.readlines() jsonstring = "\n".join(lines) else: return if jsonstring: newMapping = cls() newMapping.itemMappings = JSONDecoder().decode(jsonstring) return newMapping
def post(self, request, *args, **kwargs): form_data = request.POST.get('models', None) if form_data == None: validate_data = request.data else: json_decoder = JSONDecoder() validate_data = json_decoder.decode(form_data) task = TaskService.create_task(validate_data, request.user) serializer = project_serializer.ProjectTaskSerializer(instance=task) headers = self.get_success_headers(serializer.data) return response.Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def update(self, request, *args, **kwargs): partial = kwargs.pop('partial', False) form_data = request.POST.get('models', None) if form_data == None: validate_data = request.POST or request.data else: json_decoder = JSONDecoder() validate_data = json_decoder.decode(form_data) task = self.get_object() print(validate_data) TaskService.edit_task(task, validate_data, request.user) serializer = project_serializer.ProjectTaskSerializer(instance=task) return response.Response(serializer.data)