def main(): # Init object Northernlion = stream.Stream("Northernlion") online = False # Run infinitely, that way its always monitoring for streams print(f"Monitoring {Northernlion.channel}") while True: # If the channel is live, we start monitoring for what games they are playing Northernlion.liveCheck() if Northernlion.live: if not Northernlion.start: Northernlion.setStart() print(Northernlion.start) online = True print("Finding current game...") Northernlion.updateDocket() print(Northernlion.docket) elif online: # If the channel was online last time we checked but is no longer # Wait 3 minutes to make sure it doesn't come back online print( "Waiting 3 more minutes to make sure stream doesn't come back..." ) for remaining in range(180, 0, -1): sys.stdout.write("\r") sys.stdout.write(f"{remaining} seconds remaining...") sys.stdout.flush() time.sleep(1) print() Northernlion.liveCheck() if not Northernlion.live: Northernlion.cleanDocket() print(f"Getting vod URL") Northernlion.findVOD() print(f"Getting top clip") Northernlion.findClip() print(f"Posting to Reddit") reddit.post(Northernlion) # Reset variables online = False del Northernlion Northernlion = stream.Stream("Northernlion") print("Sleeping for 1 minute before checking again...") for remaining in range(60, 0, -1): sys.stdout.write("\r") sys.stdout.write(f"{remaining} seconds remaining") sys.stdout.flush() time.sleep(1) print()
def control(self, t): if t: if self.stream != None: if self.stream.isAlive(): return {"running": True} else: self.stream = streams.Stream() else: self.stream = streams.Stream() self.stream.start() return {"running": True} else: self.stream.stop() self.stream.join() return {"running": False}
def startStreaming(new_streams, cid): # Loop thru each stream in our list for active_stream in new_streams: # Connect to the stream with event_stream.Stream(active_stream, falcon, queue, config, cid) as active: start = False try: if active.partition in str(config["partition"]).split(","): start = True if str(config["partition"]).lower() == "all": start = True except KeyError: # Start all available streams if partition is not specified start = True if start: status.statusWrite( "Starting listener on partition number {}...".format( str(active.partition))) # Create a thread to handle stream processing, daemonize so the thread shuts down when we do t = threading.Thread(target=active.process, daemon=True) # Begin processing the stream's contents t.start() return True
def __init__(self, channelNames, name=None): name = str(name) if not name is None else self.__class__.__name__ stream.Stream.__init__(self, channelNames, name = 'sensor.' + name) self.raw = stream.Stream(channelNames, self.name + '_raw') self.loadCalibration() self.raw.updated.connect(self.newData)
def __init__(self, handles, data, rate, io_name, request_num, scan_rate): super(Thread, self).__init__() self.syncStream = stream.Stream(handles, rate) self.handles = handles self.data = data self.io_name = io_name self.request_num = request_num self.scan_rate = scan_rate self.io_addr = ljm.namesToAddresses(len(io_name), io_name)[0]
def __init__(self, sensors): super().__init__() self.rotation_raw = stream.Stream(('pitch', 'roll', 'heading'), name='estimator.rotation_raw') self.sensors = sensors self.sensors.accelerometer.updated.connect(self.updateRotation) self.sensors.magnetometer.updated.connect(self.updateRotation) self.rotation = filters.Complementary(self.rotation_raw, self.sensors.gyroscope, tau=50, name='estimator.rotation')
import stream from streamlist import StreamList stream0 = stream.Stream('123', 'User') stream1 = stream.Stream('999', 'Looser') streamlist = StreamList() streamlist.add_stream('123', stream0) streamlist.add_stream('999', stream1) print(streamlist.to_json())
from __future__ import print_function import os import sys sys.path.append('lib') from itertools import izip import numpy as np import classify import stream as img_stream import serial from log import sys_logger as logger model = classify.Classify(10) streamFactory = img_stream.Stream() imgGenerator = streamFactory.from_camera(0) ser = serial.Serial('mock') scene = 0 logger.info('lanuch successfully') while True: # check serial if ser.is_ready(): cmd, payload = ser.get_payload() # fit the model if cmd == 0: sid = payload
def cleanup(cohosts): guests = [] for channel in cohosts: guests.append(stream.Stream(channel, False)) return guests
def setUp(self): self.stream = stream.Stream()
def main(): # Init variables to default values guests = cleanup(cohosts) Northernlion = stream.Stream("Northernlion", False) NLSS = stream.NLSS([], []) online = False startTime = None # Run infinitely, that way its always monitoring for streams print(f"Monitoring {Northernlion.getName()}") while True: # If the channel is live, we start monitoring for what games they are playing if Northernlion.liveCheck(): if not startTime: NLSS.setStart() startTime = NLSS.getStart() print (startTime) online = True print("Finding current game...") Northernlion.setGame() game = Northernlion.getGame() NLSS.addDocket(game) print(f"Checking for guests...") for guest in guests: if guest not in NLSS.getGuests(): guest.liveCheck() if guest.getLive(): guest.setGame() guestGame = guest.getGame() if guestGame == game: print(f"{guest.getName()} added to guests") NLSS.addGuest(guest) else: print(f"{guest.getName()} not added, already in list") elif online: # If the channel was online last time we checked but is no longer # Wait 2 minutes to make sure it doesn't come back online print("Waiting 3 more minutes to make sure stream doesn't come back...") for remaining in range(180, 0, -1): sys.stdout.write("\r") sys.stdout.write(f"{remaining} seconds remaining...") sys.stdout.flush() time.sleep(1) print() if not Northernlion.liveCheck(): # Need to delete "unique" game entries, as sometimes the game being # played at the start is left over from last stream print(f"Cleaning entries from docket\n{NLSS.getDocket()}") NLSS.cleanDocket() print(f"Getting vod URL") NLSS.findVOD() print(f"Posting to Reddit") postReddit.post(NLSS.getDocket(), NLSS.getVOD(), NLSS.getGuests(), NLSS.getClip()) # Reset variables online = False startTime = None for guest in guests: del guest del Northernlion del NLSS guests = cleanup(cohosts) Northernlion = stream.Stream("Northernlion", False) NLSS = stream.NLSS([], []) print("Sleeping for 1 minute before checking again...") for remaining in range(60, 0, -1): sys.stdout.write("\r") sys.stdout.write(f"{remaining} seconds remaining") sys.stdout.flush() time.sleep(1) print()
def loadOrigin(self, origin_id, orig, station_list): """ Fetches Origin (and MT) from the scisola database and return it in origin object. Returns True/False and origin object/error. """ _query = "SELECT `Origin`.`id`, `Origin`.`timestamp`, " + \ "`Origin`.`datetime`, " + \ "`Origin`.`magnitude`, `Origin`.`latitude`, " + \ "`Origin`.`longitude`, `Origin`.`depth`, " + \ "`Origin`.`automatic`, `Origin`.`results_dir`, " + \ "`Event`.`id`, " + \ "`Moment_Tensor`.`cent_shift`, " + \ "`Moment_Tensor`.`cent_time`, `Moment_Tensor`." + \ "`cent_latitude`, `Moment_Tensor`.`cent_longitude`, " + \ "`Moment_Tensor`.`cent_depth`, `Moment_Tensor`." + \ "`correlation`, `Moment_Tensor`.`var_reduction`, " + \ "`Moment_Tensor`.`mw`, `Moment_Tensor`.`mrr`, " + \ "`Moment_Tensor`.`mtt`, `Moment_Tensor`.`mpp`, " + \ "`Moment_Tensor`.`mrt`, `Moment_Tensor`.`mrp`, " + \ "`Moment_Tensor`.`mtp`, `Moment_Tensor`.`vol`, " + \ "`Moment_Tensor`.`dc`, `Moment_Tensor`.`clvd`, " + \ "`Moment_Tensor`.`mo`, `Moment_Tensor`.`strike`, " + \ "`Moment_Tensor`.`dip`, `Moment_Tensor`.`rake`, " + \ "`Moment_Tensor`.`strike_2`, `Moment_Tensor`.`dip_2`, " + \ "`Moment_Tensor`.`rake_2`, `Moment_Tensor`.`p_azm`, " + \ "`Moment_Tensor`.`p_plunge`, `Moment_Tensor`.`t_azm`, " + \ "`Moment_Tensor`.`t_plunge`, `Moment_Tensor`.`b_azm`, " + \ "`Moment_Tensor`.`b_plunge`, `Moment_Tensor`.`minSV`, " + \ "`Moment_Tensor`.`maxSV`, `Moment_Tensor`.`CN`, " + \ "`Moment_Tensor`.`stVar`, `Moment_Tensor`.`fmVar`, " + \ "`Moment_Tensor`.`frequency_1`, `Moment_Tensor`." + \ "`frequency_2`, `Moment_Tensor`.`frequency_3`, " + \ "`Moment_Tensor`.`frequency_4` FROM `Origin` INNER JOIN " + \ "`Event` ON `Origin`.`id` = `Event`.`Origin_id` INNER JOIN " + \ "`Moment_Tensor` ON " + \ "`Origin`.`id` = `Moment_Tensor`.`Origin_id` " + \ "WHERE `Origin`.`id` = " + str(origin_id) + ";" _row = self.read([_query])[0][0] # converts string to datetime object _orig_tp = date.datetime.strptime(_row[1], "%Y/%m/%d %H:%M:%S.%f") orig = origin.Origin() orig.id = int(_row[0]) orig.timestamp = _orig_tp orig.datetime = _row[2] orig.magnitude = float(_row[3]) orig.latitude = float(_row[4]) orig.longitude = float(_row[5]) orig.depth = float(_row[6]) orig.automatic = bool(_row[7]) orig.results_dir = _row[8] orig.event_id = _row[9] orig.mt = origin.MomentTensor() orig.mt.cent_shift = int(_row[10]) orig.mt.cent_time = float(_row[11]) orig.mt.cent_latitude = float(_row[12]) orig.mt.cent_longitude = float(_row[13]) orig.mt.cent_depth = float(_row[14]) orig.mt.correlation = float(_row[15]) orig.mt.var_reduction = float(_row[16]) orig.mt.mw = float(_row[17]) orig.mt.mrr = float(_row[18]) orig.mt.mtt = float(_row[19]) orig.mt.mpp = float(_row[20]) orig.mt.mrt = float(_row[21]) orig.mt.mrp = float(_row[22]) orig.mt.mtp = float(_row[23]) orig.mt.vol = float(_row[24]) orig.mt.dc = float(_row[25]) orig.mt.clvd = float(_row[26]) orig.mt.mo = float(_row[27]) orig.mt.strike = float(_row[28]) orig.mt.dip = float(_row[29]) orig.mt.rake = float(_row[30]) orig.mt.strike2 = float(_row[31]) orig.mt.dip2 = float(_row[32]) orig.mt.rake2 = float(_row[33]) orig.mt.p_azm = float(_row[34]) orig.mt.p_plunge = float(_row[35]) orig.mt.t_azm = float(_row[36]) orig.mt.t_plunge = float(_row[37]) orig.mt.b_azm = float(_row[38]) orig.mt.b_plunge = float(_row[39]) orig.mt.minSV = float(_row[40]) orig.mt.maxSV = float(_row[41]) orig.mt.CN = float(_row[42]) orig.mt.stVar = float(_row[43]) orig.mt.fmVar = float(_row[44]) orig.mt.frequency_1 = float(_row[45]) orig.mt.frequency_2 = float(_row[46]) orig.mt.frequency_3 = float(_row[47]) orig.mt.frequency_4 = float(_row[48]) _query = "SELECT DISTINCT `streamNetworkCode`, " + \ "`streamStationCode` FROM `Stream_Contribution` " + \ "WHERE `Origin_id` = " + str(orig.id) + ";" _rows = self.read([_query])[0] # get stations for _row in _rows: _station = stream.Station() _station.network = _row[0] _station.code = _row[1] _query = "SELECT `streamCode`, `var_reduction`, " + \ "`mseed_path` FROM `Stream_Contribution` " + \ "WHERE `Origin_id` = " + str(orig.id) + \ " AND streamStationCode = '" + str(_station.code) + \ "' ORDER BY `streamCode`;" _stream_rows = self.read([_query])[0] # get station's streams for _stream_row in _stream_rows: _stream = stream.Stream() _stream.code = _stream_row[0] _stream.reduction = float(_stream_row[1]) _stream.mseed_path = _stream_row[2] _station.stream_list.append(_stream) station_list.append(_station) return orig, station_list
def loadStations(self, station_list): """ Fetches Streams (and Stations) from the scisola database and saves them in station_list (list containing stations objects). Returns list -station_list-. """ queries = [] _query = "SELECT Station.code, Station.network, " + \ "Station.description, Station.latitude, " + \ "Station.longitude, Station.elevation, " + \ "Station.priority FROM Station;" queries.append(_query) _query = "SELECT Station.network, Station.code, Stream.code, " + \ "Station.description, Station.latitude, Station.longitude, " + \ "Station.elevation, Stream.azimuth, Stream.dip, " + \ "Stream.gain_sensor, Stream.gain_datalogger, " + \ "Stream.norm_factor, Stream.nzeros, Stream.zeros_content, " + \ "Stream.npoles, Stream.poles_content, Stream.priority " + \ "FROM Station INNER JOIN Stream ON Station.id=Stream.station_id;" queries.append(_query) _station_rows, _stream_rows = self.read(queries) for _row in _station_rows: station = stream.Station() station.code = _row[0] station.network = _row[1] station.description = _row[2] station.latitude = _row[3] station.longitude = _row[4] station.elevation = _row[5] station.priority = int(_row[6]) station_list.append(station) _stream_list = [] for _row in _stream_rows: strm = stream.Stream() strm.station = stream.Station() strm.station.code = _row[1] strm.station.network = _row[0] strm.station.description = _row[3] strm.station.latitude = _row[4] strm.station.longitude = _row[5] strm.station.elevation = _row[6] strm.code = _row[2] strm.azimuth = _row[7] strm.dip = _row[8] strm.gain_sensor = _row[9] strm.gain_datalogger = _row[10] strm.norm_factor = _row[11] strm.nzeros = _row[12] strm.zeros_content = stream.blob2list(_row[13]) strm.npoles = _row[14] strm.poles_content = stream.blob2list(_row[15]) strm.priority = int(_row[16]) _stream_list.append(strm) for station in station_list: station.stream_list = [ _stream for _stream in _stream_list if _stream.station.network == station.network and _stream.station.code == station.code ] return stream.removeEmptyStations(station_list)
#end='', # The end timestamp for the range of candles requested granularity= 'D', # S5 S10 S15 S30 M1 M2 M3 M4 M5 M10 M15 M30 H1 H2 H3 H4 H6 H8 H12 D W M candleFormat='midpoint', # midpoint or bidask #includeFirst='false', # If it is set to “true”, the candlestick covered by the start timestamp will be returned #dailyAlignment=17, # The hour of day used to align candles with hourly, daily, weekly, or monthly granularity #weeklyAlignment='Friday',# The day of the week used to align candles with weekly granularity #alignmentTimezone='America/New_York' # The timezone to be used for the dailyAlignment parameter ) if response: print(str(response)) # # 启动实时汇率获取 # rates.start(accountId=account_id, instruments='AUD_CAD') # time.sleep(5) # 关闭api函数工作线程 api.deinit() # 关闭实时汇率获取线程 # rates.stop() if __name__ == "__main__": api = rest.Api(environment, access_token) rates = stream.Stream(environment, access_token, True) events = stream.Stream(environment, access_token, False) main()
pass if __name__ == '__main__': print("Start recording...") cli = deviceClient.Client(light_visualizer) cli_thread = threading.Thread(target=cli.run_client) cli_thread.daemon = True cli_thread.start() if len(sys.argv) >= 2: audio_stream = stream.FileStream(sys.argv[1]) else: audio_stream = stream.Stream() lights_thread = threading.Thread(target=visualize, args=(light_visualizer, )) lights_thread.daemon = True lights_thread.start() light_visualizer.attach_stream(audio_stream) vis_thread = threading.Thread(target=light_visualizer.visualize) vis_thread.daemon = True vis_thread.start() if not is_pi: analyzer.update() vis_thread.join()