def dialog(request): spotId = request.GET.get('id','').strip().encode("ascii") spot = Spot() sp = {} for s in spot.short_list(): if s['id'] == spotId: sp = s return render_to_response('dialog.html', {'spot':sp,'gateway':spot.get_gateway().get_info(), 'host':request.get_host().split(':')[0]})
def input(): form = Input() if form.validate_on_submit(): try: # print(float(form.mood.data), float(form.danceability.data), float(form.energy.data)) if not 0 <= float(form.mood.data) <= 1.0 or not 0 <= float( form.danceability.data) <= 1 or not 0 <= float( form.energy.data) <= 1: flash('Please make sure your inputs are correct') return redirect('/input') # flash('Name: {}, Mood: {}'.format(form.username.data, form.mood.data)) user = session.get('user', None) token = users[user] if token.is_expiring: token = cred.refresh(token) users[user] = token with spotify.token_as(users[user]): # # tracks = spotify.current_user_top_tracks(limit=10) # # for track in tracks.items: # # print(track.name) # top_artists_name = [] #name used to avoid duplicates # top_artists_uri = [] #uniform resource indicator to connect direct with spotify api # ranges = ['short_term', 'medium_term', 'long_term'] #4 weeks, 6 months, all time # for r in ranges: # print(r) # top_artists_all_data = spotify.current_user_top_artists(limit=50, time_range=r) #get their top artists # top_artists_data = top_artists_all_data.items # for artist_data in top_artists_data: # if artist_data.name not in top_artists_name: # top_artists_name.append(artist_data.name) # top_artists_uri.append(artist_data.uri) # followed_artists_all_data = spotify.followed_artists(limit=50) # print("bruh") # print(top_artists_name) s = Spot(form.username.data, form.mood.data, spotify) s.grab_songs(float(form.mood.data), float(form.danceability.data), float(form.energy.data)) # s.do_stuff() return redirect('/index') except: flash('Please input your username and a mood from 0 to 1') return redirect('/input') flash('Please input a mood from 0 to 1') return render_template('input.html', title='Create Your Concert!', form=form)
def __init__(self, cols, rows): self.cols = cols # temp self.rows = rows # temp w = WIDTH / cols h = HEIGHT / rows self.spots = [[Spot(r, c, w, h) for c in range(cols)] for r in range(rows)]
def index_old(request): #if request.session.get('user',False): spot = Spot() lanIdx = request.GET.get('lan','0') lan = etree.parse(BASE_DIR + '/languages/' + lanIdx + '.xml') str_monitor = lan.find("monitor_source").get("string"); str_single = lan.find("single").get("string"); str_split = lan.find("split").get("string"); str_screen = lan.find("screen").get("string"); str_screens = lan.find("screens").get("string"); str_exit = lan.find("exit").get("string"); str_devicelist = lan.find("device_list").get("string"); str_fullscreen = lan.find("fullscreen").get("string"); str_down = lan.find("down_plugin").get("string"); str_confirmexit = lan.find("confirm_exit").get("string"); return render_to_response('monitor.html', {'lan':lanIdx,'spot_list':spot.short_list(), 'gateway':spot.get_gateway().get_info(), 'host':request.get_host().split(':')[0], 'monitor':str_monitor, 'single':str_single,'split':str_split,'screen':str_screen, 'screens':str_screens, 'exit':str_exit, 'devicelist':str_devicelist,'fullscreen':str_fullscreen, 'down':str_down, 'confirm_exit':str_confirmexit})
def genBoard(): for i in range(0, filas): row = [] for j in range(0,columnas): b = Spot(i,j) row.append(b) board.append(row)
def post(self): ''' #logging.info('request = %s', self.request) logging.info('url = %s', self.request.url) logging.info('body = %s', self.request.body) ''' queryDict = simplejson.loads(self.request.body) uid = queryDict['talky_uid'] lon = queryDict['lon'] lat = queryDict['lat'] #logging.info('Receive GetSpot Request. lon = %s, lat = %s', lon, lat) spots = Spot.query(lat=lat, lon=lon, max_results=2, min_params=(2,0)) spotList = []; for distance, spot in spots: user_num = spot.users.count() spotList.append({'id':spot.key().id(), 'name':spot.name, 'description':spot.description,'user_num':user_num}) response = {'success':True, 'spots':spotList } self.response.headers['Content-Type'] = 'application/json; charset=utf-8' self.response.out.write(simplejson.dumps(response))
def create_board(rows): board = [] for x in range(rows): board.append([]) for y in range(rows): board[x].append(Spot(y, x, Params.spot_width, Params.ROWS)) return board
def _create_grid(self): my_grid = [] for i in range(self.nb_rows): my_grid.append([]) for j in range(self.nb_cols): spot = Spot(i, j, self.cell_size) my_grid[i].append(spot) return my_grid
def make_grid(win_rows, spot_width, btn_height=0): grid = [] for i in range(win_rows): grid.append([]) for j in range(win_rows): spot = Spot(i, j, spot_width, btn_height, win_rows) grid[i].append(spot) return grid
def setNodes(rows, cols, step, generateWallRate): nodes = [] for y in range(rows): temp = [] for x in range(cols): temp.append(Spot(x, y, step, generateWallRate)) nodes.append(temp) return nodes
def makeBoard(window, WIDTH): board = [] for i in range(3): row = [] for j in range(3): row.append(Spot((i, j), WIDTH)) board.append(row) return board
def init_grid(rows): grid = [] for row in range(rows): grid.append([]) for column in range(rows): spot = Spot(row, column, rows, None) grid[row].append(spot) return grid
def make_grid(rows, width): grid = [] gap = width // rows for i in range(rows): grid.append([]) for j in range(rows): spot = Spot(i, j, gap, rows) grid[i].append(spot) return grid
def lambda_handler(event, context): dynamo = boto3.resource('dynamodb').Table('Spotlights') videoId = str(event["videoId"]) response = dynamo.get_item(Key={'videoId': videoId}) if ('Item' not in response): spot = {"videoId": videoId, "data": Spot(videoId).toJson} dynamo.put_item(Item=spot) else: spot = response['Item'] return spot['data']
def prepare_cell_data(): rows = HEIGHT // SIZE cols = WIDTH // SIZE grid = [] for r in range(rows): grid.append([]) for c in range(cols): spot = Spot(r, c) grid[r].append(spot) return grid
def make_grid(rows, width, maze=False): #If maze wanted return a grid that has a random maze produced by prims algorithm if maze: return make_borders(rows, width) #Else return an grid of white spots grid = [] gap = width // rows for i in range(rows): grid.append([]) for j in range(rows): spot = Spot(i, j, gap, rows) grid[i].append(spot) return grid
def detect_and_fit(self, detector=DoG, min_sigma=1, max_sigma=5, sigma_ratio=1.3, threshold=0.01, background_kernel=(30, 30, 10)): valid = ['DoG', 'LoG', 'DoH'] if detector.__name__ not in valid: raise ValueError('Detector not adapted, use one of DoG, LoG, DoH.') if self._verbose > 0: print("\nDetecting...", end="", flush=True) # Get the background signal by smoothing with a much larger kernel than the spot width. blobs = detector(min_sigma=min_sigma, max_sigma=max_sigma, sigma_ratio=sigma_ratio, threshold=threshold).locate(self.image_raw) self.spots = [Spot(tuple(c.astype(int))) for c in blobs[:, :3]] if self._verbose > 0: print('%i spots detected.' % blobs.shape[0]) sigmas = blobs[:, 3] if self._verbose > 0: print("\nFitting...", end="", flush=True) for s, p in zip(self.spots, sigmas): s.model = Gaussian() ex = self.image_raw[extract_cube(s.coordinates, side=background_kernel)] background = numpy.mean(ex) p = itertools.chain(s.coordinates, [background], [self.image_raw[s.coordinates] - background], [p, p, p / max(self.image_raw.shape[:2])]) p_names = signature(s.model.function).parameters.keys() s.model.params = {k: v for (k, v) in zip(p_names, p)} if self._verbose > 0: print("fit.") funcs = [ s.model.function(*s.model.params.values()) for s in self.spots ] self.mixture_model = lambda x, y, z: sum([f(x, y, z) for f in funcs])
def _initialize_template(self, template): template_file = open('templates/{}'.format(template)) template_arr = [row_template.split() for row_template in template_file] for i in xrange(len(template_arr)): new_row = [] for j in xrange(len(template_arr[i])): spot_size = int(template_arr[i][j]) new_spot = Spot(size=spot_size) new_row.append(new_spot) self._queue[spot_size].append(new_spot) self._rows.append(new_row)
def updateSpots(self, t, dt=0): # If no spots then ignore if not self.spots == None: # Update active latitudes first if dt > 0: self.updateActiveRegion(dt) # Update spots and remove if dead doCull = [] for spot in self.spots: if dt > 0: spot.update(self, t, dt) if spot.dead: doCull.append(spot) # Remove dead spots and replace if len(doCull) > 0: spotsToAddBack = len(doCull) for obj in doCull: self.spots.remove(obj) for i in range(spotsToAddBack): self.spots.append(Spot.gen_spot(self.params, self, t))
def make_default_spots(self, default_spot_image): XC = self.XC YC = self.YC M = self.M N = self.N self.YTOP = YC - int((M / 2.) * default_spot_image.get_height()) self.YBOT = YC + int((M / 2.) * default_spot_image.get_height()) self.XLHS = XC - int((N / 2.) * default_spot_image.get_width()) self.XRHS = XC + int((N / 2.) * default_spot_image.get_width()) for midx in range(0, M): for nidx in range(0, N): spot = Spot(default_spot_image, midx, nidx, 'REG') w = spot.image.get_width() h = spot.image.get_height() spot.rect.center = (XC + int( (-N / 2. + nidx + .5) * w), YC + int( (-M / 2. + midx + .5) * h)) self.add(spot)
def post(self): logging.info(self.request.body) request = simplejson.loads(self.request.body) name = unicode(request['name']) logging.info(name) description = request['description'] lat = float(request['lat']) lon = float(request['lon']) print name.encode('utf-8') print description print lat print lon new_spot = Spot.add(name=name,lat=lat, lon=lon, description=description) self.response.out.write('done')
def _detect_spots(self, detector=LocalMax, **kwargs): """ DEPRECATED, replaced by detect_and_fit for simplicity and speed issues. Detect spots with a specified detector (from the spotdetector.py module) and the detection params from utils module. Spots are identified by their position, i.e. 'x.y.z'. :param detector: an instance of the SpotDetector or subclass, i.e. implementing a 'locate' method returning array of positions of spots. :return: None, the spots attribute is a dict filled with spots (name i.e. their position 'x.y.z' and their actual positions.) """ if self._verbose > 0: print("Detecting...", end="") spots = detector(**kwargs).locate(self.image_filtered) # Spots are identified by their position: self.spots = [Spot(tuple(s)) for s in spots] if self._verbose > 0: print('%i spots detected.' % len(self.spots))
def post(self): logging.info('CheckinHandler...') request = simplejson.loads(self.request.body) talky_uid = int(request['talky_uid']) spot_id = int(request['spot_id']) user = TalkyUser.get_by_id(talky_uid) spot = Spot.get_by_id(spot_id) user.spot = spot.key() user.put() response = { 'success':True, 'checkin_times':1, 'user_list':[] } self.response.out.write(simplejson.dumps(response)) logging.info('CHECK-IN ... OK')
def create_board(self, mouse_row, mouse_col, rows=ROWS, cols=COLS): #Create 2d array of Spots self.grid = [] for i in range(rows): temp = [] for j in range(cols): temp.append(Spot(i, j, GRID_WIDTH)) self.grid.append(temp) #Create Mines out of spots n = 0 while n < NUM_MINES: i,j = random.randint(0,rows-1), random.randint(0,cols-1) dist = int(((mouse_row-i)**2 + (mouse_col-j)**2)**(1/2)) if not self.grid[i][j].mine and dist > 2: n += 1 self.grid[i][j].mine = True #Update neighbors of each spot and give number of mines around for row in self.grid: for spot in row: spot.update_neighbors(self.grid)
class Bot: def __init__(self): self.keyword_fetcher = Keywords() self.spot_client = Spot() def fetch_spot(self, sentence): result = self.keyword_fetcher.extract_from_sentence(sentence) message = {} message_body = '' spot = self.spot_client.recommend_spot(list(result[1])[0], result[0]) if spot: message_body += spot['name'] message_body += 'はどうでしょうか?' message_body += 'オススメポイントは' message_body += spot['reason'] message_body += ' です' message['body'] = message_body message['image'] = spot['image'] else: message_body = '申し訳ありません、候補が見つかりませんでした' message['body'] = message_body return message
def main(user_id): """ main """ token = spotipy.util.prompt_for_user_token(user_id, ' '.join(SCOPE), client_id=CLIENT_ID, client_secret=CLIENT_SECRET, redirect_uri=REDIRECT_URI) if token: spot = Spot(token, user_id, trace=False) # spot.purge_db() # spot.fetch() # spot.display_table('tracks', order_by='created, played_at') # spot.display_table('albums', order_by='created') # spot.display_table('artists', order_by='created') # spot.display_table('_default') spot.update_recommendations() spot.db_info() else: print("Can't get token for", user_id)
def add_goal(self, x, y): self.goals.add(Spot(x, y))
def add_wall(self, x, y): self.walls.add(Spot(x, y))
from spot import Spot from direction import Direction L = Direction(Spot(-1, 0), 'l') R = Direction(Spot(1, 0), 'r') U = Direction(Spot(0, -1), 'u') D = Direction(Spot(0, 1), 'd') directions = [U, R, D, L] class Board: def __init__(self, dir_list): self.dir_list = dir_list self.walls = set() self.goals = set() self.boxes = set() self.fboxes = frozenset() # since set is not hashable self.player = None self.width = 0 self.height = 0 self.cost = 1 # used for heuristics self.is_stuck = False """ Override class functions """ def __eq__(self, other): """ Used for comparing board instances """ return self.boxes.issubset(other.boxes) and self.player == other.player def __hash__(self): """ http://www.asmeurer.com/blog/posts/what-happens-when-you-mess-with-hashing-in-python/
data = (str(id), ) db = DB(Var.hostname, Var.port, Var.dbname, Var.username, Var.password) return db.execute(query, data) from dataaccess import DataAccess from db import DB #da = DataAccess() #print("----") spot_list = get_spotsid("1") for spot in spot_list: print(spot) from spot import Spot spot1 = Spot() spot1.id = "1" spot1.data1 = '赤レンガ倉庫' spot1.data2 = 35.4516872 spot1.data3 = 139.6437905 spot2 = Spot() spot2.id = "2" spot2.data1 = '江ノ島' spot2.data2 = 35.3110403 spot2.data3 = 139.4875402 spot3 = Spot() spot3.id = "3" spot3.data1 = '高徳院(鎌倉大仏)' spot3.data2 = 35.3168463 spot3.data3 = 139.5357335
import socket import sys import pygame from spot import Spot from env import * from player import Player counter = 0 is_zoom = False spot = Spot(WIDTH / 2, HEIGHT / 2) p1 = Player() p2 = Player() def get_client_socket(): client = None try: client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect((HOST, PORT)) clientMessage = str("OK") client.sendall(clientMessage.encode()) except socket.error as msg: print(msg) client.close() quit() return client
from src.utility.gsclient import GsClient GsClient.updateCredentials( 'C:\\Users\\Chris.Williams\\.gcs\\gla001-232b82940cbf.json') client = GsClient('gla-datastore001') """ blob_names = client.getBlobNameList( 'pleiades', [ '.zip' ] ) root_path = 'ssgp/raw' for name in blob_names: obj = Pleiades( name ) path = os.path.join ( root_path, obj.getSubPath() ) pathname = os.path.join ( path, os.path.basename( name ) ) blob = client.moveBlob( name, dst_name=pathname ) """ blob_names = client.getBlobNameList('spot', ['.zip']) root_path = 'ssgp/raw' for name in blob_names: obj = Spot(name) path = os.path.join(root_path, obj.getSubPath()) pathname = os.path.join(path, os.path.basename(name)) blob = client.moveBlob(name, dst_name=pathname)
def spots(request): spot = Spot() return render_to_response('spots.html', {'spot_list':spot.short_list(), 'gateway':spot.get_gateway().get_info(), 'host':request.get_host().split(':')[0]})
def get_onlines(request): spot = Spot() return HttpResponse(spot.get_onlines())
def add_box(self, x, y): self.boxes.add(Spot(x, y))
def set_player(self, x, y): self.player = Spot(x, y)
def make_borders(rows, width): grid = [] gap = width // rows for i in range(rows): if i == 0 or i == rows - 1: temp = [] for j in range(rows): spot = Spot(i, j, gap, rows) spot.make_barrier() temp.append(spot) grid.append(temp) else: spot = Spot(i, 0, gap, rows) spot.make_barrier() temp = [spot] for j in range(1, rows - 1): temp.append(Spot(i, j, gap, rows)) spot = Spot(i, rows - 1, gap, rows) spot.make_barrier() temp.append(spot) grid.append(temp) return grid
def get(request): id = request.GET["id"]; spot = Spot() return HttpResponse(spot.getGis(id))
def spots1(request): spot = Spot() return HttpResponse(json.dumps(spot.short_list1(), ensure_ascii=False))