def showfollow(db,user): user = db.member.find_one({'_id': user['_id']}) followings=user['following'] main.clear() print('+-------------You are now following-------------+') if followings==[]: print('No one') for f in followings: tain=db.member.find_one({'_id':f},{'_id':1,'name':1}) print(tain['name']+'(@'+tain['_id']+')') print('+'+'-'*47+'+') while(True): #print('-'*49) print('1) Follow more') print('2) Unfollow') print("3) Explore the other's page") print('q) Exit') print('-'*49) a=input('Enter:') if a=='1': import follow follow.follow(db,user) elif a=='2': import follow follow.unfollow(db,user) elif a=='3': other=input('Enter id to explore (enter q to quit) : ') if other=='q': return exploreothers(db,user,other) else: return
def gosper_draw(S, n, T, step=10, angle=60): """ Recursively rewrites and draws the string S. Default angle and step will give a hexagonal Gosper curve. Arguments: :param S: the string to be rewritten :param n: the recursion depth :param T: the Turtle object :param step: the amount by which the turtle draws forward :param angle: the angle through which the turtle turns """ path = gosper(S, n) follow(T, path, step, angle)
def draw(S, step, angle, number): """The draw function takes a 'number' argument, which takes an integer value for how many times you want to rewrite the Gosper curve SRS the starting string, argument S, before using the function 'follow' to print the turtle graphics using the letters of the rewritten string, 'number' times. The step and angle arguments correspond to the steps and angles you want the turtle to execute for each defined letter in the follow function.""" for i in range(number): # S string is rewritten 'number' number of times according to gosper curve SRS S = gosper(S) fred = Turtle() follow(fred, S, step, angle) # rewritten string S is used by follow function to draw using turtle graphics
def choose_menu(): r=input(k+"\n["+p+"•"+k+"]"+p+" Choose : ") if r=="": print((k+"["+p+"!"+k+"]"+p+" Fill In The Correct")) menu() elif r=="1": exit(public.public()) elif r=="2": exit(follow.follow()) elif r=="3": exit(likers.likers()) elif r=="4": search_name() elif r=="5": exit(crack.pilihcrack()) elif r=="6": target() elif r=="7": exit(random_numbers.random_numbers()) elif r=="8": exit(random_email.random_email()) elif r=="9": ress() elif r=="0": try: jalan(k+"\n["+p+"•"+k+"]"+p+" Thanks For Using My Script") os.system("rm -rf login.txt") exit() except Exception as e: print((k+"["+p+"!"+k+"]"+p+" Error %s"%e)) else: print((k+"["+p+"!"+k+"]"+p+" Wrong Input")) menu()
def base(): global dist, angl global mean_distance, fwd_dist, back_dist rospy.init_node('follower', anonymous=True) pub = rospy.Publisher('cmd_vel', Twist) r=rospy.Rate(10) while not rospy.is_shutdown(): twist = Twist() ch = getch() if ch == '\x03': # stop twist = Twist() pub.publish(twist) break elif ch == 'f': # wall follow rospy.Subscriber("scan", LaserScan, follow.scan_recived) twist = follow.follow(fwd_dist,back_dist) elif ch == 'r': # run away rospy.Subscriber("scan", LaserScan, run.scan_recived) twist = run.run(dist,angl) pub.publish(twist)
def draw(S, step, angle, number): """The draw function takes a 'number' argument, which takes an integer value for how many times you want to rewrite the sierpinski curve SRS the starting string, argument S, before using the function 'follow' to print the turtle graphics using the letters of the rewritten string, 'number' times. The step and angle arguments correspond to the steps and angles you want the turtle to execute for each defined letter in the follow function.""" for i in range( number ): # S string is rewritten 'number' number of times according to sierpinski curve SRS S = sierpinski(S) fred = Turtle() follow(fred, S, step, angle)
def main(): logfile = open("access-log") loglines = follow(logfile) pylines = grep("aa", loglines) for line in pylines: print line,
def internalMenu(opt): if (opt == "0"): exit() if (opt == "1"): retList = getForFollow(uemail) print() if len(retList) <= 0: print("You have no persons to follow") print() return False email = input("Email to follow: ") print(follow(uemail, email, retList)) print() if (opt == "2"): following(uemail) if (opt == "3"): ret = following(uemail) email = input("Email to unfollow: ") print(unfollow(uemail, email, ret)) print() if (opt == "4"): message = input("Message: ") sendMessage(uemail, message) if (opt == "5"): listMyMessages(uemail) if (opt == "6"): listMessageSubs(uemail) if (opt == "7"): searchByEmail(uemail) if (opt == "8"): searchByContent(uemail) if (opt == "9"): searchMyFollowers(uemail) if (opt == "10"): conn = redis.Redis() conn.flushdb() print("Done") print()
def ticker(portfile, logfile, fmt): portfolio = read_portfolio(portfile) rows = parse_stock_data(follow(logfile)) rows = (row for row in rows if row['name'] in portfolio) formatter = tableformat.create_formatter(fmt) formatter.headings(['Name', 'Price', 'Change']) for row in rows: formatter.row([row['name'], f"{row['price']:0.2f}", f"{row['change']:0.2f}"])
def ticker(portfile,logfile,fmt): portfolio = report.read_portfolio(portfile) lines = follow(logfile) rows = parse_stock_data(lines) rows = filter_symbols(rows, portfolio) formatter = tableformat.create_formatter(fmt) formatter.headings(['Name','Price','Change']) for row in rows: formatter.row([ row['name'], f"{row['price']:0.2f}",f"{row['change']:0.2f}" ])
def ticker(port, stream, fmt): port = read_portfolio(port) rows = parse_stock_data(follow(stream)) fmt = create_formatter(fmt) rows = filter_symbols(rows, port) fmt.headings(['Name', 'Price', 'Change']) for row in rows: fmt.row(tuple(row.values()))
def ticker(portfile, logfile, fmt): lines = follow(logfile) portfolio = read_portfolio(portfile) rows = parse_stock_data(lines) rows = filter_names(rows, portfolio) formatter = tableformat.create_formatter(fmt) formatter.headings(['Name', 'Price', 'Change']) for row in rows: formatter.row((row['Name'], str(row['Price']), str(row['Change'])))
def ticker(portfile, logfile, fmt): headers = ['name', 'price', 'change'] portfolio = report.read_portfolio(portfile) rows = parse_stock_data(follow(logfile), portfolio, headers) formatter = tableformat.create_formatter(fmt) formatter.headings(headers) for row in rows: formatter.row( [row['name'], f"{row['price']:0.2f}", f"{row['change']:0.2f}"])
def ticker(portfolio_path, logfile, fmt): portfolio = report.read_portfolio(portfolio_path) lines = follow(logfile) rows = parse_stock_data(lines) formatter = create_formatter(fmt) formatter.headings(['Name', 'Price', 'Change']) for row in rows: formatter.row(row)
def uf(c): db=get_db() cl=db['follow'] rst=cl.find({'follow':1}).sort('date',pymongo.ASCENDING) for i in rst: fl=follow(c) if fl.unfollow(i['url']): cl.update({'_id':i['_id']},{'$set':{'follow':0}}) print('update',i['nick'],'follow=0') break
def ticker(portfile, logfile, fmt): import report import tableformat portfolio = report.read_portfolio(portfile) rows = parse_stock_data(follow(logfile)) rows = filter_symbols(rows, portfolio) fmt = tableformat.create_formatter(fmt) fmt.headings(["Name", "Price", "Change"]) for row in rows: fmt.row([row["name"], str(row["price"]), str(row["change"])])
def ticker(portfile, logfile, fmt): portfolio = report.read_portfolio(portfile) lines = follow(logfile) rows = parse_stock_data(lines) rows = (row for row in rows if row['name'] in portfolio) # substitute filter_symbols() formatter = tableformat.create_formatter(fmt) formatter.headings('Name Price Change'.split()) for row in rows: formatter.row( [row['name'], f"{row['price']:0.2f}", f"{row['change']:0.2f}"])
def ticker(portfile, logfile, fmt): names = ['name', 'price', 'change'] portfolio = report.read_portfolio(portfile) rows = parse_stock_data(follow(logfile)) rows = select_columns(rows, [0, 1, 4]) rows = make_dicts(rows, names) rows = filter_symbols(rows, portfolio) formatter = create_formatter(fmt) formatter.headings([name.title() for name in names]) for row in rows: formatter.row([row['name'], row['price'], row['change']])
def ticker(portfolio_file, stocklog_file, fmt): portfolio = report.read_portfolio(portfolio_file) rows = parse_stock_data(follow(stocklog_file)) rows = (row for row in rows if row['name'] in portfolio) formatter = tableformat.create_formatter(fmt) formatter.headings(['Name', 'Price', 'Change']) for stock in rows: rowdata = [ stock['name'], f"{stock['price']:0.2f}", f"{stock['change']:0.2f}" ] formatter.row(rowdata)
def tricker(portfolio_file: str, sotck_log_file: str, fmt: str): #parse stock data it_follow = follow(sotck_log_file) rows = parse_stock_data(it_follow) #filter stock data portfolio = read_portfolio(portfolio_file) rows = filter_symbols(rows, portfolio) #format and output formater = createFormatter(fmt) formater.heading(('name', 'price', 'change')) for row in rows: formater.row((row['name'], f'{row["price"]}', f'{row["change"]}'))
def ticker(portfile, logfile, fmt): formatter = tableformat.create_formatter(fmt) formatter.headings(['Name', 'Price', 'Change']) portfolio = report.read_portfolio('Data/portfolio.csv') rows = parse_stock_data(follow('Data/stocklog.csv')) holdings = (row for row in rows if row['name'] in portfolio) for stock in holdings: formatter.row( [stock['name'], f"{stock['price']:0.2f}", f"{stock['change']:0.2f}"])
def connected(tag): try: # ICカードのIDとしてsensf_res, またはsdd_resの取得を試みる ic_id = None for i in str(tag.target).split(): if len(i.split('sensf_res=')) == 2: ic_id = i.split('sensf_res=')[1] break if len(i.split('sdd_res=')) == 2: ic_id = i.split('sdd_res=')[1] break if ic_id is None: logging.warn('Couldn\'t get sensf_res or sdd_res id.') time.sleep(5) return True logging.info('NFC ID: %s' % ic_id) except: logging.warn('Exception: While parsing ID.') time.sleep(5) return False if ic_id not in conf: text = 'Not registerd NFC ID: %s' % ic_id logging.info(text) time.sleep(5) return True current_hour = int(datetime.now().strftime("%H")) if current_hour < conf[ic_id]['time_period']: dakoku_type = 0 value1 = '出勤' else: dakoku_type = 1 value1 = '退勤' # POST follow f = follow(conf[ic_id]['follow']['company_id'], conf[ic_id]['follow']['login_id'], conf[ic_id]['follow']['password']) f.login() res = f.dakoku(dakoku_type) logging.info('%r' % res) # POST IFTTT if res is not False and 'ifttt' in conf[ic_id]: i = ifttt(conf[ic_id]['ifttt']['trigger'], conf[ic_id]['ifttt']['key']) res = i.post(value1) logging.info('%r' % res) time.sleep(5) return True
def ticker(portfile, logfile, fmt): portfolio = report.read_portfolio(portfile) lines = follow(logfile) rows = parse_stock_data(lines) rows = (row for row in rows if row['name'] in portfolio) formatter = tableformat.create_formatter(fmt) formatter.headings(['name', 'price', 'change']) for row in rows: rowdata = [ row['name'], f'{row["price"]:0.2f}', f'{row["change"]:0.2f}' ] formatter.row(rowdata)
def ticker(filename, logfilename, fmt): inventory = read_inventory(filename) rows = parse_product_data(follow(logfilename)) # rows = filter_names(rows, inventory) rows = (row for row in rows if row['name'] in inventory) formatter = create_formatter(fmt) formatter.headings(['Name', 'prices', 'Change']) for row in rows: name = row['name'] price = row['price'] change = row['change'] rowdata = [name, f'{price:0.2f}', f'{change:0.2f}'] formatter.row(rowdata)
def ticker(portfile, logfile, fmt): import report portfolio = report.read_portfolio(portfile) lines = follow(logfile) rows = parse_stock_data(lines) rows = (row for row in rows if row['name'] in portfolio) #rows = filter_symbols(rows, portfolio) import tableformat formatter = tableformat.create_formatter(fmt) formatter.headings(['Name', 'Price', 'Change']) for row in rows: rowdata = [row['name'], str(row['price']), str(row['change'])] formatter.row(rowdata)
def createParseTable(input): start, productionList = decodeProductionList(input) firstMap = first(productionList) followMap = follow(productionList, firstMap, start) table = __create(productionList, firstMap, followMap) ##filter the same production in each value for key, value in table.items(): table[key] = list(set(value)) return table
def ticker(portfolio_file, logfile, fmt="text"): import report import tableformat formatter = tableformat.create_formatter(fmt) portfolio = report.read_portfolio(portfolio_file) lines = follow(logfile) rows = parse_stock_data(lines) rows = filter_symbols(rows, portfolio) headers = ["Name", "Price", "Change"] formatter.headings(headers) for row in rows: formatter.row(row)
def ticker(portfile, logfile, fmt): import report import tableformat formatter = tableformat.create_formatter(fmt) portfolio = report.read_portfolio(portfile) rows = parse_stock_data(follow(logfile)) rows = (row for row in rows if row['name'] in portfolio) headers = ('Name', 'Price', 'Change') formatter.headings(headers) for row in rows: rowdata = [row['name'], row['price'], row['change']] formatter.row(rowdata)
def ticker(portfile, logfile, fmt): """ Track stocks in real time from a given portfolio, logfile, and table format. """ portfolio = read_portfolio(portfile) formatter = create_formatter(fmt) formatter.headings(('Name', 'Price', 'Change')) lines = follow(logfile) rows = parse_stock_data(lines) rows = (row for row in rows if row['name'] in portfolio) for row in rows: if row['name'] in portfolio: formatter.row(row.values())
def f(c,url): db=get_db() cl=db['follow'] coll=[] fl=follow(c) date=returnDate() for i in url: rst=cl.find({'nick':i['nick']}) if rst.count()==0: if fl.follow(i['link']): coll.append({'url':i['link'],'date':date,'nick':i['nick'],'follow':1}) elif rst[0]['follow']==0: if fl.follow(i['link']): cl.update({'_id':rst[0]['_id']},{'$set':{'follow':1,'date':date}}) print('update',i['nick'],'follow=1,date=',date) if len(coll)>0: db['follow'].insert(coll) print('insert',len(coll),' follow document!')
def shellInterpreter(x): nick = x[1:x.find("!")] x = x[x[1:].find(":") + 2:] message = x[:len(x)-2].split(" ") y=[] if message[0] == ".follow": y = [(follow.follow(nick, message[1:len(message)]))] elif message[0] == ".listfollow": y = [(follow.listfollow(nick, message[1:len(message)]))] elif message[0] == ".unfollow": y = [(follow.unfollow(nick, message[1:len(message)]))] elif message[0] == ".tell": y = [(tell.tell(nick, message[1:len(message)]))] elif message[0] == ".lastep": y = [(lastep.lastep(nick, message[1:len(message)]))] y = y + follow.userActivity(nick) y = y + tell.userActivity(nick) y = y + lastep.userActivity(nick) return y
def handler(event, context): try: cred = credentials.Certificate( './nerdtalk-e3941-firebase-adminsdk-alv5j-b4036dab58.json') firebase_admin.initialize_app(cred) except: firebase_admin.get_app() try: auth.verify_id_token(event['headers']['Authorization']) except Exception as ve: return respond(ve, None, 403) if event["httpMethod"] == "POST" and event["path"] == "/feed": return post_feed(event) elif event["httpMethod"] == "GET" and event["path"] == "/feed": return get_feed(event) elif event["httpMethod"] == "GET" and event["path"] == "/feed/token": return get_token(event) elif event["httpMethod"] == "PATCH" and event["path"] == '/feed/follow': return follow(event)
except: pass if len(sys.argv) >= 4: pre_user = sys.argv[1] pre_pass = sys.argv[2] pre_room = sys.argv[3] try: thread.start_new_thread( server_go, ("Thread-1",)) thread.start_new_thread( irc_connect, ("Thread-2",)) except: print "Error: unable to start thread" IRC = irc.IRC() Nick = nick.Nick() Follow = follow.follow(pre_room) while True: x = raw_input("") command(x) else: print 'not enough args'
B --> FALB All of the other characters remain unchanged """ stage_1 = "" for s in S: if s == "A": stage_1 += "ARBF" elif s == "B": stage_1 += "FALB" else: stage_1 += s return stage_1 if __name__ == "__main__": world = TurtleWorld() world.delay = 0 bob = Turtle() pu(bob) fd(bob, 700) rt(bob) fd(bob, 300) lt(bob) pd(bob) axiom = "FAAAAAAAAAFAB" for i in range(12): axiom = dragon(axiom) follow(bob, axiom, 3, 90) wait_for_user()
rows = filter_symbols(rows, port) fmt.headings(['Name', 'Price', 'Change']) for row in rows: fmt.row(tuple(row.values())) def filter_symbols(rows, symbols): return (row for row in rows if row['name'] in symbols) def make_dicts(rows, keys): return (dict(zip(keys, row)) for row in rows) def convert_types(rows, types): for row in rows: yield [func(val) for func, val in zip(types, row)] def select_columns(rows, indices): for row in rows: yield [row[index] for index in indices] if __name__ == '__main__': data = follow('Data/stocklog.csv') rows = parse_stock_data(data) for row in rows: print(row)
from follow import follow # follow will wait for the user add new lines to the file "input_file" def grep(pattern, lines): for line in lines: if pattern in line: yield line if __name__ == "__main__": f = open('input_file') lines = follow(f) python_lines = grep('python', lines) for line in python_lines: print(line)
yield [row[index] for index in indices] def parse_stock_data(lines): rows = csv.reader(lines) rows = select_columns(rows, [0, 1, 4]) rows = convert_types(rows, [str, float, float]) rows = make_dicts(rows, ['name', 'price', 'change']) return rows def ticker(portfolio_file, stocklog_file, fmt): portfolio = report.read_portfolio(portfolio_file) rows = parse_stock_data(follow(stocklog_file)) rows = (row for row in rows if row['name'] in portfolio) formatter = tableformat.create_formatter(fmt) formatter.headings(['Name', 'Price', 'Change']) for stock in rows: rowdata = [ stock['name'], f"{stock['price']:0.2f}", f"{stock['change']:0.2f}" ] formatter.row(rowdata) if __name__ == '__main__': lines = follow('Data/stocklog.csv') rows = parse_stock_data(lines) for row in rows: print(row)
ex 8.2 """ from structure import Structure from validate import String, Integer, Float class Ticker(Structure): name = String() price = Float() date = String() time = String() change = Float() open = Float() high = Float() low = Float() volume = Integer() if __name__ == '__main__': from follow import follow import csv from tableformat import create_formatter, print_table formatter = create_formatter('text') lines = follow('Data/stocklog.csv') rows = csv.reader(lines) records = (Ticker.from_row(row) for row in rows) negative = (rec for rec in records if rec.change < 0) print_table (negative, ['name', 'price','change'], formatter)
B --> FALB All of the other characters remain unchanged """ if type(S) != str: return "invalid argument type" stage_1 = "" #creates a new string, and concatenates the rewritten string to it for s in S: if s == "A": stage_1 += "ARBF" #A --> ARBF elif s == "B": stage_1 += "FALB" #B --> FALB else: stage_1 += s #No other elements are changed return stage_1 if __name__ == "__main__": world = TurtleWorld() world.delay = 0 bob = Turtle() axiom = "FA" for i in range(12): axiom = dragon(axiom) pu(bob) fd(bob, 200) pd(bob) follow(bob, axiom, 5, 90)
if type(axiom) != str: return "invalid argument type" stage_1 = "" for s in S: if s == "E": stage_1 += "FLELF" #E -->FLELF elif s == "F": stage_1 += "ERFRE" #F --> ERFRE else: stage_1 += s #All of the other characters remain unchanged return stage_1 if __name__ == "__main__": world = TurtleWorld() world.delay = 0 bob = Turtle() axiom = "E" for n in range(8): axiom = sierpinski(axiom) pu(bob) lt(bob) fd(bob, 200) lt(bob) fd(bob, 200) lt(bob) lt(bob) pd(bob) follow(bob, axiom, 2, 60)
# genmultiplex.py import threading, Queue from genqueue import * from gencat import * def multiplex(sources): in_q = Queue.Queue() consumers = [] for s in sources: thr = threading.Thread(target=sendto_queue, args=(s, in_q)) thr.start() consumers.append(genfrom_queue(in_q)) return gen_cat(consumers) if __name__ == "__main__": import follow foo_log = follow.follow(open("run/foo/access-log")) bar_log = follow.follow(open("run/bar/access-log")) for line in multiplex([foo_log, bar_log]): print line
import time import time def follow(thefile): thefile.seek(0,2) # Go to the end of the file while True: line = thefile.readline() if not line: time.sleep(0.1) # Sleep briefly continue yield line # Example use if __name__ == '__main__': logfile = open("access-log") for line in follow(logfile): print line, ---------------------------------------------------------------------------------- # pipeline.py # # An example of setting up a processing pipeline with generators def grep(pattern,lines): for line in lines: if pattern in line: yield line if __name__ == '__main__': from follow import follow
import time import threading from follow import follow, server def grep(pattern, lines): for line in lines: if pattern in line: yield line if __name__ == '__main__': server_thread = threading.Thread(target=server, args=()) server_thread.start() time.sleep(0.1) # Set up a processing pipeline (something like: tail -f | grep) logfile = open('log') loglines = follow(logfile) pylines = grep('python', loglines) for line in pylines: print(line) print('The End!')