def get_disks(self):
''' Get disks info data '''
try:
disk_partitions = psutil.disk_partitions()
# print str(disk_partitions)
# print json.dumps(disk_partitions,default=lambda obj: obj.__dic__)
print json.dumps(disk_partitions)
temp_str = json.dumps(disk_partitions)
temp_obj = json.loads(temp_str)
print str(temp_obj)
self.__save_data_to_json(temp_str)
pass
except Exception as e:
self.__logger.exception(e)
pass
def dump_for_hb_a(infile):
dpl = DumpPresentationLayer(infile)
dpl.get_mean_emotions_values()
dpl.get_emotion_types_values()
dpl.get_mean_emotion_types_values()
average_tweet = dpl.get_average_tweet_for_group(dpl.emotions_values,
dpl.df, "worry")
average_covid_tweet = dpl.get_average_tweet_for_group(
dpl.emotions_values, dpl.df_covid_related_terms, "worry")
data = pd.concat([
dpl.emotion_types_values_covid_related_terms, dpl.emotion_types_values
],
axis=1).to_dict(orient="index")
data_series = []
for key, value in data.items():
data_series.append({
"name": key,
"x": [v / 100 for v in value.values()]
})
with open("../data/pl-hb-a.json", "w") as outfile:
data = json.dumps({
"y": [
"An Average COVID-19 Tweet",
"An Average Tweet",
],
"commments": [f'"{average_covid_tweet}"', f'"{average_tweet}"'],
"data_series":
data_series,
})
outfile.write(data)
def test_plus_encode(self):
# specify separators manually, because JSONEncoder already receives
# separators set from simplejson.dumps() to a different default
# than we use in jsonplus.dumps()
self.assertEqual(
simplejson.dumps(self.plus, sort_keys=True, separators=(',', ':'), cls=json.JSONEncoder),
json.dumps(self.plus, sort_keys=True))
def test_inf_representation(self):
a = json.dumps(float("inf"))
# TODO: we want this:
#b = '{"__class__":"float","__value__":"inf"}'
# unfortunately, with current version of simplejson, all we can get is:
b = 'Infinity'
self.assertEqual(b, a)
def test_django_money(self):
m = Money(313, 'USD')
dm = DjangoMoney(313, 'USD')
obj = jsonplus.loads(jsonplus.dumps(dm))
self.assertEqual(obj, dm)
self.assertTrue(hasattr(obj, 'is_localized'))
self.assertTrue(hasattr(dm, 'is_localized'))
self.assertFalse(hasattr(m, 'is_localized'))
def test_user_encoder_compat(self):
@json.encoder('mytype', exact=False)
def mytype_encoder(obj):
return obj.y
class mytype(object):
y = 313
self.assertEqual(json.dumps(mytype(), sort_keys=True, exact=False),
'313')
def test_user_encoder_exact(self):
class mytype1(object):
x = 313
@jsonplus.encoder('mytype1', exact=True)
def mytype_encoder(obj):
return obj.x
self.assertEqual(jsonplus.dumps(mytype1(), sort_keys=True, exact=True),
'{"__class__":"mytype1","__value__":313}')
def test_user_encoder_compat(self):
class mytype1(object):
x = 313
@jsonplus.encoder('mytype1', exact=False)
def mytype_encoder(obj):
return obj.x
self.assertEqual(
jsonplus.dumps(mytype1(), sort_keys=True, exact=False), '313')
def record(self, tick:int, event: GameEvent):
self.file.write(f"{tick}: ")
if isinstance(event, GameSysAction):
self.file.write(f"{event.action.value} ")
self.file.write(jsonplus.dumps(event.payload))
elif isinstance(event, PlayerMove):
self.file.write(f"{event.pid} {event.action.value}")
self.file.write("\n")
self.file.flush()
def list_accounts_from_parent(
): # creates a new file with accouts info. origin: aws
with open('accounts_from_parent.txt', 'w'):
pass # makes the file empty for each run
account = boto3.session.Session(
profile_name='default',
region_name='eu-west-1') # Session = Default (Organization access)
client = account.client('organizations')
with open('parentids.txt',
'r') as parents: # OU file to get accounts from
for id in parents:
id = id.strip("\n")
# weak part- hardcoded. each row represents a request that is limited to 20 accounts. overall supports 100 accounts:
response = client.list_accounts_for_parent(ParentId=id)
response1 = client.list_accounts_for_parent(
ParentId=id, NextToken=response['NextToken'])
response2 = client.list_accounts_for_parent(
ParentId=id, NextToken=response1['NextToken'])
response3 = client.list_accounts_for_parent(
ParentId=id, NextToken=response2['NextToken'])
response4 = client.list_accounts_for_parent(
ParentId=id, NextToken=response3['NextToken'])
for res in [
response, response1, response2, response3, response4
]:
accounts = res['Accounts']
dict_len = len(accounts)
y = jplus.dumps(accounts, indent=4)
j = jplus.loads(y)
counter = 0
while counter < dict_len:
name = j[counter]['Name']
email = j[counter]['Email']
id = j[counter]['Id']
with open(
'accounts_from_parent.txt', mode='a'
) as file: # Appends name,email,id to the empty file
writer = csv.writer(file, delimiter=',')
writer.writerow([id, name, email])
counter += 1
def test_encoder_predicate_over_classname(self):
class mycls(object):
uniq = 313
@jsonplus.encoder('mycls')
def mycls_encoder_1(obj):
return None
@jsonplus.encoder('mycls', lambda obj: hasattr(obj, 'uniq'))
def mycls_encoder_2(obj):
return obj.uniq
# classname-based encoder is tested after the predicate-based one
a = mycls()
b = json.loads(jsonplus.dumps(a, exact=True))
self.assertEqual(b['__class__'], type(a).__name__)
self.assertEqual(b['__value__'], a.uniq)
def test_encoder_priority(self):
class mycls(object):
pass
@jsonplus.encoder('mycls', lambda obj: isinstance(obj, mycls))
def _enc1(obj):
return 'invalid-priority-1000'
@jsonplus.encoder('mycls',
lambda obj: isinstance(obj, mycls),
priority=500)
def _enc2(obj):
return 'valid'
r = json.loads(jsonplus.dumps(mycls(), exact=True))
self.assertEqual(r['__class__'], 'mycls')
self.assertEqual(r['__value__'], 'valid')
def dump_for_ts_b(infile):
dpl = DumpPresentationLayer(infile)
dpl.normalise_datetimes()
dpl.groupby_date()
dpl.make_column_rolling(column="worry")
with open("../data/pl-ts-a.json", "w") as outfile:
data = json.dumps({
"dates":
dpl.emotions_values_by_date["date"].tolist(),
"data_series": [{
"name":
"worry",
"y":
dpl.emotions_values_by_date["worry"].apply(
lambda v: v / 100).tolist(),
}],
})
outfile.write(data)
def test_encoder_predicates(self):
class mycls1(object):
snowflake = 313
class mycls2(object):
bulldozer = 131
@jsonplus.encoder('mycls1', lambda obj: hasattr(obj, 'snowflake'))
def mycls1_encoder(obj):
return obj.snowflake
@jsonplus.encoder('mycls2', lambda obj: hasattr(obj, 'bulldozer'))
def mycls2_encoder(obj):
return obj.bulldozer
a = [mycls2(), mycls1()]
b = json.loads(jsonplus.dumps(a, exact=True))
self.assertEqual(b[0]['__value__'], a[0].bulldozer)
self.assertEqual(b[1]['__value__'], a[1].snowflake)
def doc_generator(df):
for batchRecord in batch(df, 499):
df_iter = batchRecord.iterrows()
for index, document in df_iter:
recordset = []
recordset.append({
'Data':
bytes(
json.dumps({
'gender': document['gender'],
'emp_no': document['emp_no'],
'birth_date': document['birth_date'],
'last_name': document['last_name'],
'hire_date': document['hire_date'],
'first_name': document['first_name']
}))
})
response = client.put_record_batch(
DeliveryStreamName=
'glueKinesisEsDemo-ElasticSearchDeliveryStream-KDNUH7D8KJZG',
Records=recordset)
print(response)
def test_basic_dumps(self):
self.assertEqual(json.dumps(self.basic, sort_keys=True), self.basic_dumps)
def dump_and_load(self, val, **kwargs):
return json.loads(json.dumps(val, **kwargs))
def _main():
logger = logging.getLogger()
arguments = docopt(__doc__, version=__version__)
json.prefer_compat()
if arguments["--debug"]:
logger.setLevel(logging.DEBUG)
logging.debug(arguments)
api = WhoisXMLAPI()
results = ""
search_type = "current"
mode = "preview"
if arguments["--historic"]:
search_type = "historic"
if arguments["--purchase"]:
mode = "purchase"
if arguments["bulk"]:
with open(arguments["<input_file>"]) as input_file:
domains = list(
map(lambda line: line.rstrip(), input_file.readlines()))
results = api.bulk_whois(domains)
if arguments["--csv"]:
results = results["csv"]
else:
results = results["structured"]
results = dict(results=results)
elif arguments["reverse"]:
results = api.reverse_whois(arguments["<term>"],
exclude_terms=arguments["<exclude_term>"],
search_type=search_type,
mode=mode)
if arguments["--purchase"]:
results = results["domainsList"]
elif arguments["history"]:
results = api.whois_history(arguments["<domain>"],
since_date=arguments["--since"],
mode=mode)
if arguments["--purchase"]:
results = dict(results=results)
elif arguments["brand"]:
results = api.brand_alert(arguments["<term>"],
exclude_terms=arguments["<exclude_term>"],
since_date=arguments["--since"],
mode=mode)
if arguments["--purchase"]:
if arguments["--csv"]:
results = _to_csv(results, "alert")
else:
results = dict(results=results)
elif arguments["registrant"]:
results = api.registrant_alert(
arguments["<term>"],
exclude_terms=arguments["<exclude_term>"],
since_date=arguments["--since"],
mode=mode)
if arguments["--purchase"]:
if arguments["--csv"]:
results = _to_csv(results, "alert")
else:
results = dict(results=results)
elif arguments["reverse-ip"]:
results = api.reverse_ip(arguments["<ip>"])
if arguments["--csv"]:
results = _to_csv(results, "reverse")
else:
results = dict(results=results)
elif arguments["reverse-mx"]:
results = api.reverse_mx(arguments["<mx>"])
if arguments["--csv"]:
results = _to_csv(results, "reverse")
else:
results = dict(results=results)
elif arguments["reverse-ns"]:
results = api.reverse_ns(arguments["<ns>"])
if arguments["--csv"]:
results = _to_csv(results, "reverse")
else:
results = dict(results=results)
elif arguments["balances"]:
results = api.get_account_balances()
else:
# The default action is a WHOIS lookup
thin_whois = True
if arguments["--verbose"]:
thin_whois = False
results = api.whois(arguments["<domain>"], thin_whois=thin_whois)
# Format output
if type(results) is dict:
results = json.dumps(results, indent=2, ensure_ascii=False)
elif type(results) is list:
results = "\n".join(results)
if arguments["--output"]:
filename = arguments["--output"]
if type(arguments["--output"]) == list:
filename = arguments["--output"][0]
with open(filename,
"w",
encoding="utf-8",
errors="ignore",
newline="\n") as output_file:
output_file.write(results)
else:
print(results)
def _put_encoded(self, key: str, value: object):
encoded_value = jsonplus.dumps(value).encode('utf-8')
super().put(key, encoded_value)
def _after_execute(self, conn, clause, multiparams, params, result):
logger = self.loggers.get(current_thread().ident)
if not logger:
return
try:
start_time = clause.start_time
except AttributeError:
start_time = self.tmp.pop(id(clause))
stop_time = time()
duration = (stop_time - start_time) * 1000
config = dt_settings.get_config()
try:
raw_compiled = clause.compile(dialect=self.engine.dialect,
compile_kwargs={})
except AttributeError:
try:
parameters = _distill_params(multiparams, params)
except InvalidRequestError:
parameters = []
raw_sql = " ".join(six.text_type(clause).splitlines())
else:
try:
ctx = CursorlessExecutionContext._init_compiled(
self.engine.dialect,
conn,
conn._Connection__connection,
raw_compiled,
_distill_params(multiparams, params),
)
except Exception:
parameters = []
raw_sql = " ".join(six.text_type(clause).splitlines())
else:
parameters = ctx.parameters
raw_sql = " ".join(ctx.statement.splitlines())
try:
sql = " ".join(
six.text_type(
clause.compile(dialect=self.engine.dialect,
compile_kwargs={"literal_binds":
True})).splitlines())
except (CompileError, TypeError, NotImplementedError, AttributeError):
# not all queries support literal_binds
sql = raw_sql
if config["ENABLE_STACKTRACES"]:
stacktrace = tidy_stacktrace(reversed(get_stack()))
else:
stacktrace = []
template_info = get_template_info()
params = {
"vendor":
conn.dialect.name,
"alias":
self.alias,
"sql":
sql,
"duration":
duration,
"raw_sql":
raw_sql,
"params":
json.dumps([
list(i) if isinstance(i, (list, tuple)) else i
for i in parameters if i
]),
'raw_params':
tuple(
tuple(i.items() if isinstance(i, dict) else i)
for i in parameters),
"stacktrace":
stacktrace,
"start_time":
start_time,
"stop_time":
stop_time,
"is_slow":
duration > config["SQL_WARNING_THRESHOLD"],
"is_select":
sql.lower().strip().startswith("select"),
"template_info":
template_info,
}
logger.record(**params)
return params
f.close()
with open("d:/hello.txt", 'r') as f:
string3 = f.read()
print(string3)
with open("d:/hello.txt", 'a') as f:
flag = f.writable()
string3 = f.write("\n刘颖慧，你好！！")
print(string3)
print(flag)
#os.mkdir('d:/liuyinghui')
#os.rmdir('d:/liuyinghui')
print(os.name, os.environ['OS'])
jsonDict = dict(name='liuyinghui', age=35, datetime=datetime.datetime.today())
jsonstr = json.dumps(jsonDict)
print(jsonstr)
print(jsonDict)
jsonDict2 = json.loads(jsonstr)
print(jsonDict2)
print(json.dumps(std.__dict__))
print(type(std))
def jsonHanle(d):
return St(d['name'], d['score'])
std1 = json.loads(json.dumps(std.__dict__), object_hook=jsonHanle)
print(std1)
print(type(std1))
def send(writer, data):
serialized_data = jsonplus.dumps(data).encode()
writer.write(struct.pack('>I', len(serialized_data)))
writer.write(serialized_data)
def dumps(*pa, **kw):
return jsonplus.dumps(*pa, **kw)
for record in hash_index:
if property['hash'] in hash_index[record]:
config_list = re.findall('[0-9]{1,3}.config', record)
if len(config_list) > 1:
raise SystemError(
"More than one configuration detected in path {}".format(
record))
property['configurations'].add(
re.findall('[0-9]{1,3}.config', record)[0])
count = count + 1
property['configurations'] = list(property['configurations'])
property['configurations'].sort()
property['num_occurrences'] = len(property['configurations'])
logging.info('Report ' + property['hash'] + ' was present in ' +
str(len(property['configurations'])) + ' configurations.')
# Also add the description list to the property
property['matching_description'] = description_index[property['hash']]
# Add empty investigation results field
property['investigation'] = {'result': None, 'comments': ''}
print(str(len(master)) + ' unique bugs found.')
# Write output to file
with open(args.output, 'w') as out:
content = json.dumps(master, out)
out.write(content)
print('Output written to ' + args.output)
def get_prep_value(self, value):
if value is None:
return value
return jsonplus.dumps(value)
def test_basic_loads_dumps(self):
basic = json.loads(self.basic_dumps)
self.assertEqual(json.dumps(basic, sort_keys=True), self.basic_dumps)
def test_plus_dumps(self):
self.assertEqual(json.dumps(self.plus, sort_keys=True), self.plus_dumps)
def save(self):
self._prepare_storage()
with open('%s/data.json' % self.path, 'w') as f:
f.write(json.dumps(self.data))
def test_inf_representation(self):
a = json.dumps(float("inf"))
b = 'null'
self.assertEqual(b, a)
