def test_update_activity(self):
activity1 = Activity("888", "party", datetime(2020, 2, 2, 3, 20),
datetime(2020, 2, 2, 4, 30), "case")
activity2 = Activity("000", "party", datetime(2020, 2, 2, 3, 20),
datetime(2020, 2, 2, 4, 30), "case")
self.assertTrue(self.db.update_activity(activity1))
self.assertFalse(self.db.update_activity(activity2))
def buildList(listAct):
""" Add the start activity and end activity
"""
listStart = []
listActWithPred = [] #List of activities having at least predecessor
start = Activity(-1, "start", listStart, 0, None)
start.EST = 0
start.LST = 0
start.LFT = 0
end = Activity(-2, "end", None, 0, None)
for act in listAct:
if (act.successors is None):
act.successors = [end]
end.predecessors.append(act)
else:
listActWithPred.extend(act.successors)
for suc in act.successors: #adding predecessors
suc.predecessors.append(act)
for act in listAct:
if (not act in listActWithPred):
start.successors.append(act)
act.predecessors.append(start)
listAct.insert(0, start)
listAct.append(end)
def compose_activity(content):
restrictions = []
activity_type = map_activity_type(content['scheduling_type'])
if activity_type == ActivityUtil.TYPE_INSTANCES or 'instances_per_day' in content:
instances_per_week = content[
'instances_per_week'] if 'instances_per_week' in content else 7
generated_activities = []
duration = map_duration(content)
for i in range(1, instances_per_week + 1):
for j in range(1, content['instances_per_day'] + 1):
generated_activities.append(
Activity(name="%s [%d, %d]" % (content['name'], i, j),
duration=duration,
activity_type=activity_type,
restrictions=restrictions,
instances_per_week=instances_per_week,
instances_per_day=content['instances_per_day']))
return generated_activities
return Activity(
content['name'],
map_duration(content),
map_activity_type(content['scheduling_type']),
restrictions,
)
def on_message(self, text):
dict_key = self.kwargs.get("key", "name")
if text != "Назад":
self.deferred.callback(
ActivityReturn(ActivityReturn.ReturnType.OK, {dict_key: text}))
return
Activity.on_message(self, text)
def clone(self):
pos = Instance()
pos.name = "clone of " + self.name
for act in self.activities:
newAct = Activity(act.time, len(self.resources))
newAct.resources = act.resources[:]
newAct.predecessors = act.predecessors.copy()
newAct.successors = act.successors.copy()
pos.activities.append(newAct)
return pos
def clone(self): pos = Instance() pos.name = "clone of " + self.name for act in self.activities: newAct = Activity(act.time, len(self.resources)) newAct.resources = act.resources[:] newAct.predecessors = act.predecessors.copy() newAct.successors = act.successors.copy() pos.activities.append(newAct) return pos
def _segue_to(self, activity: Activity, segue_type):
if len(self.stack) > 0:
if segue_type == Segue.REPLACE:
current_activity = self.stack.pop()
else:
current_activity = self.stack[-1]
current_activity._stop()
current_activity.on_stop()
self.unsubscribe_all(current_activity)
self.stack.append(activity)
activity._start(application=self)
def main(l, params):
act = Activity(l)
l = preProcessLog(l, act.a)
print("")
print("############## ACTIVITIES SET ##############")
act = Activity(l)
print(act.a)
print("")
print("############## LOG LIST ##############")
log = Log(l)
print(log.l)
print("")
print("############## FREQUENCY TABLE ##############")
freq = FrequencyDirectlyFollows(log.l, act.a)
print(freq.ft)
print("")
print("############## DEPENDENCY TABLE ##############")
depen = Dependency(freq.ft, act.a)
print(depen.dt)
print("")
print("############## CNET A_I AND A_O ##############")
cnet = CNet(act.a, log.l, freq.ft, depen.dt, params)
print(cnet.a_i)
print(cnet.a_o)
print("")
print("############## CNET DEPENDENCY OUT ##############")
print(cnet.depRelOut)
print("")
print("############## CNET DEPENDENCY IN ##############")
print(cnet.depRelIn)
print("")
print("############## CNET OUTPUT BINDINGS ##############")
print(cnet.outBind)
print("")
print("############## CNET INPUT BINDINGS ##############")
print(cnet.inBind)
print("")
print("############## CNET IS VALID SEQUENCE ##############")
print(cnet.isValidSequence(['a','b','b','e'], 4))
def on_message(self, text):
field_type = self.kwargs.get("field_type", "str")
if text != "Назад":
value = None
if field_type == "str":
value = text
elif field_type == "int" and FieldEdit.is_int(text):
value = int(text)
elif field_type == "bool" and FieldEdit.is_bool(text):
value = {"Да": True, "Нет": False}[text]
if value is not None:
self.deferred.callback(ActivityReturn(ActivityReturn.ReturnType.OK, {"value": value}))
return
Activity.on_message(self, text)
def __init__(self):
if self.isMember():
filePath = "./user/profile.txt"
f = open(filePath, "r")
s = f.readlines()
self.name = s[0].split('\n')[0]
self.gender = s[1].split('\n')[0]
self.birth = s[2].split('\n')[0]
self.currentDate = s[3].split('\n')[0]
self.height = s[4].split('\n')[0]
self.weight = s[5].split('\n')[0]
self.goal = Goal(self)
self.workOut = WorkOut(self.gender)
self.activity = Activity()
f.close()
else:
self.name = None
self.gender = None
self.birth = None
self.currentDate = None
self.height = None
self.weight = None
self.goal = None
self.workOut = None
self.activity = None
def readFromExport(self, infile):
line = string.strip(infile.readline())
while not string.strip(line) == '':
parts = line.split(',')
newAct = Activity(int(parts[0]), 0)
if len(parts[1]) > 0:
newAct.predecessors.update(map(int, parts[1].split()))
if len(parts[2]) > 0:
newAct.resources = map(int, parts[2].split())
self.activities.append(newAct)
line = string.strip(infile.readline())
for (actId, act) in enumerate(self.activities):
for pred in act.predecessors:
self.activities[pred].successors.add(actId)
def read(fileActivities):
"""Reads the input file
The file must be a CSV file
The attributes of each activities must follow this order :
1. ID
2. Name
3. Successors : set of activities' id delimited by the symbol ";"
4. Duration
5. Normal Cost
6. Top Cost
7. Reduction Cost
8. Ressources : set of integer delimited by the symbol ";"
(First integer is the amount of the first ressource and so on)
"""
listActivities = []
f = csv.reader(open(fileActivities,"rb"))
for line in f:
ident = int(line[0])
name = line[1]
successors = ""
if (line[2] != ""):
successors = map(int, line[2].split(";"))
duration = int(line[3])
normalCost = int(line[4])
topCost = int(line[5])
reductionCost = int(line[6])
ressources = ""
if (line[3] != ""):
ressources = map(int, line[7].split(";"))
act = Activity(ident, name, successors, duration, normalCost, topCost, reductionCost, ressources)
listActivities.insert(act.ident, act)
return listActivities
def getActivities(self, num: int, offset: int = 0) -> ActivityList:
orig_num = num
if (num > self.MAX_PAGE_SIZE):
remaining = num - self.MAX_PAGE_SIZE
num = self.MAX_PAGE_SIZE
else:
remaining = 0
out = ActivityList()
while (remaining >= 0):
self.log.debug(
"pagination parameters are: num=%s offset=%s remaining=%s" %
(num, offset, remaining))
page = math.floor(offset / num) + 1
activities = self.getActivitiesPage(page, num)
for activity in activities:
try:
out.append(Activity.newFromDict(activity))
except ValueError as e:
self.log.warning("Activity missing required field: %s" % e)
offset += num
remaining = orig_num - offset
num = self.MAX_PAGE_SIZE
out = out.sortByDate(True)
if (len(out) > orig_num):
return ActivityList.slice(out, 0, orig_num)
return out
def on_message(self, text):
field_type = self.kwargs.get("field_type", "str")
if text != "Назад":
value = None
if field_type == "str":
value = text
elif field_type == "int" and FieldEdit.is_int(text):
value = int(text)
elif field_type == "bool" and FieldEdit.is_bool(text):
value = {"Да": True, "Нет": False}[text]
if value is not None:
self.deferred.callback(
ActivityReturn(ActivityReturn.ReturnType.OK,
{"value": value}))
return
Activity.on_message(self, text)
def add_activity(self, name, children):
if name == '?':
self.add_black_box(children)
else:
new_activity = Activity(name, children)
self.components.append(new_activity)
self.G.add_node(new_activity)
def readFromExport(self, infile):
line = string.strip(infile.readline())
while not string.strip(line) == '':
parts = line.split(',')
newAct = Activity(int(parts[0]), 0)
if len(parts[1]) > 0:
newAct.predecessors.update(map(int, parts[1].split()))
if len(parts[2]) > 0:
newAct.resources = map(int, parts[2].split())
self.activities.append(newAct)
line = string.strip(infile.readline())
for (actId, act) in enumerate(self.activities):
for pred in act.predecessors:
self.activities[pred].successors.add(actId)
def getAllActivities(self) -> ActivityList:
"""
Get all activities for the user, for all time. Keep walking back
page-by-page until it looks like we have everything
return: ActivityList
"""
page = 1
done = False
out = ActivityList()
while (not done):
activities = self.getActivitiesPage(page, self.MAX_PAGE_SIZE)
for activity in activities:
try:
out.append(Activity.newFromDict(activity))
except ValueError as e:
self.log.warning("Activity missing required field: %s" % e)
page = page + 1
if (len(activities) < self.MAX_PAGE_SIZE):
self.log.debug(
"Asked for %d got %d. Assuming all activities are fetched"
% (self.MAX_PAGE_SIZE, len(activities)))
done = True
return out
def get(self):
activity = Activity()
from Authentication import Authentication
authentication = Authentication(users)
print(activity)
return ({
"activity": str(activity),
"user": str(authentication),
"location": "home"
})
def add_activity(self, name, duration, node_from_name, node_to_name):
self.add_nodes_to_nodes_dictionary(node_from_name, node_to_name)
activity_to_add = Activity(name, duration, node_from_name,
node_to_name)
assert activity_to_add, 'could not create an Activity instance'
updated_activity = self.update_the_activity_nodes_from_nodes_dictionary(
activity_to_add, "left")
assert updated_activity, 'could not update the activity'
self.activity_list.append(updated_activity)
self.calculate_activity_left_value_after_addition(activity_to_add)
def __init__(self, dictionary):
self.segmentType = dictionary['type']
self.startTime = parser.parse(dictionary['startTime'])
self.endTime = parser.parse(dictionary['endTime'])
if 'activities' in dictionary:
self.activitiesArray = [
Activity(d) for d in dictionary['activities']
]
else:
self.activitiesArray = []
def add_component(self, a_or_e, name, children):
c = None
if a_or_e == 'a':
if name == '?':
c = BlackBox(children)
else:
c = Activity(name, children)
elif a_or_e == 'e':
c = Entity(name, children)
self.components.append(c)
self.G.add_node(c, name=c.name, component_type=c.component_type)
def add_activity(name, data):
new_Activity = Activity(name, data)
if name is 'gehen':
Korpus.gehen = new_Activity
elif name is 'joggen':
Korpus.joggen = new_Activity
elif name is 'laufen':
Korpus.laufen = new_Activity
elif name is 'rueckw':
Korpus.rueckw = new_Activity
elif name is 'stehen':
Korpus.stehen = new_Activity
elif name is 'treppe':
Korpus.treppe = new_Activity
Korpus.activity.append(new_Activity)
def populate_evening_activities(self):
self.evening_activities_arr.append(
Activity("skits", "8 pm", "Ruth Brown steps"))
self.evening_activities_arr.append(
Activity("evening fires", "8 pm", "The Lodge"))
self.evening_activities_arr.append(
Activity("singing", "8 pm", "Ruth Brown steps"))
self.evening_activities_arr.append(
Activity("poetry", "8 pm", "Ruth Brown steps"))
self.evening_activities_arr.append(
Activity("capture the chicken", "8 pm", "Greenie Hill"))
self.evening_activities_arr.append(
Activity("dances", "8 pm", "Boat Barn"))
def activitylist_to_features(self, activitylist, activity_df=Activity.get_empty_dataframe(), starting_id=0):
#activity_df.set_index(["user_id",FeatureExtractor.default_kcs[0], "id"])
for i, act in enumerate(activitylist):
activity_df = activity_df.append(
{Activity.id.name: starting_id + i,
Activity.handedin.name: act.handedin,
Activity.xml_qno.name: act.xml_qno,
Activity.user_id.name: act.user_id,
Activity.chapter_id.name: act.chapter_id,
Activity.section_id.name: act.section_id,
Activity.objective_id.name: act.objective_id,
Activity.exercise_id.name: act.exercise_id,
Activity.got_correct.name: act.got_correct,
Activity.kc.name: act.kc,
}, ignore_index=True)
#activity_df = activity_df.set_index([ "user_id", FeatureExtractor.default_kcs[0], "id"])
df_features = self.df_to_features(activity_df)
return df_features
def activityImport(fichier):
file = open(fichier, "r")
try:
#on lit le fichier
reader = csv.reader(file)
i = 0
#pour chaque ligne, on la transforme en activité et on l'insert dans la BD
for row in reader:
#on ignore la première ligne qui contient les en-tetes
if (i != 0):
act = Activity(row[5], row[4])
print(act)
actInsertBD(act)
i += 1
#except:
# print("erreur, pas normal!!!")
finally:
file.close()
def readFromPSPLIB(self, infile):
# skip first lines (not interesting)
infile.readline()
infile.readline()
infile.readline()
# read instance information (number of jobs, number of resources)
(numJobs, numResources) = self.readInstanceInfo(infile)
# set up arrays
self.resources = [0] * numResources
for i in range(numJobs):
self.activities.append(Activity(0, numResources))
# read precedence relations
self.readPrecedences(infile)
# read durations & resource cost
self.readRequirements(infile)
# read resource availability
self.readResources(infile)
class TestActivity(TestCase):
start = datetime(2020, 2, 2, 12, 20)
end = datetime(2020, 2, 2, 15, 20)
id1 = "1"
name1 = "act1"
loc1 = "location1"
act = Activity(id1, name1, start, end, loc1)
def test_get_id(self):
self.assertTrue(self.act.get_id() == "1")
def test_get_name(self):
self.assertTrue(self.act.get_name() == "act1")
def test_get_start_time(self):
self.assertTrue(self.act.get_start_time() == self.start)
def test_get_end_time(self):
self.assertTrue(self.act.get_end_time() == self.end)
def test_get_location(self):
self.assertTrue(self.act.get_location() == self.loc1)
self.activity_queue[0].get_question())
self.already_visible = True
def get_activities_completed(self):
return self.activity_count
if __name__ == "__main__":
import os
import sys
from Activity import Activity
app = QtGui.QApplication(sys.argv)
screenShape = QtGui.QDesktopWidget().screenGeometry()
width = screenShape.width() / 3
height = screenShape.height() - 80
act = Activity(title='GOing to the mall')
pat = Patient(width=width, height=height)
pat.show()
pat.send(act)
# msg = QtGui.QMessageBox()
# msg.setIcon(QtGui.QMessageBox.Warning)
# msg.setText("This activity cannot be scheduled because it is past the time")
# msg.setWindowTitle("Scheduling Error")
# msg.setStandardButtons(QtGui.QMessageBox.Ok)
# msg.exec_()
sys.exit(app.exec_())
def populate_activities(self):
self.activities_arr.append(Activity("archery", "10 am", "field"))
self.activities_arr.append(Activity("soccer", "10 am", "field"))
self.activities_arr.append(Activity("pickleball", "10 am", "field"))
self.activities_arr.append(Activity("kickball", "10 am", "field"))
self.activities_arr.append(Activity("adventuretime", "10 am", "field"))
self.activities_arr.append(Activity("paddleboarding", "2 pm", "dock"))
self.activities_arr.append(Activity("extreme-canoe", "10 am", "dock"))
self.activities_arr.append(Activity("kayaking", "10 am", "dock"))
self.activities_arr.append(Activity("sailing", "2 pm", "dock"))
self.activities_arr.append(Activity("sail-racing", "10 am", "dock"))
self.activities_arr.append(Activity("swimming", "2 pm", "dock"))
self.activities_arr.append(Activity("pottery", "2 pm", "craft courts"))
self.activities_arr.append(
Activity("arts and crafts", "2 pm", "craft courts"))
self.activities_arr.append(Activity("yoga", "2 pm", "field"))
self.activities_arr.append(Activity("garden cookery", "2 pm",
"garden"))
self.activities_arr.append(Activity("Horsebackriding", "2 pm", "barn"))
self.activities_arr.append(Activity("Horsebackriding", "10 am",
"barn"))
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--send", help="dispatches e-mails to service providers, if not set will just write a report out",
action="store_true")
parser.add_argument("--infolder", type=str, help="folder to load from, defaults to {}".format(INPUT_DIR))
parser.add_argument("--infilename", type=str, help="file to load from, defaults to {}".format(INPUT_FILE_NAME))
parser.add_argument("--outfolder", type=str, help="folder to write to, defaults to {}".format(OUTPUT_DIR))
parser.add_argument("--outfilename", type=str, help="file to write to, defaults to {}".format(OUTPUT_FILE_NAME))
args = parser.parse_args()
if args.send:
print "--send flag has been set so SENDING E-MAILS TO SERVICE PROVIDERS"
# set up for output file if specified
in_folder_name = ""
if args.infolder:
in_folder_name = args.infolder
else:
in_folder_name = INPUT_DIR
in_file_name = ""
if args.infilename:
in_file_name = args.infilename
else:
in_file_name = INPUT_FILE_NAME
infile = os.path.join(in_folder_name, in_file_name)
print "using input data from file {}".format(infile)
# set up for output file if specified
out_folder_name = ""
if args.outfolder:
out_folder_name = args.outfolder
else:
out_folder_name = OUTPUT_DIR
out_file_name = ""
if args.outfilename:
out_file_name = args.outfilename
else:
out_file_name = OUTPUT_FILE_NAME
wb = open_workbook(infile)
for s in wb.sheets():
print 'found worksheet:', s.name
print
# make service provider map
provider_sheet = wb.sheet_by_name('Service providers')
sp_ids = provider_sheet.col_values(0,1)
sp_names = provider_sheet.col_values(1,1)
sp_primary_emails = provider_sheet.col_values(4,1)
providers = {}
i=0
for sp_id in sp_ids:
#print 'Service provider:', sp_id
sp = ServiceProvider()
sp.id = sp_id
sp.name = sp_names[i]
sp.primary_email = sp_primary_emails[i]
i=i+1
providers[sp_id] = sp
# for each activity in activities sheet, attach activity to appropriate provider
activity_sheet = wb.sheet_by_name('Activities')
act_ids = activity_sheet.col_values(0,1)
act_provider_ids = activity_sheet.col_values(1,1)
act_names = activity_sheet.col_values(3,1)
act_intros = activity_sheet.col_values(5,1)
act_start_dates = activity_sheet.col_values(7,1)
act_last_dates = activity_sheet.col_values(8,1)
act_start_times = activity_sheet.col_values(9,1)
act_recurrences = activity_sheet.col_values(11,1)
j=0
for activity_provider_id in act_provider_ids:
provider = providers.get(activity_provider_id)
if provider != None:
ac = Activity()
ac.id = act_ids[j]
ac.name = act_names[j]
ac.introduction = act_intros[j]
ac.time = act_start_times[j]
# work out what day the activity runs on from its start date
try:
start_date = datetime.strptime(act_start_dates[j], "%d/%m/%Y").date()
except TypeError as e:
exc_type, exc_value, exc_traceback = sys.exc_info()
print "Error converting activity start date at row {}. {}".format(j, str(e))
print "Try converting the date column into text and trying again. Also check that the year has century numbers i.e.; it is 2015 rather than 15"
traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
ac.day = find_day_of_week(start_date)
ends_on_date = datetime.strptime(act_last_dates[j], "%d/%m/%Y").date()
branch = {0 : generate_one_off_occurence_list,
1 : generate_next_weekly_occurence_list,
2 : generate_next_fortnightly_occurence_list,
3 : generate_next_day_of_month_occurence_list,
4 : generate_next_date_of_month_occurence_list}
next_dates = branch.get(act_recurrences[j], generate_default_occurence)(date.today(), start_date, ends_on_date)
HOW_MANY = 2
ac.next_dates = resize_next_dates(next_dates, HOW_MANY)
provider.addActivity(ac)
else:
print 'Activity id:', act_ids[j], ' has a provider_id of ', activity_provider_id, ' which does not match a service provider id'
j += 1
# if e-mail switch is on then generate and send e-mails, but only if the provider has some activities
if args.send:
for k in providers.keys():
provider = providers.get(k)
if len(provider.activities) > 0:
generate_email_to_provider(provider)
else:
# set up output for report
wb = Workbook()
ws = wb.add_sheet('Kids Connect output', cell_overwrite_ok=True)
# make header row
ws.row(0).write(0,'provider id')
ws.row(0).write(1,'provider name')
ws.row(0).write(2,'e-mail')
ws.row(0).write(3,'activity id')
ws.row(0).write(4,'activity name')
ws.row(0).write(5,'introduction')
ws.row(0).write(6,'day')
ws.row(0).write(7,'time')
ws.row(0).write(8,'next event 1')
ws.row(0).write(9,'next event 2')
row_num = 1
for k in providers.keys():
provider = providers.get(k)
print "processing provider {} {}".format(provider.id, provider.name)
for activity in provider.activities:
ws.row(row_num).write(0,provider.id)
ws.row(row_num).write(1,provider.name)
ws.row(row_num).write(2,provider.primary_email)
ws.row(row_num).write(3,activity.id)
ws.row(row_num).write(4,activity.name)
ws.row(row_num).write(5,activity.introduction)
ws.row(row_num).write(6,activity.day)
ws.row(row_num).write(7,activity.time)
if len(activity.next_dates) > 0:
event_col = 8
for next_event_date in activity.next_dates:
ws.row(row_num).write(event_col, next_event_date.strftime('%d-%m-%Y'))
event_col += 1
row_num += 1
output_file = os.path.join(out_folder_name, out_file_name)
wb.save(output_file)
print "writing output data to file {}".format(output_file)
print "finished!"
def collect_ride_data(self, challenge):
"""
Pull the latest ride data from Strava via the API
"""
client = Client()
client.access_token = self.strava_config['access-token']
#activities = client.get_club_activities(165009)
activities = client.get_club_activities(challenge.get_group_id())
act_list = []
for activity in activities:
if not activity.type == 'Ride' and not activity.type == 'VirtualRide':
print 'Non-ride activity: %s, type: %s' % (activity.name, activity.type)
continue
act = Activity(activity.id)
act.set_athlete(activity.athlete.id)
act.set_name(activity.name)
act.set_gmt_date(activity.start_date) # GMT Start date
act.set_elapsed_time(activity.elapsed_time)
act.set_distance(round(unithelper.kilometers(activity.distance).num, 2))
act.set_elevation(unithelper.meters(activity.total_elevation_gain).num)
act.set_ride_type(activity.type)
act.set_trainer_ride(activity.trainer)
act_list.append(act)
db_store = GTDataStore(challenge.get_db_path(), self.verbose)
db_store.store_if_new(act_list)
def main():
address_old = 'localhost'
port_old = 27017
address_new = '192.168.6.254'
port_new = 37017
print("convert label type data")
LabelType.insert_label_type(address_new, port_new)
print("convert area data")
Area.insert_area(address_old, port_old, address_new, port_new)
print("convert label data")
Label.convert_label(address_old, port_old, address_new, port_new)
# 城市表 依赖新导入的Label表，需保证City前导入Label
print("convert city data")
City.convert_city(address_old, port_old, address_new, port_new)
print("convert weather data")
Weather.convert_weather(address_old, port_old, address_new, port_new,
Weather.collection_old, Weather.collection_new, Weather.params_map)
# 特别注意 weather_history 表依赖于当前的 weather 表
print("create weather_history data")
WeatherHistory.create_weather_history(address_new, port_new, address_new, port_new,
WeatherHistory.collection_old, WeatherHistory.collection_new, WeatherHistory.params_map)
print("convert pgc data")
Pgc.convert_pgc(address_old, port_old, address_new, port_new)
print("convert label data")
Label.convert_label(address_old, port_old, address_new, port_new)
print("convert attraction data")
Attraction.convert_attraction(address_old, port_old, address_new, port_new,
Attraction.collection_old, Attraction.collection_new, Attraction.params_map)
print("convert restaurant data")
Restaurant.convert_restaurant(address_old, port_old, address_new, port_new,
Restaurant.collection_old, Restaurant.collection_new, Restaurant.params_map)
print("convert shopping data")
Shopping.convert_shopping(address_old, port_old, address_new, port_new,
Shopping.collection_old, Shopping.collection_new, Shopping.params_map)
print("convert activity data")
Activity.convert_activity(address_old, port_old, address_new, port_new,
Activity.collection_old, Activity.collection_new, Activity.params_map)
print("convert recommendBynamic data")
# RecommendDynamic.convert_recommendDynamic(address_old, port_old, address_new, port_new,RecommendDynamic.collection_old,
# RecommendDynamic.collection_new, RecommendDynamic.params_map)
print("convert plan data")
Plan.convert_plan(address_old, port_old, address_new, port_new,
Plan.collection_old, Plan.collection_new, Plan.params_map)
print("convert brand data")
Brand.convert_brand(address_old, port_old, address_new, port_new,
Brand.collection_old, Brand.collection_new, Brand.params_map)
print("OK")
def parallelSequencing(listActivities) :
#initialization
available = [7,6]
chosenAct = []
copy=[]
sequencing = []
complete = []
instant = 0
finish=False
#initialization with successors of START
chosenAct.extend(listActivities[0].successors)
while (finish==False) :
sequencing = sorted(sequencing, key=lambda ac: ac.seq)
copy= sorted(copy, key=lambda activity: activity.LFT) #activities arranged in LFT order
if(len(listActivities)==(len(complete)+len(sequencing))): #if all the activities are handled :
instant=complete[len(complete)-1].seq
for seq in sequencing :
complete.append(seq)
sequencing.remove(seq)
finish = True
else :
chosenAct=sorted(chosenAct, key=lambda activity: activity.LFT) # Order LFT
sequencing=sorted(sequencing, key=lambda activity: activity.seq) # Order LFT
for pa in sequencing :
if (pa.seq<=instant):
available = addRes(available, pa.resources) #update of resources
complete.append(pa)
sequencing.remove(pa)
for succ in pa.successors : #verify if the activity is already in the chosen activities list or not to avoid repetition when adding
found=False
if succ.ident != -2:
for find in chosenAct :
if succ.name == find.name:
found = True
if predComplete(succ, complete) == True and found == False :
chosenAct.append(succ)
copy=list(chosenAct)
copy= sorted(copy, key=lambda activity: activity.LFT)
for act in copy : #Next step : sequencing the selected activity if not already sequenced thanks to an other predecessor
if (isSeq(act,available) == True) :
parAct = Activity(act.ident,act.name,act.successors,act.duration,act.resources)
parAct.seq = instant+act.duration
parAct.predecessors = act.predecessors
done = False
if activitySearch(sequencing,act) == True or activitySearch(complete,act) == True :
done = True
chosenAct.remove(act)
if (done == False) : # if the activity is not already sequenced by an other predecessor :
sequencing.append(parAct)
available = minusRes(available, act.resources) #update of resources
chosenAct.remove(act)
sequencing = sorted(sequencing, key=lambda activity: activity.seq)
if (len(complete)+2)<len(listActivities):
instant = sequencing[0].seq
else:
finish = True
def _populate(self, stmt_data, auth, sub=False):
# pdb.set_trace()
args = {}
#Must include verb - set statement verb
try:
raw_verb = stmt_data['verb']
except KeyError:
raise exceptions.ParamError(
"No verb provided, must provide 'verb' field")
#Must include object - set statement object
try:
statementObjectData = stmt_data['object']
except KeyError:
raise exceptions.ParamError(
"No object provided, must provide 'object' field")
try:
raw_actor = stmt_data['actor']
except KeyError:
raise exceptions.ParamError(
"No actor provided, must provide 'actor' field")
# Throw error since you can't set voided to True
if 'voided' in stmt_data:
if stmt_data['voided']:
raise exceptions.Forbidden(
'Cannot have voided statement unless it is being voided by another statement'
)
# If not specified, the object is assumed to be an activity
if not 'objectType' in statementObjectData:
statementObjectData['objectType'] = 'Activity'
args['verb'] = self._build_verb_object(raw_verb)
valid_agent_objects = ['agent', 'group']
# Check to see if voiding statement
# if raw_verb['id'] == 'http://adlnet.gov/expapi/verbs/voided':
if args['verb'].verb_id == 'http://adlnet.gov/expapi/verbs/voided':
# objectType must be statementRef if want to void another statement
if statementObjectData['objectType'].lower(
) == 'statementref' and 'id' in statementObjectData.keys():
stmt_ref = self._voidStatement(statementObjectData['id'])
args['stmt_object'] = stmt_ref
else:
raise exceptions.ParamError(
"There was a problem voiding the Statement")
else:
# Check objectType, get object based on type
if statementObjectData['objectType'].lower() == 'activity':
if auth is not None:
args['stmt_object'] = Activity(
json.dumps(statementObjectData),
auth=auth.username).activity
else:
args['stmt_object'] = Activity(
json.dumps(statementObjectData)).activity
elif statementObjectData['objectType'].lower(
) in valid_agent_objects:
args['stmt_object'] = Agent(initial=statementObjectData,
create=True).agent
elif statementObjectData['objectType'].lower() == 'substatement':
sub_statement = SubStatement(statementObjectData, auth)
args['stmt_object'] = sub_statement.statement
elif statementObjectData['objectType'].lower() == 'statementref':
try:
existing_stmt = models.statement.objects.get(
statement_id=statementObjectData['id'])
except models.statement.DoesNotExist:
raise exceptions.IDNotFoundError(
"No statement with ID %s was found" %
statementObjectData['id'])
else:
stmt_ref = models.StatementRef(
ref_id=statementObjectData['id'])
stmt_ref.save()
args['stmt_object'] = stmt_ref
#Retrieve actor
args['actor'] = Agent(initial=stmt_data['actor'], create=True).agent
#Set voided to default false
args['voided'] = False
#Set result when present - result object can be string or JSON object
if 'result' in stmt_data:
# args['result'] = self._populateResult(stmt_data, raw_verb)
args['result'] = self._populateResult(stmt_data, args['verb'])
# Set context when present
if 'context' in stmt_data:
args['context'] = self._populateContext(stmt_data)
# Set timestamp when present
if 'timestamp' in stmt_data:
args['timestamp'] = stmt_data['timestamp']
if 'authority' in stmt_data:
args['authority'] = Agent(initial=stmt_data['authority'],
create=True).agent
else:
if auth:
authArgs = {}
authArgs['name'] = auth.username
authArgs['mbox'] = auth.email
args['authority'] = Agent(initial=authArgs, create=True).agent
#See if statement_id already exists, throw exception if it does
if 'statement_id' in stmt_data:
try:
existingSTMT = models.statement.objects.get(
statement_id=stmt_data['statement_id'])
except models.statement.DoesNotExist:
args['statement_id'] = stmt_data['statement_id']
else:
raise exceptions.ParamConflict(
"The Statement ID %s already exists in the system" %
stmt_data['statement_id'])
else:
#Create uuid for ID
args['statement_id'] = uuid.uuid4()
# args['stored'] = datetime.datetime.utcnow().replace(tzinfo=utc).isoformat()
#Save statement
self.statement = self._saveStatementToDB(args, sub)
def on_message(self, text):
dict_key = self.kwargs.get("key", "name")
if text != "Назад":
self.deferred.callback(ActivityReturn(ActivityReturn.ReturnType.OK, {dict_key: text}))
return
Activity.on_message(self, text)
def __init__(self):
# app title
appuifw.app.title = u"Sissi"
# app lock
self.lock = e32.Ao_lock()
# ensure data dir exists
self.datadir = os.path.join(u"C:\\Data", u"Sissi")
if not os.path.exists(self.datadir):
os.makedirs(self.datadir)
# create a directory for temporary data
self.cachedir = u"D:\\Sissi"
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
# get screen resolution
self.screen = sysinfo.display_pixels()
# extra classes instantiated
self.scanner = Scanner(self)
self.netmapper = NetMapper(self)
self.map = Map(self)
self.cos_api = COSApi(self)
self.sensor = Activity(self)
# timers
self.t = e32.Ao_timer()
self.t2 = e32.Ao_timer()
self._timer = 0
self._interval = 15
self.active = False
# set canvas
self.activate()
# configuration / settings
self.draw_screen('reading config')
self.config_file = os.path.join(self.datadir, "settings.ini")
self.config = {} # TODO: read these from a configuration file
self.apid = None # Default access point
self.read_config()
if self.config.has_key("apid"):
self._select_access_point(self.config["apid"])
# set extra handler to be called on each GPS loop
# self.scanner.set_extra_handler(self.loop)
# update our menu
self._update_menu()
self.draw_screen('ready!')
# self.debug(self.screen)
self.scanner_handler() # start scanning automatically
# set exit key handler
appuifw.app.exit_key_handler = self.exit_key_handler
# activate sensor if available
self.sensor.activate()
# call main loop
self.main()
class SissiApp:
__id__ = u'Sissi'
__version__ = u'0.1'
def __init__(self):
# app title
appuifw.app.title = u"Sissi"
# app lock
self.lock = e32.Ao_lock()
# ensure data dir exists
self.datadir = os.path.join(u"C:\\Data", u"Sissi")
if not os.path.exists(self.datadir):
os.makedirs(self.datadir)
# create a directory for temporary data
self.cachedir = u"D:\\Sissi"
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
# get screen resolution
self.screen = sysinfo.display_pixels()
# extra classes instantiated
self.scanner = Scanner(self)
self.netmapper = NetMapper(self)
self.map = Map(self)
self.cos_api = COSApi(self)
self.sensor = Activity(self)
# timers
self.t = e32.Ao_timer()
self.t2 = e32.Ao_timer()
self._timer = 0
self._interval = 15
self.active = False
# set canvas
self.activate()
# configuration / settings
self.draw_screen('reading config')
self.config_file = os.path.join(self.datadir, "settings.ini")
self.config = {} # TODO: read these from a configuration file
self.apid = None # Default access point
self.read_config()
if self.config.has_key("apid"):
self._select_access_point(self.config["apid"])
# set extra handler to be called on each GPS loop
# self.scanner.set_extra_handler(self.loop)
# update our menu
self._update_menu()
self.draw_screen('ready!')
# self.debug(self.screen)
self.scanner_handler() # start scanning automatically
# set exit key handler
appuifw.app.exit_key_handler = self.exit_key_handler
# activate sensor if available
self.sensor.activate()
# call main loop
self.main()
def main(self):
self.t2.cancel()
if self._timer > self._interval:
self._timer = 0
try:
if self.scanner.position.has_key("gps_data"): # first check whether we have a GPS position
self.cos_api.post(self.scanner.position["gps_data"]["lat"], self.scanner.position["gps_data"]["lon"])
# if map view is active load a new one
if self.map.active:
self.map.load(self.scanner.position["gps_data"]["lat"], self.scanner.position["gps_data"]["lon"])
elif self.scanner.position.has_key("wlan_data"): # if not then see if we have wlans in the latest scanned position
wlanlist = self.scanner.position["wlan_data"]["wlanlist"]
wlanlist.sort(lambda x, y: cmp(y['rxlevel'], x['rxlevel']))
if len(wlanlist) > 1:
self.netmapper.get_location(wlanlist) # fetching calculated location from OpenNetMap
if self.netmapper.computed_location["latitude"] and self.netmapper.computed_location["longitude"]:
self.cos_api.post(self.netmapper.computed_location["latitude"], self.netmapper.computed_location["longitude"])
# if map view is active load a new one
if self.netmapper.computed_location["latitude"] and self.netmapper.computed_location["longitude"] and self.map.active:
self.map.load(self.netmapper.computed_location["latitude"], self.netmapper.computed_location["longitude"])
elif self.scanner.position.has_key("gsm_data"):
# not yet implemented!!
pass
except:
pass
if self.sensor.SENSOR_AVAILABLE:
if self.sensor.activity > 5000: # we are moving
self._interval = 15
appuifw.note(u"sensor available, interval: "+str(self._interval), 'info')
else:
self._interval = 120
appuifw.note(u"sensor available, interval: "+str(self._interval), 'info')
else:
self._interval = 120
self._timer += 1
self.t2.after(1.0, self.main)
def debug(self,obj):
self.draw_screen(simplejson.dumps(obj))
def update(self, dummy=(0, 0, 0, 0)):
self.t.cancel()
text = self.get_canvas_text()
self.draw_screen(text)
if self.active:
self.t.after(1.0, self.update)
def get_canvas_text(self):
text = ""
if self.scanner.text != None:
text += self.scanner.text
if self.netmapper.text != None:
text += self.netmapper.text
if self.cos_api.text != None:
text += self.cos_api.text
if len(text) == 0:
text = "Waiting for location fix!"
else:
text += "\nUntil next COS update: "+str(self._timer)+"\n"
return text
def draw_screen(self,text):
self.canvas.clear()
line_height = y = 15
text = text.split("\n")
for line in text:
self.canvas.text((3, y), u""+line, font=(u"Series 60 Sans", 12), fill=0x333333)
y += line_height
def open_ossi(self):
path = u"e:\\python\\ossi.html"
c=appuifw.Content_handler()
c.open(path)
app_lock = e32.Ao_lock()
app_lock.wait()
appuifw.app.exit_key_handler = self.exit_key_handler
def _select_access_point(self, apid = None):
"""
Shortcut for socket.select_access_point()
TODO: save selected access point to the config
TODO: allow user to change access point later
"""
if apid is not None:
self.apid = apid
else:
access_points = socket.access_points()
sort_key = "iapid"
decorated = [(dict_[sort_key], dict_) for dict_ in access_points]
decorated.sort()
access_points = [dict_ for (key, dict_) in decorated]
ap_names = [dict_["name"] for dict_ in access_points]
ap_ids = [dict_["iapid"] for dict_ in access_points]
selected = appuifw.selection_list(ap_names, search_field=1)
#print selected, ap_names[selected], ap_ids[selected]
if selected is not None:
self.apid = ap_ids[selected]
if self.apid:
self.apo = socket.access_point(self.apid)
socket.set_default_access_point(self.apo)
self.config["apid"] = self.apid
self.save_config()
self._update_menu()
return self.apid
def _update_menu(self):
scanner_string = 'Start'
if self.__dict__.has_key("scanner"): # check that scanner has been initialized
if self.scanner.running:
scanner_string = 'Stop'
appuifw.app.menu = [
(u""+scanner_string+" scanner", self.scanner_handler),
(u"Show map", self.toggle_map),
# (u"Accelerometer view", self.toggle_accelerometer),
(u"Reset config", self.reset_config),
(u"About", lambda:appuifw.note("Sissi is OtaSizzle S60 daemon. Version: " + self.__version__ + "\n\nJ Turunen / HIIT", 'info')),
(u"Close", self.exit_key_handler),
]
def read_config(self):
data = {}
try:
f = open(self.config_file, "rt")
data = eval(f.read())
#data = f.read()
f.close()
except:
appuifw.note(u"Generating a settings file...", 'info')
# raise
# List here ALL POSSIBLE configuration keys, so they will be initialized
defaults = {
"scan_interval" : 20, # 6 minutes
"scan_interval_active" : 10, # 2 minutes
"otasizzle_username" : None,
"otasizzle_password" : None,
"cos_method" : u"http",
"cos_domain" : u"cos.alpha.sizl.org",
"cos_path" : u"/location/single_update",
"apid" : None,
"onm_url" : u"http://opennetmap.org/api/?operation=get_wlan_01&wlan_ids=",
"script" : u"/api/",
}
# List here all configuration keys, which must be defined before use
# If a config key has key "function", it's called to define value
# TODO: make some order for these
mandatory = {
"otasizzle_username" : {"querytext" : u"your OtaSizzle username",
"valuetype" : "text",
"default" : u'',
"canceltext" : u'username is mandatory!',
},
"otasizzle_password" : {"querytext" : u"your OtaSizzle password",
"valuetype" : "text",
"default" : u'',
"canceltext" : u'password is mandatory!',
},
"apid" : {"querytext" : u"Select default data connection!",
"valuetype" : "function",
"default" : u'',
"canceltext" : None,
"function" : self._select_access_point,
},
}
# Loop all possible keys (found from defaults)
for key in defaults.keys():
if data.has_key(key): # Use the value found from the data
defaults[key] = data[key]
elif mandatory.has_key(key) and defaults[key] is None: # Ask mandatory values from the user
value = None
if mandatory[key].has_key("function"): # if defined, call the "function"
appuifw.note(mandatory[key]["querytext"], 'info')
value = mandatory[key]["function"]() # "function" must return a value
else:
while value is None:
value = appuifw.query(mandatory[key]["querytext"],
mandatory[key]["valuetype"],
mandatory[key]["default"])
if value is None and mandatory[key]["canceltext"]:
appuifw.note(mandatory[key]["canceltext"], 'error')
elif value is None: # If canceltext is u"", change value None to u""
value = u""
defaults[key] = value
self.config = defaults
self.save_config()
def save_config(self):
f = open(self.config_file, "wt")
f.write(repr(self.config))
f.close()
def reset_config(self):
if appuifw.query(u'Are you sure you want to delete all settings?', 'query') is True:
os.remove(self.config_file)
appuifw.note(u"Done, now you need to restart Sissi!", 'info')
self.running = False
self.lock.signal()
appuifw.app.exit_key_handler = None
def scanner_handler(self):
if self.scanner:
if self.scanner.running:
self.scanner.stop()
else:
self.scanner.start()
self._update_menu()
def toggle_map(self):
if not appuifw.app.body == self.canvas:
self.map.active = False
self.activate()
else:
self.active = False
self.map.activate()
def activate(self):
self.active = True
appuifw.app.exit_key_handler = self.exit_key_handler
try:
self.canvas
except:
self.canvas = appuifw.Canvas(redraw_callback=self.update)
appuifw.app.body = self.canvas
self._update_menu()
def run(self):
self.lock.wait()
self.close()
def exit_key_handler(self):
if appuifw.query(u"Quit program", 'query') is True:
self.running = False
self.scanner.stop()
if self.map.active:
self.map.stop()
self.sensor.stop()
self.lock.signal()
def close(self):
# positioning.stop_position()
appuifw.app.exit_key_handler = None
self.running = False
def __init__(self) :
self.ledFrein = Output(Pin.led)
self.sensors = [Pin.pedaleFrein]
Activity.__init__(self, False)
def main():
address_old = 'localhost'
port_old = 27017
address_new = '123.56.65.17'
# address_new = 'localhost'
port_new = 27017
print("convert label type data")
# LabelType.insert_label_type(address_new, port_new)
print("convert weather data")
# Weather.convert_weather(address_old, port_old, address_new, port_new,
# Weather.collection_old, Weather.collection_new, Weather.params_map)
# 特别注意 weather_history 表依赖于当前的 weather 表
print("create weather_history data")
# WeatherHistory.create_weather_history(address_new, port_new, address_new, port_new,
# WeatherHistory.collection_old, WeatherHistory.collection_new, WeatherHistory.params_map)
print("convert pgc data")
# Pgc.convert_pgc(address_old, port_old, address_new, port_new,
# Pgc.collection_old, Pgc.collection_new, Pgc.params_map)
print("convert person data")
# Person.convert_person(address_old, port_old, address_new, port_new)
# 必须在 attraction 之前创建
print("create spot data")
# Spot.create_spot(address_old, port_old, address_new, port_new,
# Spot.collection_old, Spot.collection_new, Spot.params_map)
# 必须在 restaurant 之前创建
print("create dish data")
# Dish.create_dish(address_old, port_old, address_new, port_new,
# Dish.collection_old, Dish.collection_new, Dish.params_map)
# 必须在 shopping 之前创建
print("convert brand data")
# Brand.convert_brand(address_old, port_old, address_new, port_new,
# Brand.collection_old, Brand.collection_new, Brand.params_map)
# label的 id 依赖于 label 表
print("convert attraction data")
# Attraction.convert_attraction(address_old, port_old, address_new, port_new,
# Attraction.collection_old, Attraction.collection_new, Attraction.params_map)
# label的 id 依赖于 label 表
print("convert restaurant data")
# Restaurant.convert_restaurant(address_old, port_old, address_new, port_new,
# Restaurant.collection_old, Restaurant.collection_new, Restaurant.params_map)
# label的 id 依赖于 label 表
print("convert shopping data")
# Shopping.convert_shopping(address_old, port_old, address_new, port_new,
# Shopping.collection_old, Shopping.collection_new, Shopping.params_map)
# label 表依赖于 attraction、restaurant、shopping 表
print("convert label data")
# Label.convert_label(address_new, port_new)
# 需 在 poi 表之后处理
print("change poi label id")
# POILabelId.attraction_label(address_new, port_new)
# 城市表 依赖新导入的Label表，需保证City前导入Label
print("convert city data")
# City.convert_city(address_old, port_old, address_new, port_new)
print("convert activity data")
Activity.convert_activity(address_old, port_old, address_new, port_new,
Activity.collection_old, Activity.collection_new, Activity.params_map)
print("convert recommendInfo data")
# RecommendInfo.convert_recommend_info(address_old, port_old, address_new, port_new,
# RecommendInfo.collection_old, RecommendInfo.collection_new, RecommendInfo.params_map)
print("convert recommendHistory data")
# RecommendHistory.insert_recommend_history(address_new, port_new)
#
print("convert plan data")
# Plan.convert_plan(address_old, port_old, address_new, port_new,
# Plan.collection_old, Plan.collection_new, Plan.params_map)
print("OK")
def createActivity(label, weight, value, time):
newactivity = Activity(label, weight, value, time)
return newactivity
def __init__(self) :
self.state = False
self.led = Output(Pin.led)
self.sensors = [Pin.bouton]
Activity.__init__(self, True)
def main():
# Create some activities for testing:
actStart = Activity("Start", 0)
actA = Activity("A", 4)
actB = Activity("B", 5)
actC = Activity("C", 3)
actD = Activity("D", 4)
actE = Activity("E", 3)
actF = Activity("F", 6)
actG = Activity("G", 4)
actH = Activity("H", 4)
actEnd = Activity("End", 0)
tempActivity = Activity("temp", 5) # Just for testings
# Create first graph:
g = {
actStart: [actA],
actA: [actB, actC, actD],
actB: [actF],
actC: [actE],
actD: [actE],
actE: [actH],
actF: [actG],
actG: [actEnd],
actH: [actEnd],
actEnd: []
}
# Create another graph for testing:
withCircles = {
actStart: [actA],
actA: [actB, actC, actD],
actB: [actF],
actC: [actE],
actD: [actE],
actE: [actH],
actF: [actG],
actG: [actEnd, actH],
actH: [actEnd, actF],
actEnd: []
}
'''
Check all the questions from the home work.
'''
print(
"============================== Question 1 ==================================="
)
print("Initialize the project object - CPM_Network")
newGraph = CPM_Network(g)
print(
"=============================================================================\n"
)
print(
"============================== Question 2 ==================================="
)
print("Add activity to the project: %s, with the following activities %s" %
(actH, [actEnd]))
newGraph.addActivity(actH, [actEnd])
print(
"=============================================================================\n"
)
print(
"============================== Question 3 ==================================="
)
print("Add temporary activity i.e for testing:")
print("Add activity %s to the project, with the following activities %s" %
(tempActivity, [actEnd]))
newGraph.addActivity(tempActivity, [actEnd])
print(str(newGraph))
print("Removing the %s activity from the project" % tempActivity)
newGraph.removeActivity(tempActivity)
print(str(newGraph))
print(
"=============================================================================\n"
)
print(
"============================== Question 4 ==================================="
)
print("Using another project for the test:")
circles = CPM_Network(withCircles)
circles.validateProject()
print(
"=============================================================================\n"
)
print(
"============================== Question 5 ==================================="
)
isolatedActivities = newGraph.isolatedActivities()
print("The isolated activities in the project: \n%s" % isolatedActivities)
print(
"=============================================================================\n"
)
print(
"============================== Question 6 ==================================="
)
print(str(newGraph))
print(
"=============================================================================\n"
)
print(
"============================== Question 7 ==================================="
)
criticalPath, maximumDuration = newGraph.criticalPath()
print("The duration of the critical path is: %r" % maximumDuration)
print("The critical paths in the project: \n%s" % criticalPath)
print(
"=============================================================================\n"
)
print(
"============================== Question 8 ==================================="
)
newGraph.showSlackTime()
print(
"=============================================================================\n"
)
print(
"============================== Question 9 ==================================="
)
print("The project duration is: %r" % newGraph.duration)
print(
"=============================================================================\n"
)
def stop(self) :
Activity.stop(self)
