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)
