def ib_bars_import(hint_date, hint_sym, bar_size="1 min", verbose=False):
if bar_size == 5:
bar_size=='5 mins'
""" Hint_date => YYYYMMD format """
# Generate Event to wait for
e = threading.Event()
# Generate Observable for results
retObservable = ReplaySubject()
# Connect To IB
global CONN, TICKER_ID
conn = CONN
# Register input processing function
def processInput(x):
tz = tzlocal.get_localzone()
if isinstance(x, conn.messageTypes['historicalData']):
if x.date.startswith("finished"):
retObservable.on_completed()
else:
nextValue = dict([(k, getattr(x, k)) for k in x.keys() if k !=
"reqId"])
nextValue['date'] = tz.localize(datetime.strptime(nextValue['date'], '%Y%m%d %H:%M:%S'))
nextValue['date'] = nextValue['date'].astimezone(pytz.utc).replace(tzinfo=None)
retObservable.on_next(nextValue)
elif isinstance(x, conn.messageTypes['error']):
if "data farm connection is OK" in x.errorMsg:
return
print (x, file=sys.stderr)
if x.errorCode != None:
retObservable.on_error(Exception(x.errorMsg));
elif verbose:
print (x)
# Register it and connect
conn.registerAll(processInput)
# Request data from server
endtime = "%s 17:20:00" % hint_date
conn.reqHistoricalData(
tickerId=TICKER_ID,
contract=make_contract(hint_sym),
endDateTime=endtime,
durationStr='1800 S',
barSizeSetting=bar_size,
whatToShow='TRADES',
useRTH=1,
formatDate=1)
TICKER_ID += 1
def on_complete(err=None):
e.set()
# Register on observable to hear "Complete" event.
retObservable.subscribe(None, on_complete, on_complete)
# Wait until data completed
e.wait()
return retObservable.as_observable()
class AudioBackend:
class State(Enum):
paused = 1
playing = 2
def __init__(self):
self.playing = False
self.current_position = 0
self.current_duration = 1
self.current_state = self.State.paused
self.state = ReplaySubject(1)
self.current_track = ReplaySubject(1)
self.position = ReplaySubject(1)
self.duration = ReplaySubject(1)
self.end_of_track = Subject()
self.end_of_track.subscribe(lambda _: logger.debug('END OF TRACK'))
self.state.subscribe(self.set_state)
self.position.subscribe(self.set_position)
self.duration.subscribe(self.set_duration)
self.time_tracking = self.position.pipe(map(self.make_time_tracking))
def destroy(self) -> None:
raise NotImplementedError
def set_track(self, track: Track) -> None:
raise NotImplementedError
def seek(self, position: int) -> None:
raise NotImplementedError
def play(self) -> None:
raise NotImplementedError
def pause(self) -> None:
raise NotImplementedError
def make_time_tracking(self, position: int):
return TimeTrack(
elapsed=utils.format_seconds(position),
total=utils.format_seconds(self.current_duration),
progress_percentage=position / self.current_duration,
)
def set_position(self, position: int):
self.current_position = position
def set_duration(self, duration: int):
self.current_duration = duration
def set_state(self, state):
self.current_state = state
def play_track(self, track: Track):
self.current_track.on_next(track)
self.set_track(track)
self.play()
def rewind_by_seconds(self, offset: int):
new_position = self.current_position + offset
new_position = min(self.current_duration, max(0, new_position))
self.seek(new_position)
def rewind_by_percentage(self, offset: float):
self.rewind_by_seconds(self.current_duration * offset)
def toggle_pause(self):
if self.current_state == self.State.playing:
self.pause()
elif self.current_state == self.State.paused:
self.play()
else:
logger.error(f'Unknown playback state "{self.current_state}"')