def notifications(self, from_date=None, to_date=None):
        if not to_date:
            to_date = date2str(datetime.utcnow())
            from_date = date2str(datetime.utcnow() - timedelta(days=7))
        poll_url = self.baseURL + "/SentNotifications/" + self.token + \
                   "?from=" + from_date + "&to=" + to_date
        print(poll_url)
        response = requests.get(poll_url)

        data = response.json().get("Result")
        print(len(data), json.dumps(data, indent=4))
        return data
    def sensor_data(self, sensor_id, from_date=None, to_date=None):
        if not to_date:
            to_date = date2str(datetime.utcnow())
            from_date = date2str(datetime.utcnow() - timedelta(days=7))

        poll_url = self.baseURL + "/SensorDataMessages/" + self.token + "?" +\
                   "sensorID=" + str(sensor_id) + "&fromDate=" + from_date + \
                   "&toDate=" + to_date
        response = requests.get(poll_url)
        data = None
        print(response.status_code, response.reason)
        if response.status_code == 200:
            data = response.json().get("Result")
            print(json.dumps(data, indent=4))
        return data
Beispiel #3
0
def save_segments(original_image, segments, image_saved_path):
    original_image = original_image.split(".")[0]
    output_names = []
    time = date2str()
    for k, segment in enumerate(segments):
        pil_object = Image.fromarray(segment.astype('uint8'), 'RGB')
        output_name = original_image + "segment{0}_{1}.jpg".format(k, time)
        output_names.append(output_name)
        pil_object.save(image_saved_path + output_name)
    return output_names
Beispiel #4
0
    def _async_select(self, sql, vals, inst=None, **kwargs):
        ret = []
        max_id = 0
        key_set = set()
        auto_convert = False
        account_max_id = False
        mk_timestamp = False
        set_key = None
        if kwargs.has_key("auto_convert"):
            auto_convert = kwargs["auto_convert"]
        if kwargs.has_key("account_max_id"):
            account_max_id = kwargs["account_max_id"]
        if kwargs.has_key("mk_timestamp"):
            mk_timestamp = kwargs["mk_timestamp"]
        if kwargs.has_key("set_key"):
            set_key = kwargs["set_key"]

        if not vals:
            vals = None

        if not inst:
            inst = self.get_mysql_inst(**kwargs)
        cursor = yield inst.execute(sql, vals)
        for row in cursor:
            tmp = {}
            for i in range(0, len(row)):
                colval = row[i]
                if auto_convert:
                    if isinstance(colval, datetime.date) or isinstance(
                            colval, datetime.datetime):
                        if mk_timestamp:
                            colval = utils.date2int(colval)
                        else:
                            colval = utils.date2str(colval)
                    elif isinstance(colval, float):
                        colval = str(colval)
                tmp[cursor.description[i][0]] = colval
                if account_max_id and cursor.description[i][
                        0] == "id" and colval > max_id:
                    max_id = colval
                if set_key and cursor.description[i][0] == set_key:
                    key_set.add(colval)

            ret.append(tmp)

        tmp_ret = [ret]
        if account_max_id:
            tmp_ret.append(max_id)
        if set_key:
            tmp_ret.append(key_set)
        if len(tmp_ret) > 1:
            raise gen.Return(tuple(tmp_ret))
        else:
            raise gen.Return(tmp_ret[0])
Beispiel #5
0
def save_masks(original_image, masks, image_saved_path):
    original_image = original_image.split(".")[0]
    output_names = []
    time = date2str()
    for k, mask in enumerate(masks):

        def img_frombytes(data):
            size = data.shape[::-1]
            databytes = np.packbits(data, axis=1)
            return Image.frombytes(mode='1', size=size, data=databytes)

        pil_object = img_frombytes(mask)
        output_name = original_image + "mask{0}_{1}.jpg".format(k, time)
        output_names.append(output_name)
        pil_object.save(image_saved_path + output_name)
    return output_names
Beispiel #6
0
def train(model, epochs, train_loader, val_loader=None, frequency=5):
    config = get_light_mask_rcnn_config()
    learning_rate = config['learning_rate']
    decay_param = config['decay_param']
    num_warmup_steps = config['num_warmup_steps']
    checkpoint_path = config['checkpoints']
    optimizer = AdamW(model.parameters(), lr=learning_rate, eps=1e-8)
    num_training_steps = len(train_loader) * epochs

    scheduler = get_linear_schedule_with_warmup(
        optimizer,
        num_warmup_steps=num_warmup_steps,
        num_training_steps=num_training_steps)

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    #device = torch.device("cpu")
    model.to(device)
    record = []
    for epoch in range(epochs):
        timestamp = date2str()
        metric_logger = train_one_epoch(model, optimizer, scheduler,
                                        train_loader, device, epoch, frequency,
                                        num_warmup_steps, True)
        record.append(metric_logger)
        if val_loader is not None:
            coco_evaluator = evaluate(model, val_loader, device)
            file_name = checkpoint_path + 'coco_evaluator_{0}.pkl'.format(
                timestamp)
            with open(file_name.format(timestamp), 'wb') as f:
                pickle.dump(coco_evaluator, f)
        if epoch % frequency == 0:
            save_checkpoint(
                {
                    'epoch': epoch,
                    'state_dict': model.state_dict(),
                    'optimizer': optimizer.state_dict(),
                    'scheduler': scheduler.state_dict(),
                },
                checkpoint_path,
                timestamp=timestamp)
            file_name = checkpoint_path + 'loss_{0}.pkl'.format(timestamp)
            with open(file_name.format(timestamp), 'wb') as f:
                pickle.dump(record, f)
    file_name = checkpoint_path + "resnet_101.pth"
    torch.save(model.state_dict(), file_name)
Beispiel #7
0
table = HtmlTable(border=1, cellpadding=3)

# table header
header = ['#',
          '<a href= "main2.py?order_by=title">Title</a>',
          '<a href= "main2.py?order_by=author">Author</a>',
          '<a href= "main2.py?order_by=notes">Notes</a>',
          '<a href= "main2.py?order_by=when_read">Date</a>']
table.addHeader(header)

# table body
i = 0
for (book_id, title, author, notes, when_read) in results:
    i += 1
    href = '<a href="detail.py?book_id=%d">%s' % (book_id, title)
    date = '<nobr>%s</nobr>' % date2str(when_read)
    table.addRow([i, href, author, notes, date])

# Output HTML
print 'Content-Type: text/html\n'

print "<html>"
print """
<head>
<title> Read A Book! </title>
<link href="css/main.css" rel="stylesheet" type="text/css">
</head>"""

print "<body>"
print "<h3>Books, Authors, and Notes</h3>"
Beispiel #8
0
    if value == None:
        value= 'Unknown'

    #Special Handeling for binary field published
    if key =='published':
        key = 'Published'
    if key == 'Published' and value == 1:
        value = 'Yes'
    if key == 'Published' and value == 0:
        value = 'No'
    
    #Special handeling for date output
    if key == 'when_read':
        key= 'Date Read'
        value =date2str(value)
    
#    form +='''<br>
#    %s: <input type = "textfield" name = "entry" value = "%s"><br>
#    '''% (key, value)

    if key == 'title':
        key = 'Title'
        form += '''<br>
        %s: <input type = "textfield" name = "entry" value = "%s"><br>
        '''% (key, value)

    if key == 'last_name':
        key = 'Author Last Name'
        form += '''<br>                                                      
        %s: <input type = "textfield" name = "entry" value = "%s">  
Beispiel #9
0
def	__doc_acu(request, id, mode):
	'''
	Anon/Create/Update
	:param id:int - uuid (anon/create) or doc id (update)
	:param mode:int (0: anon (print), 1: create, 2: update)
	'''
	__log_request(request)
	if (mode == 2):
		item = models.Doc.objects.get(pk=id)	# Update only
		uuid = item.type
		if (uuid not in moduledict):
			return 'Template not found'
	else:
		uuid = id
	if (request.method == 'POST') and (mode > 0) and (request.POST.get('_action', None) in set(('print', 'view'))):
		mode = 0
	tpl = moduledict[uuid]
	# 1. check <pkg>.ANON/CREATE/UPDATE
	self_func = [K_T_F_ANON, K_T_F_ADD, K_T_F_EDIT][mode]
	if (self_func in tpl[K_V_MODULE].__dict__):
		return tpl[K_V_MODULE].__dict__[self_func](request, id)
	# else:
	# 2. get FORM and FORMSETS
	formclass = tpl[K_T_FORM]
	formsetsclass = tpl[K_T_FORMSETS]	# SortedDict of dicts
	if request.method == 'POST':
		#pprint.pprint(request.POST['_action'])
		form = formclass(request.POST)
		if (mode == 0):	# ANON, Create/Update -> view/print
			del form.fields[K_T_F_NAME]
		formlist = SortedDict()
		isvalid = form.is_valid()
		for k, formset in formsetsclass.iteritems():
			formlist[k] = formset(request.POST, prefix=k)
			isvalid = isvalid and formlist[k].is_valid()
		if isvalid:
			data = form.cleaned_data
			# inject formsets into data
			for k, v in formlist.iteritems():
				dataset = list()
				for i in v.cleaned_data:	# list of dicts
					if i:			# reject empty dicts
						dataset.append(i)
				if dataset:			# reject empty lists
					data[k] = dataset	# inject datasets into data
			__try_to_call(tpl, K_T_F_POST_FORM, data)
			# split
			if (mode == 0):		# ANON > PRINT, C/U -> V/P
				if ((K_T_T in tpl[K_V_MODULE].DATA) and (K_T_T_PRINT in tpl[K_V_MODULE].DATA[K_T_T])):
					context_dict = {'data': data}
					template = tpl[K_V_MODULE].DATA[K_T_T][K_T_T_PRINT]
					if (request.POST.get('_action', None) == u'view'):
						__try_to_call(tpl, K_T_F_PRE_VIEW, data)	# Create/Update -> View
						return converter.html2html(request, context_dict, template)
					else:			# Anon/Create/Update -> PRINT
						__try_to_call(tpl, K_T_F_PRE_PRINT, data)
						return __doc_print(request, context_dict, template)
				else:	# tmp dummy
					return redirect('dox.views.index')
			else:	# CREATE/UPDATE -> SAVE
				if (mode == 1):	# CREATE
					name = data[K_T_F_NAME]
				else:
					item.name = data[K_T_F_NAME]
				del data[K_T_F_NAME]
				# convert dates
				if (K_V_DATES in tpl):
					for k in tpl[K_V_DATES]:
						utils.date2str(data, k)
				__try_to_call(tpl, K_T_F_PRE_SAVE, data)
				if (mode == 1):	# CREATE
					# user, type, name, data
					item = models.Doc(user=request.user, type=uuid, name=name, data=json.dumps(data, indent=1, ensure_ascii=False))
				else:
					item.data = json.dumps(data, indent=1, ensure_ascii=False)
				item.save()
				return redirect(doc_r, id=item.pk)
	else:	# GET
		if (mode < 2):		# ANON, CREATE
			form = formclass()
			if (mode == 0):	# ANON
				del form.fields[K_T_F_NAME]
			formlist = SortedDict()
			for k, formset in formsetsclass.iteritems():
				formlist[k] = formset(prefix=k)
		else:			# UPDATE
			data = json.loads(item.data)
			data[K_T_F_NAME] = item.name				# inject name
			# restore dates after loading
			if (K_V_DATES in tpl):
				for k in tpl[K_V_DATES]:
					utils.str2date(data, k)
			#pprint.pprint(data)
			__try_to_call(tpl, K_T_F_POST_LOAD, data)
			#pprint.pprint(data)
			__try_to_call(tpl, K_T_F_PRE_FORM, data)
			# split form and formsets
			# 1. eject formsets
			formlist = SortedDict([])
			for pfx, formset in formsetsclass.iteritems():		# formsetsclass == SortedDict {name: FormSetClass}
				formset_data = dict()
				for i, l in enumerate(data.get(pfx, list())):	# l:str - formset name; l:
					for k, v in l.iteritems():
						formset_data[pfx+'-'+str(i)+'-'+k] = v
				formset_data.update({
					pfx+'-TOTAL_FORMS': len(data[pfx]) if pfx in data else 1,
					pfx+'-INITIAL_FORMS': u'0',
					pfx+'-MAX_NUM_FORMS': u'',
				})
				formlist[pfx] = formset(formset_data, prefix=pfx)
				if (pfx in data):
					del data[pfx]
			# 2. else
			form = formclass(data)
	return render_to_response(
		tpl[K_V_MODULE].DATA[K_T_T][K_T_T_FORM] if ((K_T_T in tpl[K_V_MODULE].DATA) and (K_T_T_FORM in tpl[K_V_MODULE].DATA[K_T_T])) else 'auto_form.html',
		context_instance=RequestContext(request, {
			'name': tpl[K_V_MODULE].DATA[K_T_NAME],
			'comments': tpl[K_V_MODULE].DATA[K_T_COMMENTS],
			'legend': tpl[K_V_MODULE].DATA.get(K_T_LEGEND, ''),
			'uuid': tpl[K_V_MODULE].DATA[K_T_UUID],
			'form': form,
			'formlist': formlist,
			'example': tpl[K_V_MODULE].DATA.get('example', None),
		}))