def file_list(request, date=None):
template_name = 'index.html'
context = {
'files': [],
'date': date
}
# Реализуйте алгоритм подготавливающий контекстные данные для шаблона по примеру:
files_list = os.listdir(FILES_PATH)
for file in files_list:
file_path = os.path.join(FILES_PATH, file)
file_metadata = os.stat(file_path)
# print(f'ТУТ!!!!!! : {file_metadata}')
time_create_file = datetime.fromtimestamp(file_metadata.st_ctime)
time_change_file = datetime.fromtimestamp(file_metadata.st_mtime)
file_info = {
'name': file,
'ctime': time_create_file,
'mtime': time_change_file
}
if date:
if file_info['ctime'].date() == datetime.strptime(date, '%Y-%m-%d').date():
context['files'].append(file_info)
else:
context['files'].append(file_info)
return render(request, template_name, context)
def filter_data(data, min_item_support, min_session_length):
#y?
session_lengths = data.groupby('SessionId').size()
data = data[np.in1d(data.SessionId,
session_lengths[session_lengths > 1].index)]
#filter item support
item_supports = data.groupby('ItemId').size()
data = data[np.in1d(
data.ItemId, item_supports[item_supports >= min_item_support].index)]
#filter session length
session_lengths = data.groupby('SessionId').size()
data = data[np.in1d(
data.SessionId,
session_lengths[session_lengths >= min_session_length].index)]
#output
data_start = datetime.fromtimestamp(data.Time.min(), timezone.utc)
data_end = datetime.fromtimestamp(data.Time.max(), timezone.utc)
print(
'Filtered data set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}\n\n'
.format(len(data), data.SessionId.nunique(), data.ItemId.nunique(),
data_start.date().isoformat(),
data_end.date().isoformat()))
return data
def compare(ds1_path, ds2_path):
"""
Function that compares content of two pickled
:param ds1_path: path string
:param ds2_path: path string
:return: void
"""
ds1_path = str(ds1_path).lower()
ds2_path = str(ds2_path).lower()
# File where the comparision result will be stored
logfile_name = 'diff' + datetime.now().strftime('%Y%m%d%H%M%S') + '.csv'
log = open(logfile_name, 'w')
log.write("TYPE; SNAPSHOT1; SNAPSHOT2; CONTEXT\n")
ds1 = pickle.load(open(ds1_path, 'rb'))
ds2 = pickle.load(open(ds2_path, 'rb'))
# Loop over directory state stored in the first path
for subdir, content in ds1.items():
if subdir in ds2:
for f, f_det in content['file_details'].items():
if f in ds2[subdir]['file_details']:
ds1_time = datetime.fromtimestamp(
ds1[subdir]['file_details'][f][0]).isoformat()
ds2_time = datetime.fromtimestamp(
ds2[subdir]['file_details'][f][0]).isoformat()
# Check if modification date changed
if ds1_time != ds2_time:
log.write("DATE MODIFIED;" + str(ds1_time) + ";" +
str(ds2_time) + ";" +
str(os.path.join(subdir, f)) + "\n")
else:
log.write("MISSING FILE;exists;missing;" +
os.path.join(subdir, f) + "\n")
else:
log.write("MISSING FOLDER;exists;missing;" + subdir + "\n")
# Loop over directory state stored in the second path and check for missing/existing files
for subdir, content in ds2.items():
if subdir in ds1:
for f, f_det in content['file_details'].items():
if f not in ds1[subdir]['file_details']:
log.write("MISSING FILE;missing;exists;" +
os.path.join(subdir, f) + "\n")
else:
log.write("MISSING FOLDER;missing;exists;" + subdir + "\n")
print("Differences stored in: " + logfile_name)
def split_data_retrain_train(data, output_file, days_train, days_test,
retrain_num):
data_start = datetime.fromtimestamp(data.Time.min(), timezone.utc)
train_from = data_start
new_days = retrain_num * days_test
train_to = data_start + timedelta(days=days_train) + timedelta(
days=new_days)
# todo: test_from
# test_to = train_to + timedelta(days=days_test)
session_min_times = data.groupby('SessionId').Time.min()
session_max_times = data.groupby('SessionId').Time.max()
session_train = session_max_times[
(session_min_times >= train_from.timestamp())
& (session_max_times <= train_to.timestamp())].index
train = data[np.in1d(data.SessionId, session_train)]
trlength = train.groupby('SessionId').size()
train = train[np.in1d(train.SessionId, trlength[trlength >= 2].index)]
# print('Full train set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}'.format(len(train), train.SessionId.nunique(),
# train.ItemId.nunique()))
print(
'Full train set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}\n\n'
.format(len(train), train.SessionId.nunique(), train.ItemId.nunique(),
train_from.date().isoformat(),
train_to.date().isoformat()))
train.to_csv(output_file + '_train_full.' + str(retrain_num) + '.txt',
sep='\t',
index=False)
data_end = datetime.fromtimestamp(train.Time.max(), timezone.utc)
valid_from = data_end - timedelta(days=days_test)
session_max_times = train.groupby('SessionId').Time.max()
session_train = session_max_times[
session_max_times < valid_from.timestamp()].index
session_valid = session_max_times[
session_max_times >= valid_from.timestamp()].index
train_tr = train[np.in1d(train.SessionId, session_train)]
valid = train[np.in1d(train.SessionId, session_valid)]
valid = valid[np.in1d(valid.ItemId, train_tr.ItemId)]
tslength = valid.groupby('SessionId').size()
valid = valid[np.in1d(valid.SessionId, tslength[tslength >= 2].index)]
print('Train set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}'.format(
len(train_tr), train_tr.SessionId.nunique(),
train_tr.ItemId.nunique()))
train_tr.to_csv(output_file + '_train_tr.' + str(retrain_num) + '.txt',
sep='\t',
index=False)
print('Validation set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}'.format(
len(valid), valid.SessionId.nunique(), valid.ItemId.nunique()))
valid.to_csv(output_file + '_train_valid.' + str(retrain_num) + '.txt',
sep='\t',
index=False)
return train
def photo_shooting_date(self, file):
photo = Image.open(file)
info = photo._getexif()
try:
if 36867 in info:
date = info[36867]
date = datetime.strptime(date, '%Y:%m:%d %H:%M:%S')
else:
date = datetime.fromtimestamp(os.path.getmtime(file))
except:
date = datetime.fromtimestamp(os.path.getmtime(file))
return date
def store_data(my_data):
try:
file_name = 'DATA/DataGatherer_' + str(
datetime.fromtimestamp(time()).strftime('%Y%m%d_%H') + '.csv')
file = open(file_name, 'a')
file.write(my_data)
file.write('\n')
file.close()
except BaseException as e:
print('store_data: ' + str(e) + ' TIME: ' +
str(datetime.fromtimestamp(time()).strftime('%Y%m%d_%H%M')))
sleep(5)
pass
def load_data_prepared(file, version):
data = pd.read_csv(file + '.csv', sep='\t')
#output
data_start = datetime.fromtimestamp(data.Time.min(), timezone.utc)
data_end = datetime.fromtimestamp(data.Time.max(), timezone.utc)
print(
'Loaded data set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}\n\n'
.format(len(data), data.SessionId.nunique(), data.ItemId.nunique(),
data_start.date().isoformat(),
data_end.date().isoformat()))
return data
def __init__(self, parent = None):
'''
Constructor
'''
super(VoivoiShow, self).__init__(parent)
#self.setStyleSheet("background: #000;")
self.splashscreen = QImage("res/splashscreen.jpg")
#print(self.splashscreen.isNull())
if not self.splashscreen.isNull():
self.imgList.append(self.splashscreen)
self.imageLabel = QLabel()
self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.imageLabel.setParent(self)
self.httpPool = urllib3.PoolManager()
self.slideIterator = 0
self.timer.timeout.connect(self.nextImage)
self.updateTimer = QTimer()
self.updateTimer.timeout.connect(self.updateImages)
self.mostRecent = datetime.fromtimestamp(0)
self.layout = QHBoxLayout()
self.layout.setMargin(0)
self.layout.addWidget(self.imageLabel)
self.layout.setAlignment(self.imageLabel, Qt.AlignHCenter)
self.setLayout(self.layout)
self.voivoifont = QFont("Helvetica", 48)
self.voivoifont.setBold(True)
def on_data(self, data):
try:
all_data = json.loads(data)
t_date = all_data['created_at']
t_date = datetime.strptime(
t_date, "%a %b %d %H:%M:%S %z %Y") # change to datetime format
t_id = all_data['id']
t_followers = all_data['user']['followers_count']
if 'extended_tweet' in all_data:
t_text = all_data['extended_tweet']['full_text']
else:
t_text = all_data['text']
t_text = t_text.replace(
"'", "") # Gives an error when writing to the db
t_text = t_text.replace(";", "") # Is used as delimiter
t_text = t_text.encode(
"utf-8") # Should get rid of unknown characters
t_user = all_data["user"]['id']
# hashtags = all_data['entities']['hashtags']
my_data = str(t_date) + ";" + str(t_id) + ";" + str(
t_followers) + ";" + str(t_text) + ";" + str(t_user)
store_data(my_data)
return True
except BaseException as e:
print('failed ondata: ' + str(e) + ' TIME: ' +
str(datetime.fromtimestamp(time()).strftime('%Y%m%d_%H%M')))
sleep(5)
pass
def patch(self, user_id):
"""
TODO: cascading update to soccerInfo for user_id change
Updates fields of the User
:param user_id: user id
:return: message dict
"""
data = request.get_json()
try:
user = User.objects(user_id__exact=user_id)
if 'user_id' in data:
user.update(set__user_id=data['user_id'])
if 'first_name' in data:
user.update(set__first_name=data['first_name'])
if 'last_name' in data:
user.update(set__last_name=data['last_name'])
if 'email' in data:
user.update(set__email=data['email'])
if 'password' in data:
user.update(set__password=data['password'])
if 'last_login' in data:
date = datetime.fromtimestamp(data['last_login']['$date'] / 1e3)
user.update(set__last_login=date)
return {"message": "successfully patched!"}, 201
except Exception as err:
return {"message": "Failed to patch: {0}".format(err)}, 405
def mediawiki_time(epoch):
date = datetime.fromtimestamp(epoch)
year = str(date.year)
if date.month < 10:
month = '0' + str(date.month)
else:
month = str(date.month)
if date.day < 10:
day = '0' + str(date.day)
else:
day = str(date.day)
if date.hour < 10:
hour = '0' + str(date.hour)
else:
hour = str(date.hour)
if date.minute < 10:
minute = '0' + str(date.minute)
else:
minute = str(date.minute)
if date.second < 10:
second = '0' + str(date.second)
else:
second = str(date.second)
return year + month + day + hour + minute + second
def print_message(self, message):
text = message['text']
nick = message['username']
timestamp = float(message['time'])
ct = datetime.fromtimestamp(timestamp).strftime('%H:%M:%S')
self.show_text(f'{ct} {nick}\n{text}\n\n')
def dir_l(path):
for f in os.listdir(path):
abspath=os.path.join(path,f) #定位文件 绝对路径
fsize = os.path.getsize(abspath)
mtime = datetime.fromtimestamp(os.path.getmtime(abspath)).strftime('%Y-%m-%d %H:%M:%S') #时间格式化
flag = '/' if os.path.isdir(abspath) else ''
print("%10d %s %s%s" % (fsize,mtime,f,flag)) #格式化输出
def __initializeFileBrowser(self, decryption, encryptedDir, parent=''):
for entry in os.listdir(encryptedDir):
# Check if file is segmented
filename, segment = FilenameUtils.splitSegmentedFileName(entry)
if segment is not None and segment is not 0:
continue
encryptedFullPathForEntry = os.path.join(encryptedDir, entry)
decryptedName = decryption.decryptFileName(filename)
identifier = None
printableModificationDate = datetime.fromtimestamp(os.path.getmtime(encryptedFullPathForEntry)).strftime('%Y-%m-%d %H:%M:%S')
fileSize = None
if os.path.isfile(encryptedFullPathForEntry):
encryptedVirtualFile = None
if segment is not None:
encryptedVirtualFile = SegmentedVirtualFile(os.path.join(encryptedDir, filename))
else:
encryptedVirtualFile = VirtualFile(encryptedFullPathForEntry)
fileSize = decryption.decryptedFileSize(encryptedVirtualFile)
encryptedVirtualFile.closeFileHandle()
identifier = self.fileBrowser.insert(parent, 'end', text=decryptedName)
else:
identifier = self.fileBrowser.insert(parent, 'end', text=decryptedName)
self.__initializeFileBrowser(decryption, encryptedFullPathForEntry, identifier)
fileSize = os.path.getsize(encryptedFullPathForEntry)
self.fileBrowser.set(identifier, 'size', hurry.filesize.size(fileSize))
self.fileBrowser.set(identifier, 'modified', printableModificationDate)
self.fileBrowser.set(identifier, 'encrypted name', entry)
self.fileBrowserShadowInformation[identifier] = encryptedFullPathForEntry
def main():
key = os.environ.get('WEATHER_KEY')
city, country_code = getInput()
query = {
'q': city + "," + country_code,
'units': 'imperial',
'appid': '9db10307657b0ff8224b0da642ac57f7'
}
url = 'http://api.openweathermap.org/data/2.5/forecast'
try:
data = requests.get(url, params=query).json()
forecast_items = data['list']
for forecast in forecast_items:
timestamp = forecast['dt']
date = datetime.fromtimestamp(timestamp)
# I choose to convert the timestamp in to a datetime
# to get a local Minneapolis time, my program is currently built
# to be used in this area for educational purposed and not deployed to others around the world yet
temp = forecast['main']['temp']
description = forecast['weather'][0]['description']
wind_speed = forecast['wind']['speed']
city = city.capitalize()
print(
f'At {date} in {city} the temp is {temp:.2f}F. \n and {description} with a wind speed of {wind_speed:.1f}mph'
)
except:
print("Please enter a valid city/country code")
main()
def get_address(bk=770000):
url = f'https://cpchain.io/explorer/impeachs_by_block/{bk}/0'
r = requests.get(url)
bks = json.loads(r.text).get('impeach_bks')
li = []
addr = {}
for i in range(len(bks)):
time = datetime.fromtimestamp(
bks[i]["timestamp"]).strftime("%Y-%m-%d %H:%M:%S")
impeach_item = {
"address": bks[i]['impeachProposer'],
'number': bks[i]['number'],
'time': time
}
if impeach_item['address'] not in addr:
addr[impeach_item['address']] = 1
else:
addr[impeach_item['address']] += 1
li.append(impeach_item)
li.reverse()
pprint(li)
print("*" * 100)
pprint(sorted(addr.items(), key=lambda x: x[1], reverse=True))
print('total impeach number: ', len(li))
def load_data(path, file_name):
'''
Desc: Loads a tuple of training and test set with the given parameters.
--------
Input:
path : Path of preprocessed data (str)
file : Name of dataset
--------
Output : tuple of DataFrame (train, test)
'''
print('START load data')
st = time.time()
sc = time.perf_counter()
train_appendix = '_train'
test_appendix = '_test'
train = pd.read_csv(path + file_name + train_appendix + '.txt',
sep='\t',
dtype={'ItemId': np.int64})
test = pd.read_csv(path + file_name + test_appendix + '.txt',
sep='\t',
dtype={'ItemId': np.int64})
data_start = datetime.fromtimestamp(train.Time.min(), timezone.utc)
data_end = datetime.fromtimestamp(train.Time.max(), timezone.utc)
print(
'train set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}\n'
.format(len(train), train.SessionId.nunique(), train.ItemId.nunique(),
data_start.date().isoformat(),
data_end.date().isoformat()))
data_start = datetime.fromtimestamp(test.Time.min(), timezone.utc)
data_end = datetime.fromtimestamp(test.Time.max(), timezone.utc)
print(
'test set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}\n'
.format(len(test), test.SessionId.nunique(), test.ItemId.nunique(),
data_start.date().isoformat(),
data_end.date().isoformat()))
print('END load data ', (time.perf_counter() - sc), 'c / ',
(time.time() - st), 's')
return (train, test)
def download(start=0, end=100000, max_results=10, wait=10, done=None):
no_results = 0
base_url = 'http://export.arxiv.org/api/query?'
categories = ['cat:cs.CV', 'cat:cs.AI', 'cat:cs.LG', 'cat:cs.CL', 'cat:cs.NE', 'cat:stat.ML']
params = {'search_query': '+OR+'.join(categories),
'sortBy' : 'lastUpdatedDate',
'max_results' : max_results}
articles = pd.DataFrame()
for s in range(start, end, max_results):
print(s, end=' ', flush=True)
params.update({'start': s})
param_str = "&".join(f'{k}={v}' for k, v in params.items())
response = requests.get(url=base_url, params=param_str)
parsed = feedparser.parse(response.text)
if len(parsed.entries) == 0:
print('\nReceived no results from arxiv.')
no_results += 1
if no_results < 5:
sleep(60)
else:
save_articles(articles)
break
for entry in parsed.entries:
entry = encode_feedparser_dict(entry)
id = entry['id'].split('/')[-1]
if id in done:
continue
r = dict(
summary=' '.join([t.strip() for t in entry['summary'].replace('\n', ' ').split()]),
tags=','.join([t['term'] for t in entry['tags']]),
category=entry['arxiv_primary_category']['term'],
affiliation=entry.get('arxiv_affiliation'),
pdf_url=entry['link'],
author=entry['author'],
updated=datetime.fromtimestamp(mktime(entry['updated_parsed'])),
published=datetime.fromtimestamp(mktime(entry['published_parsed'])),
title=entry['title'].replace('\n', ' ')
)
articles[id] = pd.Series(r)
sleep(wait + random.uniform(0, 3))
print(articles.T.info(null_counts=True))
save_articles(articles)
def convert_from_timestamp(data):
print("===================================")
print(data)
for pin in data['pin_data']:
print(pin)
t = str(pin['time'])[0:10]
print(t)
pin['time'] = datetime.fromtimestamp(int(t)) #remove milliseconds
def do_dir():
pwd = os.path.abspath(".")
for f in os.listdir(pwd):
fsize = os.path.getsize(f)
mtime = datetime.fromtimestamp(
os.path.getmtime(f)).strftime("%Y.%m.%d %H:%M")
flag = "/" if os.path.isdir(f) else " "
print("%30s %10s %20s %10s" % (f, fsize, mtime, flag))
def get_photo(user_id, access_token, invert=False):
log(user_id)
params_prof_photo = {
'user_id': user_id,
'album_id': 'profile',
'rev': '1',
'access_token': access_token,
'v': '5.120',
'Pragma-directive': 'no-cache',
'ache-directive': 'no-cache',
'Cache-control': 'no-cache',
'Pragma': 'no-cache',
'Expires': 0
}
prof_photo_response = requests.get(
'https://api.vk.com/method/photos.get', params=params_prof_photo)
photo_info = prof_photo_response.json()
log(photo_info)
photo = photo_info['response']['items'][0]
urls = photo['sizes'][-1]
log('url:' + urls['url'])
date = str(datetime.fromtimestamp(photo['date']))
log('date:' + date)
picture = requests.get(urls['url'], stream=True).raw
image = np.asarray(bytearray(picture.read()), dtype="uint8")
image = cv2.imdecode(image, cv2.IMREAD_COLOR)
x0 = 100
x2 = x0 + len(date) * 20
x1 = x2 // 2
y = 50
color1 = image[x0, y - 30]
color2 = image[x1, y - 15]
color3 = image[x2, y]
background = list()
background.append(int(color1[0]) + int(color1[1]) + int(color1[2]))
background.append(int(color2[0]) + int(color2[1]) + int(color2[2]))
background.append(int(color3[0]) + int(color3[1]) + int(color3[2]))
background.sort()
if background[1] < 155:
color_text = (255, 255, 255)
else:
color_text = (0, 0, 0)
text = str("Creation date: " + date)
cv2.putText(image,
text, (x0, y),
cv2.FONT_HERSHEY_COMPLEX,
1,
color=color_text,
thickness=2)
# put the text about creation date
if invert:
image = cv2.bitwise_not(image)
return cv2.imencode('.JPEG', image)[1].tobytes()
else:
cv2.imwrite(f'{user_id}.jpg',
image) # write photo with text in file
return color_text # return color for text
def filter_min_date( data, min_date='2014-04-01' ) :
min_datetime = datetime.strptime(min_date + ' 00:00:00', '%Y-%m-%d %H:%M:%S')
#filter
session_max_times = data.groupby('SessionId').Time.max()
session_keep = session_max_times[ session_max_times > min_datetime.timestamp() ].index
data = data[ np.in1d(data.SessionId, session_keep) ]
#output
data_start = datetime.fromtimestamp( data.Time.min(), timezone.utc )
data_end = datetime.fromtimestamp( data.Time.max(), timezone.utc )
print('Filtered data set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}\n\n'.
format( len(data), data.SessionId.nunique(), data.ItemId.nunique(), data_start.date().isoformat(), data_end.date().isoformat() ) )
return data;
def load_data(file):
#load csv
data = pd.read_csv(file + '.csv', sep=';', header=None)
data.columns = ['SessionId', 'ItemId', 'Time']
data.Time = data.Time / 1000
#output
data_start = datetime.fromtimestamp(data.Time.min(), timezone.utc)
data_end = datetime.fromtimestamp(data.Time.max(), timezone.utc)
print(
'Loaded data set\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}\n\n'
.format(len(data), data.SessionId.nunique(), data.ItemId.nunique(),
data_start.date().isoformat(),
data_end.date().isoformat()))
return data
def split_data_slice( data, output_file, slice_id, days_offset, days_train, days_test ) :
data_start = datetime.fromtimestamp( data.Time.min(), timezone.utc )
data_end = datetime.fromtimestamp( data.Time.max(), timezone.utc )
print('Full data set {}\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}'.
format( slice_id, len(data), data.SessionId.nunique(), data.ItemId.nunique(), data_start.isoformat(), data_end.isoformat() ) )
start = datetime.fromtimestamp( data.Time.min(), timezone.utc ) + timedelta( days_offset )
middle = start + timedelta( days_train )
end = middle + timedelta( days_test )
#prefilter the timespan
session_max_times = data.groupby('SessionId').Time.max()
greater_start = session_max_times[session_max_times >= start.timestamp()].index
lower_end = session_max_times[session_max_times <= end.timestamp()].index
data_filtered = data[np.in1d(data.SessionId, greater_start.intersection( lower_end ))]
print('Slice data set {}\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {} / {}'.
format( slice_id, len(data_filtered), data_filtered.SessionId.nunique(), data_filtered.ItemId.nunique(), start.date().isoformat(), middle.date().isoformat(), end.date().isoformat() ) )
#split to train and test
session_max_times = data_filtered.groupby('SessionId').Time.max()
sessions_train = session_max_times[session_max_times < middle.timestamp()].index
sessions_test = session_max_times[session_max_times >= middle.timestamp()].index
train = data[np.in1d(data.SessionId, sessions_train)]
print('Train set {}\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {}'.
format( slice_id, len(train), train.SessionId.nunique(), train.ItemId.nunique(), start.date().isoformat(), middle.date().isoformat() ) )
train.to_csv(output_file + '_train_full.'+str(slice_id)+'.txt', sep='\t', index=False)
test = data[np.in1d(data.SessionId, sessions_test)]
test = test[np.in1d(test.ItemId, train.ItemId)]
tslength = test.groupby('SessionId').size()
test = test[np.in1d(test.SessionId, tslength[tslength>=2].index)]
print('Test set {}\n\tEvents: {}\n\tSessions: {}\n\tItems: {}\n\tSpan: {} / {} \n\n'.
format( slice_id, len(test), test.SessionId.nunique(), test.ItemId.nunique(), middle.date().isoformat(), end.date().isoformat() ) )
test.to_csv(output_file + '_test.'+str(slice_id)+'.txt', sep='\t', index=False)
def error_log_append(errorString, sessionID, statusID):
localTimestamp = int(time())
localDateTime = datetime.fromtimestamp(localTimestamp)
with open(paths.errorLog, 'a') as f:
f.writelines(
"Status crashed and the following exception or error was raised:")
f.writelines('\n\t' + errorString)
f.writelines('\n\tSession ID: ' + sessionID)
f.writelines('\n\tCurrent or previous Status ID: ' + statusID)
f.writelines('\n\t' + str(localTimestamp))
f.writelines('\n\t' + str(localDateTime) + '\n')
def save_record(request, encode_params):
param_str = base64.standard_b64decode(encode_params.encode())
param_list = param_str.decode().split(',')
record = models.LocationRecords()
record.imei = param_list[0]
record.longitude = param_list[1]
record.latitude = param_list[2]
record.update_time = datetime.fromtimestamp(int(param_list[3])/1000)
record.save()
print(param_list)
return HttpResponse("success")
def _format_data(self, graph_df):
if self._time_format == "numerate":
return
if self._time_format == "MIL":
graph_df[self._time_col] = graph_df[self._time_col] / 1000 # mili to seconds
if self._time_format == "MIL" or self._time_format == "SEC":
graph_df[self._time_col] = \
graph_df[self._time_col].apply(lambda x: datetime.fromtimestamp(x)) # to datetime format
else:
# to datetime
graph_df[self._time_col] = graph_df[self._time_col].apply(lambda x: datetime.strptime(str(x), self._time_format))
def datetime_filter(t):
delta = int(time.time() - t)
if delta < 60:
return u'1分钟前'
if delta < 3600:
return u'%s分钟前' % (delta // 60)
if delta < 86400:
return u'%s小时前' % (delta // 3600)
if delta < 604800:
return u'%s天前' % (delta // 86400)
dt = datetime.fromtimestamp(t)
return u'%s年%s月%s日' % (dt.year, dt.month, dt.day)
def print_block_chain(self):
current_block = self.tail
index = 0
while current_block:
print("Index: ", index)
print("Timestamp: ",
datetime.fromtimestamp(current_block.timestamp))
print("data: ", current_block.data)
print("SHA256 Hash: ", current_block.hash)
print("Prev Hash: ", current_block.previous_hash)
current_block = current_block.prev
index += 1
def file_info():
path = request.headers['path']
filename = request.headers['file_name']
file = os.path.join(root_dir, path, filename)
if not os.path.exists(file):
return 'file ' + file + ' does not exist'
# collect file info
st = os.stat(file)
s = filename + ' info: \n\n' + \
'mode: ' + str(st.st_mode) + '\n' + \
'I-node: ' + str(st.st_ino) + '\n' + \
'device: ' + str(st.st_dev) + '\n' + \
'number of hard links: ' + str(st.st_nlink) + '\n' + \
'uid: ' + str(st.st_uid) + '\n' + \
'gid: ' + str(st.st_gid) + '\n' + \
'size: ' + str(st.st_size) + ' bytes\n' + \
'last access (atime): ' + str(datetime.fromtimestamp(int(st.st_atime))) + '\n' + \
'last modify (mtime): ' + str(datetime.fromtimestamp(int(st.st_mtime)))
return s
def update_subscriptions(cookie):
query['restful_graph_data'] = {}
results = StationReadings.get_newest_by_cookie("",
cookie["id"])["pin_data"]
if results:
for pin in StationReadings.get_newest_by_cookie(
"", cookie["id"])["pin_data"]:
pin['time'] = datetime.fromtimestamp(int(
pin['time'][0:10])) # remove milliseconds
query['map_data']["pin_data"].append(pin)
query['restful_graph_data'] = StationReadings.get_all_by_cookie(
"", cookie["id"])
print( ' '.join([str(i),'out of',str(len(tickerSet)),'-',tickerSet[i],'options found, set ,',str(k)]))
splitData = re.split('"expirationDates"|"strikes"|"quote"|"options"|"_options"|"epochs"',tickerData[0])
if len(splitData) < 3:
continue
underlyingData = re.split(',',splitData[3][2:-2])
underlyingData = pd.DataFrame([x.replace('"','').split(':') for x in underlyingData])
underlying = pd.DataFrame(underlyingData[1].to_dict(),index=[0])
underlying.columns = underlyingData[0]
underlying = underlying.T.drop_duplicates().T
underlyingOutput.append(underlying)
contracts = re.split('<option ',str(scrape.findAll("option")))
contracts = [re.findall(r'"([^"]*)"', x)[1] for x in contracts[1:]]
contractDates = [np.datetime64(datetime.fromtimestamp(np.float(x)).isoformat()) for x in contracts]
for ii in range(len(contracts)):
print(ii)
if ii != 0:
testPop = []
while len(testPop) == 0:
pullData = requests.Request('GET', url + tickerSet[i] + '+' + contracts[ii])
pullData = pullData.prepare()
dataText, track = tryRequest(funct = pullData, typ = 'sendRaise', track = track)
scrape = BeautifulSoup(dataText,'lxml')
testPop = scrape.findAll("table", {"class": "details-table quote-table Fz-m"})
optionData = scrape.findAll("table", {"class": "details-table quote-table Fz-m"})
