def post(self, uid):
try:
body = json.loads(self.request.body)
pid = body.get('pin_id')
content = body.get('content')
image = body.get('image')
title = body.get('title')
caption = body.get('caption')
private = body.get('private', False)
if pid is None and content is None:
raise KeyError
except (KeyError, ValueError, TypeError):
self.send_error(httplib.BAD_REQUEST)
return
try:
pin = yield Pin.fetch(guid=pid, content=content)
except KeyError:
if not content:
self.send_error(httplib.NOT_FOUND)
return
pin = Pin(content, image, title)
yield pin.save()
userpin = UserPin(uid, pin, caption, private)
yield userpin.save()
self.write(self.application.userpin_representation(userpin))
self.set_status(httplib.CREATED)
def __init__(self):
self.board = "na-satbus-3c0-gcc"
self.arch = "ARM"
self.cpu = "stm32f405"
self.binfiletype = "ELF"
self.pins = {
'rst': Pin(name='rst', number=17),
'pwr': Pin(name='pwr', number=27)
}
def __init__(self, pin1, pin2):
self.pin1 = pin1
self.pin2 = pin2
io.setmode(io.BCM)
io.setup(pin1, io.OUT)
io.setup(pin2, io.OUT)
self.Pin1 = Pin(pin1)
self.Pin2 = Pin(pin2)
def __init__(self):
for code in self.OUTPUT_PINS:
pin = Pin(code, code in self.STARTING_HIGH, self, True)
setattr(self, 'pin_{}'.format(pin.code), pin)
for code in self.INPUT_PINS:
pin = Pin(code, code in self.STARTING_HIGH, self)
setattr(self, 'pin_{}'.format(pin.code), pin)
self.vcc = Pin('VCC', True, self)
self.update()
def test_pin_multiple(self):
p1 = Pin()
p1.id = '400'
p2 = Pin()
p2.id = '500'
self.assertTrue(p1.id.value == '400')
self.assertTrue(p2.id.value == '500')
def __init__(self, *args, **kwargs):
for code in self.OUTPUT_PINS:
pin = Pin(code, code in self.STARTING_HIGH, self, True)
setattr(self, 'pin_{}'.format(pin.code), pin)
for code in self.INPUT_PINS:
pin = Pin(code, code in self.STARTING_HIGH, self)
setattr(self, 'pin_{}'.format(pin.code), pin)
self.vcc = Pin('VCC', True, self)
self.update()
self.leds = {pin.code: LED(self.vcc, pin) for pin in self.getpins(self.INPUT_PINS)}
def __init__(self):
self.board = "msp430f5529-gcc"
self.arch = "MSP430"
self.cpu = "msp430f5529"
self.binfiletype = "ELF"
self.pins = {
'rst' : Pin(name = 'rst', number = 17),
'pwr' : Pin(name = 'pwr', number = 27),
'opt' : Pin(name = 'opt', number = 22) # optional
}
def __init__(self):
self.board = "stm32f407-disco-gcc"
self.arch = "ARM"
self.cpu = "stm32f407"
self.binfiletype = "ELF"
self.pins = {
'rst' : Pin(name = 'rst', number = 17),
'pwr' : Pin(name = 'pwr', number = 27),
'opt' : Pin(name = 'opt', number = 22) # optional
}
def __init__(self, directionIO, stepIO):
self.directionIO = Pin(directionIO, 'OUT')
self.stepIO = Pin(stepIO, 'OUT')
self.direction = False
self.velocity = DEFAULT_VELOCITY
self.default_wait = DEFAULT_WAIT
self.position = 0
self.turn = DEFAULT_POSITION_STEP
def __init__(self):
self.board = "pyboard-gcc"
self.arch = "ARM"
self.cpu = "stm32f405"
self.binfiletype = "BIN"
self.pins = {
'rst' : Pin(name = 'rst', number = 17),
'pwr' : Pin(name = 'pwr', number = 27),
'prg' : Pin(name = 'prg', number = 18),
'opt' : Pin(name = 'opt', number = 22)
}
def __init__(self, *args, **kwargs):
self.value = 0
self.prev_clock_high = False
for code in self.OUTPUT_PINS:
pin = Pin(code, code in self.STARTING_HIGH, self, True)
setattr(self, 'pin_{}'.format(pin.code), pin)
for code in self.INPUT_PINS:
pin = Pin(code, code in self.STARTING_HIGH, self)
setattr(self, 'pin_{}'.format(pin.code), pin)
self.vcc = Pin('VCC', True, self)
self.update()
def __init__(self):
# input/output pins:
self.__a = Pin()
self.__x = Pin()
# components
self.__nand1 = Nand()
# connections:
self.__connection1 = Connection(
[self.__a, self.__nand1.b, self.__nand1.a])
self.__connection2 = Connection([self.__x, self.__nand1.x])
class Motor:
def __init__(self, directionIO, stepIO):
self.directionIO = Pin(directionIO, 'OUT')
self.stepIO = Pin(stepIO, 'OUT')
self.direction = False
self.velocity = DEFAULT_VELOCITY
self.default_wait = DEFAULT_WAIT
self.position = 0
self.turn = DEFAULT_POSITION_STEP
def set_direction(self, direction):
if direction == "F":
self.direction = True
else:
self.direction = False
self.directionIO.set_state(self.direction)
def step(self, counter, direction):
self.set_direction(direction)
self.do_step(counter)
def do_step(self, counter):
while counter > 0:
self.send_step()
counter -= 1
def send_step(self):
self.stepIO.send_signal()
self.wait_time()
def wait_time(self):
time.sleep(self.default_wait / self.velocity)
def next_position(self):
self.step(self.turn, "F")
self.position += 1
def back_position(self):
self.step(self.turn, "B")
self.position -= 1
def move_to(self, destination):
if destination != self.position:
if destination > self.position:
self.next_position()
else:
self.back_position()
self.move_to(destination)
class Motor(object):
def __init__(self, pin1, pin2):
self.pin1 = pin1
self.pin2 = pin2
io.setmode(io.BCM)
io.setup(pin1, io.OUT)
io.setup(pin2, io.OUT)
self.Pin1 = Pin(pin1)
self.Pin2 = Pin(pin2)
def drive_forward(self):
io.output(self.pin1, io.HIGH)
io.output(self.pin2, io.LOW)
def drive_back(self):
io.output(self.pin1, io.LOW)
io.output(self.pin2, io.HIGH)
def stop(self):
io.output(self.pin1, io.LOW)
io.output(self.pin2, io.LOW)
def drive(self, speed=0.0):
if speed >= 0.0:
self.Pin1.output(speed)
self.Pin2.output(0)
else:
self.Pin1.output(0)
self.Pin2.output(abs(speed))
def suggestion(request):
if request.is_ajax() and request.method=='GET':
try:
user_id = request.GET['user_id']
except KeyError:
return HttpResponse(dumps({'status':'ERR', 'data':'No user id'}, cls=MyEncoder), mimetype='application/json')
u=User(user_id)
try:
if re.search('[^a-zA-Z0-9_]',user_id):
raise NotFound
pin_list=u.getToRepin(10)
u.saveDB()
except NotFound:
return HttpResponse(dumps({'status':'ERR', 'data':'Wrong name, nobody have this name on pinterest'}, cls=MyEncoder), mimetype='application/json')
if not pin_list:
print 'not_pinlist'
pin_list=[Pin.modelToPin(p) for p in random.sample(PinModel.objects.all(),10)]
res = {'status':'OK', 'data':{'pin_list':pin_list,'user':u}, }
return HttpResponse(dumps(res, cls=MyEncoder), mimetype='application/json')
else:
FB_INFO['meta']=None
return render_to_response('map/suggestion.html', {'fb_info':FB_INFO,})
def get(self, pid):
try:
pin = yield Pin.fetch(guid=pid)
except KeyError:
self.send_error(httplib.NOT_FOUND)
return
self.write(self.application.pin_representation(pin))
def generate_pins(self):
self.fetch_pin_constants()
for pin_name in self.pin_data:
pin_number = self.pin_data[pin_name]["number"]
pin_node = self.pin_data[pin_name]["node"]
pin_is_input = self.pin_data[pin_name]["is_input"]
pin = Pin(pin_node, self, pin_is_input, pin_name, pin_name)
self.pins[pin_name] = pin
def test_pin_full_example(self):
p = Pin()
action = Action()
action.launch_code = 13
action.title = 'Open in Watchapp'
action.type = 'openWatchApp'
self.assertDoesNotRaise(ValidationException, action.validate)
p.add_action(action)
reminder = Reminder()
reminder.time = '2015-08-04T20:00:00+00:00Z'
reminder.layout.backgroundColor = '#FFFFFF'
reminder.layout.body = 'Drama about a police unit...'
reminder.layout.foregroundColor = '#000000'
reminder.layout.largeIcon = 'system://images/TV_SHOW'
reminder.layout.smallIcon = 'system://images/TV_SHOW'
reminder.layout.tinyIcon = 'system://images/TV_SHOW'
reminder.layout.subtitle = 'New Tricks'
reminder.layout.title = 'Last Man Standing'
reminder.layout.type = 'genericReminder'
self.assertDoesNotRaise(ValidationException, reminder.validate)
p.add_reminder(reminder)
p.layout.backgroundColor = '#FFFFFF'
p.layout.foregroundColor = '#000000'
p.layout.tinyIcon = 'system://images/TV_SHOW'
p.layout.title = 'Last Man Standing'
p.layout.subtitle = 'New Tricks'
p.layout.type = 'genericPin'
p.layout.shortTitle = 'Last Man Standing'
p.layout.body = 'Drama about a police unit...'
p.layout.add_section('Series', 'New Tricks')
self.assertDoesNotRaise(ValidationException, p.layout.validate)
p.duration = 60
p.id = '101'
p.time = '2015-08-04T20:00:00+00:00Z'
self.assertDoesNotRaise(ValidationException, p.validate)
p.time = ''
self.assertRaises(ValidationException, p.validate)
def test_pin_json(self):
p = Pin()
p.layout.add_section('Hello', 'Goodbye')
data = p.json()
self.assertTrue(len(data['layout']['headings']) == 1)
self.assertTrue(len(data['layout']['paragraphs']) == 1)
self.assertTrue(data['layout']['headings'][0] == 'Hello')
self.assertTrue(data['layout']['paragraphs'][0] == 'Goodbye')
p.layout.add_section('Goodbye', 'Hello')
data = p.json()
self.assertTrue(len(data['layout']['headings']) == 2)
self.assertTrue(len(data['layout']['paragraphs']) == 2)
self.assertTrue(data['layout']['headings'][0] == 'Hello')
self.assertTrue(data['layout']['paragraphs'][0] == 'Goodbye')
self.assertTrue(data['layout']['headings'][1] == 'Goodbye')
self.assertTrue(data['layout']['paragraphs'][1] == 'Hello')
def fetch(cls, user_id, pin_id):
cursor = yield cls.db_pool().execute("SELECT caption, private, modified FROM userpin WHERE user_id=%s AND pin_id=%s", (user_id, pin_id))
if cursor.rowcount != 1:
cursor.close()
raise KeyError
row = cursor.fetchone()
cursor.close()
pin = yield Pin.fetch(guid=pin_id)
userpin = cls(user_id, pin, row[0], row[1], row[2])
userpin._stored = True
raise gen.Return(userpin)
def cb(obj, event):
nonlocal first_time_usage
if event == lv.EVENT.RELEASED:
c = obj.get_active_btn_text()
if c is None:
return
if c == lv.SYMBOL.CLOSE:
pin_lbl.set_text("")
antiphish_label.set_text(antiphishing_word(""))
elif c == lv.SYMBOL.OK:
# FIXME: check PIN len
Key.generate_key(pin_lbl.get_text())
if first_time_usage:
Secret.save_secret(alert)
callback()
else:
Pin.counter -= 1
Pin.save_counter(alert)
if Pin.is_pin_valid():
Pin.reset_counter(alert)
callback()
else:
instruct_label.set_text(
"#f07070 Wrong pin: %d/%d #" %
(Pin.counter, Pin.ATTEMPTS_MAX))
if Pin.counter <= 0:
Factory_settings.restore(alert)
Secret.generate_secret()
alert("Security", "Device has been factory reset!")
first_time_usage = True
title_lbl.set_text(first_time_title)
instruct_label.set_text(instruct_txt)
pin_lbl.set_text("")
antiphish_label.set_text(antiphishing_word(""))
else:
instruct_label.set_text(instruct_txt)
pin_lbl.add_text(c)
word = antiphishing_word(pin_lbl.get_text())
antiphish_label.set_text(antiphish_label.get_text() + " " +
word)
def test_pin_simple(self):
p = Pin()
p.id = '400'
p.time = '2012-10-06T04:13:00+00:00Z'
p.duration = 200
self.assertTrue(isinstance(p.id, StringField))
self.assertTrue(p.id.value == '400')
self.assertRaises(ValidationException, p.validate)
p.layout.type = PIN_LAYOUTS['GENERIC']
p.layout.title = 'Hello World!'
p.layout.body = 'Hello'
p.layout.tinyIcon = ICONS['MISC']['SHOW']
p.validate()
self.assertDoesNotRaise(ValidationException, p.validate)
p.layout.foregroundColor = '0xdeadbeef'
self.assertRaises(ValidationException, p.validate)
p.layout.foregroundColor = COLOURS['INCH_WORM']
p.layout.add_section('Hello', 'World')
self.assertDoesNotRaise(ValidationException, p.validate)
def __init__(self, IN1, IN2, IN3, IN4, timeout):
self.P1 = Pin(IN1, Pin.OUT)
self.P2 = Pin(IN2, Pin.OUT)
self.P3 = Pin(IN3, Pin.OUT)
self.P4 = Pin(IN4, Pin.OUT)
self.P1.value(0)
self.P2.value(0)
self.P3.value(0)
self.P4.value(0)
self.timeout = timeout
self.stop = False
self.turning = False
self.command = None
self.loop_running = False
def list_for_user(cls, user_id, limit=None):
userpins = []
# TODO: replace this with a join, but to do that need to know internals of pin table...
cursor = yield cls.db_pool().execute("SELECT caption, private, modified, pin_id FROM userpin WHERE user_id=%s", (user_id,))
cursor.arraysize = min(cursor.rowcount, limit or cursor.rowcount)
rows = cursor.fetchmany()
for row in rows:
pid = row[3]
try:
pin = yield Pin.fetch(guid=pid)
except KeyError:
Log.warning('Userpin record references Pin record that isn\'t in DB, user={}, pin={}'.format(user_id, pid))
continue
userpins.append(cls(user_id, pin, row[0], row[1], row[2]))
raise gen.Return(userpins)
def savematch(request): if request.is_ajax() and request.method == 'POST': try: pin1_id = request.POST['pin1_id'] pin2_id = request.POST['pin2_id'] choice = request.POST['choice'] pin1 = PinModel.objects.get(pin_id=pin1_id) pin2 = PinModel.objects.get(pin_id=pin2_id) pin1.score, pin2.score = Pin.getNewScore(pin1.score, pin2.score, pin1_id == choice) pin1.save() pin2.save() try: # Save the match history if the user is logged with facebook fb_id = request.POST['fb_id'] if fb_id == 'null': raise KeyError fb_user = SocialUserModel.objects.get_or_create(social_id=fb_id, net_name="facebook")[0] pin1_perso = fb_user.pinpersomodel_set.get_or_create(pin=pin1)[0] pin2_perso = fb_user.pinpersomodel_set.get_or_create(pin=pin2)[0] pin1_perso.score, pin2_perso.score = Pin.getNewScore(pin1_perso.score, pin2_perso.score, pin1_id == choice) pin1_perso.save() pin2_perso.save() except KeyError: pass request.session.modified = True request.session['match_list'].append((pin1.pin_id, pin2.pin_id, choice)) msg = "OK" return HttpResponse(msg) except KeyError, PinModel.DoesNotExist: msg = "Pin not found" return HttpResponse(msg)
def profile(user):
dbgp(user)
profile_img = user.profile_image_url
profile_bg_img = user.profile_banner_url
profile_bio = default_str_new_line(user.description)
profile_location = default_str_new_line(user.location)
profile_stats = [user.statuses_count, user.friends_count, user.followers_count]
profile_mapping = ["Tweets", "Following", "Followers"]
profile_stats_text = ""
for (i, stat) in enumerate(profile_stats):
profile_stats_text += "{} {},".format(stat, profile_mapping[i])
if profile_stats_text:
profile_stats_text = profile_stats_text[:-1] + "\n"
profile_elem = (profile_img, profile_bg_img, profile_stats, profile_bio, profile_location)
content = profile_bio + profile_location + profile_stats_text
return profile_elem, Pin(profile_url = profile_img, content = content)
def insert_all_pins_or_boards(all_data, class_name):
counter = 0
for index, item in enumerate(all_data):
counter += 1
data = json.loads(item)
if class_name == "pin":
if store.get(Pin, data['id']) is None:
store.add(Pin(data))
elif class_name == "board":
if store.get(Board, data['id']) is None:
store.add(Board(data))
if counter == MAX_INMEMORY:
store_to_db()
counter = 0
store_to_db()
class Car(object):
"""
Control of our lego buggy via left, right and gas pins
"""
def __init__(self):
self.left = ExclusivePin(17, None)
self.right = ExclusivePin(14, self.left)
self.gas = Pin(0)
self.left.xpin = self.left
def turn(self, s, is_left, angle=0.05):
first = self.left if is_left else self.right
second = self.right if is_left else self.left
first.drive(angle)
end = time.time() + s
while time.time() < end:
sleep(0.25)
first.drive(angle/10)
second.drive(angle)
def turn_left(self, s):
self.turn(s, True)
def turn_right(self, s):
self.turn(s, False)
def rev(self, s=0.4):
self.gas.drive(s)
def start(self, wait=None):
self.gas.on()
if wait:
sleep(wait)
def pause(self, s):
self.stop()
sleep(s)
self.start()
def stop(self):
self.gas.off()
def all_stop(self):
self.stop()
self.left.off()
self.right.off()
def test_output_zero(self):
p24 = Pin(24)
p24.output(0)
self.assertEqual(p24.value, 0.0)
self.assertTrue(p24._stopped)
def get(self):
limit = self.get_argument('limit', None)
pins = yield Pin.list(limit)
self.write({pin.guid: self.application.pin_representation(pin) for pin in pins})
def test_output_one(self):
p24 = Pin(24)
p24.output(1)
self.assertEqual(p24.value, 1.0)
self.assertTrue(p24._stopped)
def __init__(self):
self.left = ExclusivePin(17, None)
self.right = ExclusivePin(14, self.left)
self.gas = Pin(0)
self.left.xpin = self.left
def test_output_zero(self):
p24 = Pin(24)
p24.output(0)
self.assertEqual(p24.value, 0.0)
self.assertTrue(p24._stopped)
def test_output(self):
p24 = Pin(24)
p24.output(.5)
self.assertEqual(p24.value, 0.5)
class Buzzer:
def __init__(self):
self.pin = Pin(Board.BUZZ_PIN)
def execWarningSound(self):
self.pin.data(1)
time.sleep(0.2)
self.pin.data(0)
time.sleep(0.4)
self.pin.data(1)
time.sleep(0.4)
self.pin.data(0)
time.sleep(0.4)
self.pin.data(1)
time.sleep(0.6)
self.pin.data(0)
time.sleep(0.4)
def serverReadySound(self):
for i in range(1, 6):
self.pin.data(1)
time.sleep(0.1)
self.pin.data(0)
time.sleep(0.1)
class PinSet:
def __init__(self, enable, pin1, pin2):
self._enable = Pin(enable, GPIO.OUT)
self._pin1 = Pin(pin1, GPIO.OUT)
self._pin2 = Pin(pin2, GPIO.OUT)
def get_enable_number(self):
return self._enable.get_pin_number()
def get_pin1_number(self):
return self._pin1.get_pin_number()
def get_pin2_number(self):
return self._pin2.get_pin_number()
def get_all_pin_numbers(self):
return self._enable.get_pin_number(), self._pin1.get_pin_number(), \
self._pin2.get_pin_number()
def get_enable_val(self):
return self._enable.get_pin_value()
def get_pin1_val(self):
return self._pin1.get_pin_value()
def get_pin2_val(self):
return self._pin2.get_pin_value()
def get_all(self):
return self._enable.get_pin_value(), self._pin1.get_pin_value(), \
self._pin2.get_pin_value()
def set_enable_val(self, val):
self._enable.set_pin_value(val)
def set_pin1_val(self, val):
self._pin1.set_pin_value(val)
def set_pin2(self, val):
self._pin2.set_pin_value(val)
def set_all(self, enable, pin1, pin2):
self._enable.set_pin_value(enable)
self._pin1.set_pin_value(pin1)
self._pin2.set_pin_value(pin2)
def __init__(self):
# input pins
self.a = Pin()
self.b = Pin()
# output pins
self.x = Pin()
def test_output(self):
p24 = Pin(24)
p24.output(.5)
self.assertEqual(p24.value, 0.5)
def __init__(self, enable, pin1, pin2):
self._enable = Pin(enable, GPIO.OUT)
self._pin1 = Pin(pin1, GPIO.OUT)
self._pin2 = Pin(pin2, GPIO.OUT)
def get_tweets_api(twitter_id, dtos, api):
dbgpi("Getting tweets for {}".format(twitter_id))
# get profile contents
profile_elem = None
user = api.GetUser(screen_name=twitter_id)
profile_elem, profile_pin = profile(user)
profile_img, profile_bg_img, profile_stats, profile_bio, profile_location = profile_elem
# activities
# TODO: indicates profile in activities
# Or always has profile at 0th index
# and other activities for e.g next page
# starting at 1th index
acts = [profile_pin]
# TODO : Get all tweets for days
timeline = api.GetUserTimeline(screen_name=twitter_id, count=number_of_tweets)
tweets = []
for tweet in timeline:
tweets.append(str(tweet))
dbgp(tweet)
replies = ()
author = () # (screen_name, profile_image_url)
# favor whatever url it has
urls = None
medias = None
profile_name = ""
profile_url = ""
created_at = tweet.created_at
relations = []
if tweet.retweeted_status: # retweet has to pull different stuff
dbgp("Retweeting")
rt = tweet.retweeted_status
profile_name = tweet.user.screen_name
profile_url = rt.user.profile_image_url
medias = rt.media
# TODO: medias on all these
elif tweet.quoted_status:
dbgp("Quote status")
qt = tweet.quoted_status
profile_name = tweet.user.screen_name
profile_url = qt.user.profile_image_url
medias = qt.media
else:
dbgp("Not Retweeting")
profile_name = tweet.user.screen_name
profile_url = tweet.user.profile_image_url
medias = tweet.media
urls = [status_link.format(profile_name, tweet.id)]
media_urls = []
if medias:
for media in medias:
media_url = [media.type, media.media_url]
media_url.append(media.media_url)
# TODO: Confirm gif saved as mp4 ?
if media.type == "video" or media.type == "animated_gif":
video_url = media.video_info["variants"][-1]["url"]
dbgp("video {}".format(video_url))
media_url = ["video", media.media_url, video_url]
media_urls.append(media_url)
content = "@" + profile_name
if tweet.in_reply_to_screen_name: # not replying to self
dbgp("Replying to {}".format(tweet.in_reply_to_screen_name))
content += " replies to @" + tweet.in_reply_to_screen_name
if not urls:
dbgp("Reconstructing urls:")
urls = [status_link.format(tweet.in_reply_to_screen_name, tweet.in_reply_to_status_id)]
elif tweet.quoted_status: # TODO: Refactor these
content += " (quoted @" + tweet.quoted_status.user.screen_name + ": \"" + tweet.quoted_status.text + "\")"
content += " : " + tweet.text
dbgp(("final_urls:", urls))
# TODO: relation
acts.append(Pin(profile_name, profile_url, created_at, content, urls, media_urls))
if debug:
with open(twitter_id + ".json", "w") as json_file:
json_dict = {}
json_dict["profile_img"] = profile_img
json_dict["profile_bg_img"] = profile_bg_img
json_dict["profile_stats"] = profile_stats
json_dict["profile_bio"] = profile_bio
json_dict["profile_location"] = profile_location
json_dict["acts"] = [json.dumps(dataclasses.asdict(act)) for act in acts]
json_dict["tweets"] = tweets
json.dump(json_dict, json_file, indent=4)
dtos[twitter_id] = (profile_elem, acts)
dbgpi("Finished getting tweets for {}".format(twitter_id))
return dtos
def ranking(request):
if request.is_ajax() and request.method == 'GET':
try:
cat = request.GET['category']
try:
if cat == 'all':
ranking_q = PinModel.objects.all()
else:
cat_model = CategoryModel.objects.get(category_id=cat)
ranking_q = cat_model.pinmodel_set.all()
except CategoryModel.DoesNotExist:
d = {'status': 'ERR', 'data':'This category does not exist on the database '}
data = dumps(d, cls=MyEncoder)
return HttpResponse(data, mimetype='application/json')
except KeyError:
ranking_q = PinModel.objects.all()
# Personal ranking
if request.GET['perso'] == u'true':
info_open_graph = []
try:
# Db-based personal ranking (only if the user is logged in with Facebook)
fb_id = request.GET['fb_id']
#access_token=request.GET['access_token']
if fb_id == 'null':
raise KeyError
fb_u = SocialUserModel.objects.get_or_create(social_id=fb_id, net_name="facebook")[0]
pin_id_list = [p.pin_id for p in ranking_q]
pin_list = fb_u.pinpersomodel_set.order_by('-score').filter(pin__pin_id__in=pin_id_list)
ranking_list = fun.group(lambda p: p.score, pin_list)
ranking_list = [[e.pin for e in sub] for sub in ranking_list ]
if ranking_list:
nb=3 # Number of pin to post on facebook
if len(ranking_list[0])>3:
to_post=random.sample(ranking_list[0],nb)
else:
to_post=pin_list[:3]
for p in to_post:
p_url = 'http://'+request.get_host() + '/pin?pin_id=' + p.pin_id
info_open_graph.append({'fb_id':fb_id, 'action':'vote for', 'obj':'pin', 'obj_url':p_url})
except KeyError:
# Cookie-based personal ranking
match_list = request.session['match_list']
score = {}
for t in match_list:
pin1, pin2, choice = t
score.setdefault(pin1, 0)
score.setdefault(pin2, 0)
score[pin1], score[pin2] = Pin.getNewScore(score[pin1], score[pin2], choice == pin1)
ranking_list = list(ranking_q.filter(pin_id__in=score.keys()))
ranking_list.sort(key=lambda pin:-score[pin.pin_id])
ranking_list = fun.group(lambda p: p.score, ranking_list)
if len(ranking_list) > 0:
data = dumps({'status':'OK', 'data':{'ranking_list':ranking_list, 'info_open_graph':info_open_graph}}, cls=MyEncoder)
return HttpResponse(data, mimetype='application/json')
else:
d = {'status': 'ERR', 'data':'No pins in this category'}
data = dumps(d, cls=MyEncoder)
return HttpResponse(data, mimetype='application/json')
# Overall ranking
if len(ranking_q) > 0:
ranking_q = ranking_q.order_by('-score')[:10]
ranking_list = []
for pin in ranking_q:
ranking_list.append(pin)
ranking_list = fun.group(lambda p: p.score, ranking_list)
data = dumps({'status':'OK', 'data':{'ranking_list':ranking_list}}, cls=MyEncoder)
return HttpResponse(data, mimetype='application/json')
else:
d = {'status': 'ERR', 'data':'Error: No pins in this category'}
data = dumps(d, cls=MyEncoder)
return HttpResponse(data, mimetype='application/json')
else:
raise Http404
dbgp("{} does not exist!!!".format(twitter_id_json))
else:
with open(twitter_id_json, "r") as json_file:
json_dict = json.load(json_file)
# TODO: idiomatic way of deserialize json
# TODO : better way to write out debugs
acts = []
for act_str in json_dict["acts"]:
act = json.loads(act_str)
profile_name = act["profile_name"]
profile_url = act["profile_url"]
created_at = act["created_at"]
content = act["content"]
urls = act["urls"]
media_urls = act["media_urls"]
acts.append(Pin(profile_name, profile_url, created_at, content, urls, media_urls))
profile_elem = (json_dict["profile_img"], json_dict["profile_bg_img"], json_dict["profile_stats"], json_dict["profile_bio"], json_dict["profile_location"])
dtos[twitter_id] = (profile_elem, acts)
continue
if not use_api:
dbgp("not user api")
dtos = get_tweets(twitter_id, dtos)
else:
dbgp("use api")
dtos = get_tweets_api(twitter_id, dtos, api)
dbgp(dtos[twitter_id])
if ui:
app = QApplication([])
def test_thread_running(self):
p24 = Pin(24)
p24.output(.5)
self.assertTrue(p24._thread.is_alive())
def ask_pin(first_time_usage, callback):
scr = switch_to_new_screen()
first_time_title = "Choose a PIN code"
title = "Enter your PIN code"
if first_time_usage:
title = first_time_title
title_lbl = add_label(title, y=PADDING, style="title")
btnm = lv.btnm(scr)
# shuffle numbers to make sure
# no constant fingerprints left on screen
buttons = ["%d" % i for i in range(0,10)]
btnmap = []
for j in range(3):
for i in range(3):
v = rng.get_random_bytes(1)[0] % len(buttons)
btnmap.append(buttons.pop(v))
btnmap.append("\n")
btnmap = btnmap+[lv.SYMBOL.CLOSE, buttons.pop(), lv.SYMBOL.OK, ""]
btnm.set_map(btnmap)
btnm.set_width(HOR_RES)
btnm.set_height(HOR_RES)
btnm.align(scr, lv.ALIGN.IN_BOTTOM_MID, 0, 0)
# remove feedback on press to avoid sidechannels
btnm.set_style(lv.btnm.STYLE.BTN_PR,btnm.get_style(lv.btnm.STYLE.BTN_REL))
pin_lbl = lv.ta(scr)
pin_lbl.set_text("")
pin_lbl.set_pwd_mode(True)
style = lv.style_t()
lv.style_copy(style, styles["theme"].style.ta.oneline)
style.text.font = lv.font_roboto_28
style.text.color = lv.color_hex(0xffffff)
style.text.letter_space = 15
pin_lbl.set_style(lv.label.STYLE.MAIN, style)
pin_lbl.set_width(HOR_RES-2*PADDING)
pin_lbl.set_x(PADDING)
pin_lbl.set_y(PADDING+50)
pin_lbl.set_cursor_type(lv.CURSOR.HIDDEN)
pin_lbl.set_one_line(True)
pin_lbl.set_text_align(lv.label.ALIGN.CENTER)
pin_lbl.set_pwd_show_time(0)
instruct_txt = "Device tamper check.\nThese words should remain #ffffff the same every time#:"
instruct_label = add_label(instruct_txt, 180, style="hint")
instruct_label.set_recolor(True)
antiphish_label = add_label(antiphishing_word(""), 250)
Pin.read_counter()
@feed_rng
def cb(obj, event):
nonlocal first_time_usage
if event == lv.EVENT.RELEASED:
c = obj.get_active_btn_text()
if c is None:
return
if c == lv.SYMBOL.CLOSE:
pin_lbl.set_text("")
antiphish_label.set_text(antiphishing_word(""))
elif c == lv.SYMBOL.OK:
# FIXME: check PIN len
Key.generate_key(pin_lbl.get_text());
if first_time_usage:
Secret.save_secret(alert);
callback()
else:
Pin.counter -= 1
Pin.save_counter(alert)
if Pin.is_pin_valid():
Pin.reset_counter(alert)
callback()
else:
instruct_label.set_text("#f07070 Wrong pin: %d/%d #" % (Pin.counter, Pin.ATTEMPTS_MAX))
if Pin.counter <= 0:
Factory_settings.restore(alert)
Secret.generate_secret()
alert("Security","Device has been factory reset!")
first_time_usage = True
title_lbl.set_text(first_time_title)
instruct_label.set_text(instruct_txt)
pin_lbl.set_text("")
antiphish_label.set_text(antiphishing_word(""))
else:
instruct_label.set_text(instruct_txt)
pin_lbl.add_text(c)
word = antiphishing_word(pin_lbl.get_text())
antiphish_label.set_text(antiphish_label.get_text() + " " + word)
btnm.set_event_cb(cb);
g_server = None
stream_enabled = True
webserver_restart = True
# Stepper
pin_IN1 = 15
pin_IN2 = 18
pin_IN3 = 4
pin_IN4 = 17
pulse_timeout = 0.001 # time to wait before sending another pulse to the stepper motor (smaller = faster but less strong and less precise)
stepper = Stepper(pin_IN1, pin_IN2, pin_IN3, pin_IN4, pulse_timeout)
# PIR sensors
IR_PIN = 23
IR2_PIN = 27
IR_front = Pin(IR_PIN, Pin.IN)
IR_back = Pin(IR2_PIN, Pin.IN)
IR_timestamp = monotonic()
IR_time_threshold = 15 # seconds before subsequent IR input is recognized again
IR_loop_running = False
# Processes object detection results and calculates if the device should adjust its rotation or not
def process_coords(data):
im_width = stream_resolution[0]
prioritized_target = None
targets = data["tar"]
for target in targets:
if not prioritized_target:
prioritized_target = target
else:
if object_detection_targets.index(target["n"]) < object_detection_targets.index(prioritized_target["n"]):
class PinSet:
def __init__(self, enable, pin1, pin2):
self._enable = Pin(enable, GPIO.OUT)
self._pin1 = Pin(pin1, GPIO.OUT)
self._pin2 = Pin(pin2, GPIO.OUT)
def get_enable_number(self):
return self._enable.get_pin_number()
def get_pin1_number(self):
return self._pin1.get_pin_number()
def get_pin2_number(self):
return self._pin2.get_pin_number()
def get_all_pin_numbers(self):
return self._enable.get_pin_number(), self._pin1.get_pin_number(), \
self._pin2.get_pin_number()
def get_enable_val(self):
return self._enable.get_pin_value()
def get_pin1_val(self):
return self._pin1.get_pin_value()
def get_pin2_val(self):
return self._pin2.get_pin_value()
def get_all(self):
return self._enable.get_pin_value(), self._pin1.get_pin_value(), \
self._pin2.get_pin_value()
def set_enable_val(self, val):
self._enable.set_pin_value(val)
def set_pin1_val(self, val):
self._pin1.set_pin_value(val)
def set_pin2(self, val):
self._pin2.set_pin_value(val)
def set_all(self, enable, pin1, pin2):
self._enable.set_pin_value(enable)
self._pin1.set_pin_value(pin1)
self._pin2.set_pin_value(pin2)
def __init__(self):
self.pin = Pin(Board.BUZZ_PIN)
def __init__(self, enable, pin1, pin2):
self._enable = Pin(enable, GPIO.OUT)
self._pin1 = Pin(pin1, GPIO.OUT)
self._pin2 = Pin(pin2, GPIO.OUT)
if left > 580:
left = 300
top += 60
#----------------------------------------------------------------------------# Main
initialise_gpio()
initialise_window()
screen = pygame.display.set_mode(window_size)
button_font = pygame.font.Font(None, 36)
pins7 = [
Pin(a_pin_num, False, True),
Pin(b_pin_num, False, True),
Pin(c_pin_num, False, True),
Pin(d_pin_num, False, True),
Pin(e_pin_num, False, True),
Pin(f_pin_num, False, True),
Pin(g_pin_num, False, True)
]
buttons = [
PinButton(20, 20, 'Red', button_font, red, off, 120, 75, 31, 22,
Pin(red_pin)),
PinButton(160, 20, 'Amber', button_font, amber, off, 120, 75, 22, 22,
Pin(amber_pin)),
PinButton(300, 20, 'Green', button_font, green, off, 120, 75, 22, 22,
Pin(green_pin)),
def test_intitialization(self):
p24 = Pin(24)
self.assertEqual(p24.pin_number, 24)
self.assertEqual(p24.period, 10e-3)
self.assertEqual(p24.value, 0.0)
self.assertTrue(p24._stopped)
def test_thread_running(self):
p24 = Pin(24)
p24.output(.5)
self.assertTrue(p24._thread.is_alive())
def test_output_one(self):
p24 = Pin(24)
p24.output(1)
self.assertEqual(p24.value, 1.0)
self.assertTrue(p24._stopped)