def genPeriodsFromDates(self, dts, duration):
"Generates list of periods based of given start times and duration."
ps = []
for dt in dts:
p = Period(session = self
, start = dt
, duration = duration
)
p.save()
ps.append(p)
return ps
def post(self):
values = json.decode(self.request.body)
courseCodeGet = values['code']
dateGet = values['date']
startTimeGet = values['startTime']
endTimeGet = values['endTime']
periodTypeGet = values['type']
rooms = values['rooms']
courseList = Course.query_by_code(courseCodeGet).fetch(1)
course = None
for c in courseList:
course = c
period = Period(parent=course.key)
# Setup the period
period.date = datetime.datetime.strptime(dateGet, '%d.%m.%Y').date()
period.startTime = datetime.datetime.strptime(startTimeGet,
'%H:%M').time()
period.endTime = datetime.datetime.strptime(endTimeGet, '%H:%M').time()
period.periodType = periodTypeGet
i = 0
for r in rooms:
period.rooms.append(rooms[str(i)])
i = i + 1
period.put()
course.periodsKeys.append(period.key)
course.put()
def _prop_from_ref(self, p):
if (p == None or p == WrapperNULL):
return None
d_string = icallangbind_property_eval_string(p, ":")
d = eval(d_string)
d['ref'] = p
if not self.cached_props.has_key(p):
if d['value_type'] == 'DATE-TIME' or d['value_type'] == 'DATE':
prop = Time(d, )
elif d['value_type'] == 'PERIOD':
prop = Period(d)
elif d['value_type'] == 'DURATION':
prop = Duration(d)
elif d['name'] == 'ATTACH':
prop = Attach(d)
elif d['name'] == 'ATTENDEE':
prop = Attendee(d)
elif d['name'] == 'ORGANIZER':
prop = Organizer(d)
else:
prop = Property(ref=p)
self.cached_props[p] = prop
def _prop_from_ref(self, p):
if (p == None or p == WrapperNULL):
return None
d = {}
d['value'] = icalproperty_get_value_as_string(p)
d['name'] = icalproperty_get_property_name(p)
propkind = icalproperty_string_to_kind(d['name'])
kind = icalproperty_kind_to_value_kind(propkind)
d['value_type'] = icalvalue_kind_to_string(kind)
d['ref'] = p
#~ print p, Property(ref=p).name()
if not self.cached_props.has_key(p):
if d['value_type'] == 'DATE-TIME' or d['value_type'] == 'DATE':
prop = Time(d, )
elif d['value_type'] == 'PERIOD':
prop = Period(d)
elif d['value_type'] == 'DURATION':
prop = Duration(d)
elif d['name'] == 'ATTACH':
prop = Attach(d)
elif d['name'] == 'ATTENDEE':
prop = Attendee(d)
elif d['name'] == 'ORGANIZER':
prop = Organizer(d)
else:
prop = Property(ref=p)
self.cached_props[p] = prop
def get(self):
periodsList = Period.query()
for period in periodsList:
period.key.delete()
courseList = Course.query()
for course in courseList:
course.key.delete()
def cb_fill(self, number): """callback for fill the db""" from User import User import Event for i in range(number): cursus = Cursus() cursus.name = "Cursus-"+str(date.today().year + i) cursus.start = date(date.today().year + i, 1, 1) db.session.add(cursus) period = Period() period.cursus = cursus period.cb_fill(number, cursus.name) user = User() user.cursus = [cursus] user.cb_fill(randint(1, number), 'cursus_user'+str(i))
def cb_fill(self, number):
"""callback for fill the db"""
from User import User
import Event
for i in range(number):
cursus = Cursus()
cursus.name = "Cursus-" + str(date.today().year + i)
cursus.start = date(date.today().year + i, 1, 1)
db.session.add(cursus)
period = Period()
period.cursus = cursus
period.cb_fill(number, cursus.name)
user = User()
user.cursus = [cursus]
user.cb_fill(randint(1, number), 'cursus_user' + str(i))
def __init__(self, name, period_type='months', n_periods=12):
self.name = name
self.periods = []
self.period_type = period_type
period_names = []
for n in range(n_periods):
period_names.append('{}{}'.format(period_type, n))
self.periods.append(Period())
self.income_statement = pd.DataFrame(period_names)
def _transform(self, period):
transformed = []
current_first = self._data_raw[0]
current = current_first
for data in self._data_raw[1:]:
if Period.is_greater_than(current_first.date, data.date, period):
transformed.append(current)
current = data
current_first = data
else:
current = self._combinator(current, data)
transformed.append(current)
return transformed
def _transform(self, period):
transformed = []
current_first = self._data_raw[0]
current = current_first
for data in self._data_raw[1:]:
if Period.is_greater_than(current_first.date, data.date, period):
transformed.append(current)
current = data
current_first = data
else:
current = self._combinator(current, data)
transformed.append(current)
return transformed
def get(self):
self.response.headers['Content-Type'] = 'application/json'
courseCodeGet = self.request.get('code')
# The four next lines gets the course corresponding to the code in parameter.
courseList = Course.query_by_code(courseCodeGet).fetch(1)
course = None
for c in courseList:
course = c
periodsList = Period.query_by_parent(course.key).fetch(5)
periodsJSON = {}
i = 0
for p in periodsList:
periodsJSON.update({str(i): p.get_as_json()})
i = i + 1
self.response.out.write(json.encode(periodsJSON))
def cb_tree_plug(self, tree, iter, id):
"""plug object's childs in the tree"""
from Period import Period
from User import User
from TreeMgmt import TreeRowMgmtSeparator
period = None
for period in self.periods:
tree.plug(iter, period, self)
self.last_period = period
add_period = Period()
tree.plug_action(iter, add_period, self, Period.ADD_ACTION)
tree.plug_group(iter, User(), self, User.CURSUS_MANAGERS_GROUP)
def test_one_day_period_before_budget(self):
ba = BudgetAccount(Budget('201703', 31))
period = Period(datetime(2017, 2, 27), datetime(2017, 2, 28))
self.amount_should_be(ba, period, 0)
def test_half_month_period_has_budget(self):
ba = BudgetAccount(Budget('201703', 31))
period = Period(datetime(2017, 3, 1), datetime(2017, 3, 15))
self.amount_should_be(ba, period, 15)
def plug_period(obj, tree, iter, parent):
for period in obj.periods:
tree.plug(iter, period, parent)
link_period = Period()
tree.plug_action(iter, link_period, parent,
Period.LINK_CLASS_ACTION)
def test_period_before_budget_time(self):
bm = BudgetManager
bm.get_budgets(Budget("201703", 31))
self.assertEqual(bm.account_budget(Period(datetime(2017, 2, 27),datetime(2017, 2, 28))), 0)
#!/usr/bin/env python
def test_no_budget(self):
ba = BudgetAccount()
period = Period(datetime(2017, 3, 1), datetime(2017, 3, 15))
self.amount_should_be(ba, period, 0)
def test_amount_is_100(self):
ba = BudgetAccount(Budget('201703', 3100))
period = Period(datetime(2017, 3, 1), datetime(2017, 3, 5))
self.amount_should_be(ba, period, 500)
import urllib.request
import re
import time
from Period import Period
from RequestClient import RequestClient
from Monitor import Monitor
import os
import winsound
winsound.PlaySound('p.mp3', flags=1)
forward = Period("I1807")
recent = Period("I1809")
request = RequestClient("http://hq.sinajs.cn/list=")
# 正常值 了结价格 偏低值
monitor = Monitor(request, forward, recent, -20, -25, -30)
while True:
time.sleep(1)
monitor.checking()
print(monitor.DValue)
print(forward.price)
print(recent.price)
#!/usr/bin/env python
def test_amount_is_100_per_day(self):
bm = BudgetManager
bm.get_budgets(Budget("201703", 3100))
self.assertEqual(bm.account_budget(Period(datetime(2017, 3, 20), datetime(2017, 3, 26))), 700)
def test_20_days_period_in_budget_time(self):
bm = BudgetManager
bm.get_budgets(Budget("201703", 31))
self.assertEqual(bm.account_budget(Period(datetime(2017, 3, 1), datetime(2017, 3, 20))), 20)
def test_multiple_budgets_with_overlapping_period(self):
bm = BudgetManager
bm.get_budgets(Budget("201703", 3100), Budget("201704", 120))
self.assertEqual(bm.account_budget(Period(datetime(2017, 3, 30), datetime(2017, 4, 3))), 212)
while (readingCount < numOfParams):
line = myFile.readline()
data.append(
line[::-1].split('p')[1][2::].split('>')[0][::-1])
readingCount = readingCount + 1
if (readingCount == 3):
jumpLines(myFile, 3)
if (readingCount == 7):
jumpLines(myFile, 2)
# saving period info
currentPeriods.append(
Period(periodCount, data[0], data[1],
float(data[2][:-1].replace(',', '.')),
float(data[3].replace(',', '.')), data[4],
float(data[5][:-1].replace(',', '.')), data[6],
data[7], data[8]))
periodCount = periodCount + 1
data = []
jumpLines(myFile, 12)
# saving pair info
#for period in periodCount
pairs.append(Pair(str(pairIndex), currentPair, currentPeriods))
pairIndex = pairIndex + 1
currentPeriods = []
# Step 5b: get chart data for further analysis
# beta rotation chart (same for every period)
time.sleep(5)
def __init__(self,arg): Period.__init__(self,arg,"RDATE")
p = None
def test_one_day_period_after_budget(self):
ba = BudgetAccount(Budget('201703', 31))
period = Period(datetime(2017, 4, 1), datetime(2017, 4, 2))
self.amount_should_be(ba, period, 0)
def test_one_overlapping_period_cross_budget_first_day(self):
ba = BudgetAccount(Budget('201703', 31))
period = Period(datetime(2017, 2, 28), datetime(2017, 3, 5))
self.amount_should_be(ba, period, 5)
def test_period_overlapping_budget_last_day(self):
bm = BudgetManager
bm.get_budgets(Budget("201703", 31))
self.assertEqual(bm.account_budget(Period(datetime(2017, 3, 27),datetime(2017, 4, 2))), 5)
def test_multiple_budgets_with_overlapping_days(self):
ba = BudgetAccount(Budget('201703', 3100), Budget('201704', 30))
period = Period(datetime(2017, 3, 29), datetime(2017, 4, 2))
self.amount_should_be(ba, period, 302)
def test_period_after_budget_time(self):
bm = BudgetManager
bm.get_budgets(Budget("201703", 31))
self.assertEqual(bm.account_budget(Period(datetime(2017, 4, 1),datetime(2017, 4, 3))), 0)
def __init__(self, arg):
Period.__init__(self, arg, "RDATE")
class TVMUser:
_EPOCH = datetime(2000, 1, 1)
@staticmethod
def comparator(entry):
diff = entry.date - TVMUser._EPOCH
return diff.days * 24 * 60 * 60 + diff.seconds
@staticmethod
def combinator(entry1, entry2):
return Entry(entry1.id, entry1.date, entry1.data + entry2.data)
year = Period(Period.YEAR_TYPE, 1)
month = Period(Period.MONTH_TYPE, 1)
day = Period(Period.DAY_TYPE, 1)
minute = Period(Period.MINUTE_TYPE, 1)
insig_words = ("i", "to", "and", "the", "you", "of", "this", "is", "it",
"t", "my", "on", "for", "as", "ll", "s", "a", "that", "in",
"be", "not", "was", "with", "me", "have", "are", "your",
"or", "can", "when", "our", "all", "but", "how", "did",
"which", "what", "there", "just", "its", "has", "been",
"from", "one", "her", "she", "were", "had", "more", "about",
"they", "their", "his")
def __init__(self, name):
self.entries = EntriesDataObject.load(name)
self.model = TVM(self.entries.data, TVMUser.comparator,
TVMUser.combinator)
self.results = {}
def _apply(self, period, name, function):
if (period, name) not in self.results:
self.results[(period, name)] = self.model.apply(period, function)
return self.results[(period, name)]
def get_length(self, period):
def length(entry):
return len(entry.data)
return self._apply(period, "length", length)
def get_freq(self, period):
def freq(entry):
all_words = split('\W+', entry.data)
words = {}
for word in all_words:
word = word.lower()
if word in words:
words[word] += 1
else:
words[word] = 1
n = len(all_words)
freqs = []
for word, count in words.items():
freqs.append((word, count * 1.0 / n))
return entry.date, sorted(freqs, key=lambda x: x[1])[::-1], len(
entry.data)
return self._apply(period, "freq", freq)
def print_freq(self, period, i):
result = self.get_freq(period)[i]
def include(word):
if word.lower() in TVMUser.insig_words:
return False
if len(word) <= 2:
return False
return True
for item in result:
freq = item[1]
date = item[0]
length = item[2]
s = str(date.year) + " " + str(
date.month) + " | " + str(length) + ": "
i = 0
for item in freq:
word = item[0]
if include(word):
s += word + ", "
i += 1
if i >= 10:
break
print s
@staticmethod
def splitParagraphIntoSentences(paragraph):
sentenceEnders = compile(
r"""
# Split sentences on whitespace between them.
(?: # Group for two positive lookbehinds.
(?<=[.!?]) # Either an end of sentence punct,
| (?<=[.!?]['"]) # or end of sentence punct and quote.
) # End group of two positive lookbehinds.
(?<! Mr\. ) # Don't end sentence on "Mr."
(?<! Mrs\. )
(?<! Ms\. )
(?<! Jr\. )
(?<! Dr\. )
(?<! Prof\. )
(?<! Sr\. )
\s+ # Split on whitespace between sentences.
""", IGNORECASE | VERBOSE)
return sentenceEnders.split(paragraph)
def get_markov_sentences(self, period):
def markov_sentences(entry):
sentences = TVMUser.splitParagraphIntoSentences(entry.data)
sentences_words = []
for sentence in sentences:
words = split("\W+", sentence)
sentences_words.append(
[word for word in words if len(word) > 0])
result = {}
for sentence_words in sentences_words:
for i in range(len(sentence_words) - 1):
cur, next = sentence_words[i].lower(), sentence_words[
i + 1].lower()
if cur in result:
target_dict = result[cur]
if next in target_dict:
target_dict[next] += 1
else:
target_dict[next] = 1
else:
target_dict = {next: 1}
result[cur] = target_dict
return result
return self._apply(period, "markov_sentences", markov_sentences)
def make_markov_sentences(self, period, i, size=10, seed=None):
dict = self.get_markov_sentences(period)[i]
n = len(dict)
if seed is None:
seed = dict.keys()[int(random() * n)]
def choose_word(word):
next_words = dict[word]
total = 0
for count in next_words.values():
total += count
selection = random()
bound = 0
for word, count in next_words.items():
bound += count / 1.0 / total
if bound >= selection:
return word
cur_word = seed
sentence = cur_word
count = 0
while cur_word in dict and count < size:
cur_word = choose_word(cur_word)
sentence += " " + cur_word
count += 1
return sentence
def make_freq_vectors(self, period):
results = self.get_freq(period)
word_space_map = {}
word_space_map_inverse = {}
i = 0
for result in results:
for word, _ in result[1]:
word = word.lower()
if word not in word_space_map:
word_space_map[word] = i
word_space_map_inverse[i] = word
i += 1
n = i + 1
dates = []
freq_vectors = []
for result in results:
dates.append(result[0])
vec = [0 for i in range(n)]
for word, freq in result[1]:
vec[word_space_map[word]] = freq
freq_vectors.append(vec)
return dates, freq_vectors, word_space_map_inverse
