def run():
""" Uses a callback scheduled on an event loop"""
pb = AsyncPushbullet(API_KEY)
listener = WebsocketListener(pb, on_connect=ws_connected,on_message=ws_msg_received,on_close=ws_closed)
loop = asyncio.get_event_loop()
try:
loop.run_forever()
except KeyboardInterrupt:
print("KeyboardInterrupt")
finally:
print("finally...")
loop.run_until_complete(listener.close())
loop.run_until_complete(pb.close())
def run():
""" Uses a callback scheduled on an event loop"""
pb = AsyncPushbullet(API_KEY)
listener = WebsocketListener(pb, on_connect=ws_connected,on_message=ws_msg_received,on_close=ws_closed)
loop = asyncio.get_event_loop()
try:
loop.run_forever()
except KeyboardInterrupt:
print("KeyboardInterrupt")
finally:
print("finally...")
loop.run_until_complete(listener.close())
loop.run_until_complete(pb.close())
def pushbullet(self) -> AsyncPushbullet:
current_key = self.key_var.get()
if self._pushbullet is not None:
if current_key != self._pushbullet.api_key:
self._pushbullet.close_all_threadsafe()
self._pushbullet = None
if self._pushbullet is None:
self._pushbullet = AsyncPushbullet(
api_key=current_key,
# loop=self.ioloop,
verify_ssl=False,
proxy=self.proxy)
return self._pushbullet
def get_pushbullet_client(cls):
try:
return cls._pushbullet_client
except AttributeError:
cls._pushbullet_client = AsyncPushbullet(api_key=conf.PB_API_KEY,
loop=LOOP)
return cls._pushbullet_client
def main():
proxy = os.environ.get("https_proxy") or os.environ.get("http_proxy")
pb = AsyncPushbullet(API_KEY, proxy=proxy)
async def _run():
devices = await pb.async_get_devices()
print("Devices:")
for d in devices:
print("\t", d.nickname)
# Name of a device?
if devices:
name = devices[0].nickname
this_device = await pb.async_get_device(nickname=name)
print("Retrieved device by it's name '{}': {}".format(
name, this_device))
# Do we have a device named foobar? Returns None if not found.
name = "foobar"
this_device = await pb.async_get_device(nickname=name)
print("Retrieved device by it's name '{}': {}".format(
name, this_device))
await pb.async_close()
loop = asyncio.get_event_loop()
loop.run_until_complete(_run())
async def _listen():
try:
self.pushbullet = AsyncPushbullet(self.key_var.get(),
verify_ssl=False,
proxy=self.proxy_var.get())
async with LiveStreamListener(self.pushbullet) as pl2:
self.pushbullet_listener = pl2
await self.connected(pl2)
async for push in pl2:
await self.push_received(push, pl2)
except Exception as ex:
print("Exception:", ex)
finally:
await self.disconnected(self.pushbullet_listener)
async def _run():
try:
async with AsyncPushbullet(API_KEY, proxy=PROXY) as pb:
msg["type"] = "asynchronous_example"
await pb.async_push_ephemeral(msg) # Asynchronous IO
# await pb.async_close()
except Exception as ex:
print("ERROR:", ex, file=sys.stderr, flush=True)
traceback.print_tb(sys.exc_info()[2])
async def run():
api_key = os.environ["PUSHBULLET_API_KEY"].strip()
# pb = await AsyncPushbullet(api_key=api_key).connect()
pb = AsyncPushbullet(api_key=api_key)
handler = AsyncPushbulletLogHandler(pb, level=logging.WARNING)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(handler)
logger.info("Normal stuff here.")
logger.warning("Warning stuff here.")
logger.warning("Warning 2")
print("Done")
await asyncio.sleep(2)
async def _listen():
try:
async with AsyncPushbullet(API_KEY, proxy=PROXY) as pb:
async with EphemeralComm(
pb, Msg) as ec: # type: EphemeralComm[Msg]
await q.put(ec)
print(await ec.next(.5))
print(await ec.next(.5))
print(await ec.next(.5))
await ec.close()
except Exception as ex:
print("ERROR:", type(ex), ex, file=sys.stderr, flush=True)
traceback.print_tb(sys.exc_info()[2])
finally:
print("AsyncPushbullet disconnected.", flush=True)
async def _listen():
asyncio.get_event_loop().set_debug(True)
try:
async with AsyncPushbullet(API_KEY,
proxy=PROXY) as self.pushbullet:
self.pause_btn.configure(state=tk.NORMAL)
self.pushes.clear()
# Two ways to handle GUI manipulation. Since these are
# just two-off commands, not in a loop, it doesn't matter
# very much which we use.
# Technique 1
# self.push_count_var.set(len(self.pushes))
# self.push_listbox.delete(0, tk.END)
# await asyncio.sleep(0)
# Technique 2
self.tk_schedule(self.push_count_var.set,
len(self.pushes))
self.tk_schedule(self.push_listbox.delete, 0, tk.END)
self.push_iterator = self.pushbullet.pushes_asynciter(
limit=None, modified_after=0.0, active_only=True)
async for push in self.push_iterator:
# As pushes are retrieved -- it will take several calls to pushbullet
# to retrieve the long history of pushes -- they are processed on
# this async for loop. Although the for loop obviously only processes
# one item at a time, they will come in bunches. When a network request
# is processed, a batch of pushes maybe 1 to 20 will fire through quickly.
# We immediately schedule processing on the main thread, since we'll
# be updating the GUI.
self.tk_schedule(_recv_push, push)
except Exception as ex:
print("Exception:", ex, file=sys.stderr, flush=True)
tb = sys.exc_info()[2]
traceback.print_tb(tb)
self.retrieve_btn.configure(state=tk.NORMAL)
self.pause_btn.configure(state=tk.DISABLED)
else:
self.retrieve_btn.configure(text="Completed")
self.pause_btn.configure(text="Completed")
self.retrieve_btn.configure(state=tk.DISABLED)
self.pause_btn.configure(state=tk.DISABLED)
self.tk_schedule(
self.push_count_var.set,
"{:,} (Completed)".format(len(self.pushes)))
async def _run():
try:
async with AsyncPushbullet(API_KEY, proxy=PROXY) as pb:
# List devices
devices = await pb.async_get_devices()
print("Devices:")
for dev in devices:
print("\t", dev)
# Send a push
push = await pb.async_push_note(title="Success",
body="I did it!")
print("Push sent:", push)
# Ways to listen for pushes
async with LiveStreamListener(pb) as lsl:
# This will retrieve the previous push because it occurred
# after the enclosing AsyncPushbullet connection was made
push = await lsl.next_push()
print("Previous push, now received:", push)
# Alternately get pushes with a 3 second inter-push timeout
print(
"Awaiting pushes with 3 second inter-push timeout...")
async for push in lsl.timeout(3):
print("Push received:", push)
# Alternately get pushes forever
print("Awaiting pushes forever...")
async for push in lsl:
print("Push received:", push)
except InvalidKeyError as ke:
print(ke, file=sys.stderr)
return EXIT_INVALID_KEY
except PushbulletError as pe:
print(pe, file=sys.stderr)
return EXIT_PUSHBULLET_ERROR
except Exception as ex:
print(ex, file=sys.stderr)
traceback.print_tb(sys.exc_info()[2])
return EXIT_OTHER
async def _run():
print("Connectiong to Pushbullet...", end="", flush=True)
try:
types_try_this = None
# types_try_this=("push",) # Default
# types_try_this=("tickle")
# types_try_this=("tickle", "push", "ephemeral")
# types_try_this=("nop",)
types_try_this = () # Everything
async with AsyncPushbullet(api_key=API_KEY, proxy=PROXY) as pb:
async with LiveStreamListener(pb, types=types_try_this) as lsl:
print("Connected.", flush=True)
# Wait indefinitely for pushes and other notifications
async for item in lsl:
print("Live stream item:", pprint.pformat(item))
except Exception as ex:
print("_run() exception:", ex)
print("Disconnected.", flush=True)
class PushApp():
def __init__(self, root):
self.window = root
root.title("Async Pushbullet Upload Demo")
self.log = logging.getLogger(__name__)
# Data
self.ioloop = None # type: asyncio.AbstractEventLoop
self.pushbullet = None # type: AsyncPushbullet
self.pushbullet_listener = None # type: LiveStreamListener
self.key_var = tk.StringVar() # API key
self.pushes_var = tk.StringVar()
self.filename_var = tk.StringVar()
self.btn_upload = None # type: tk.Button
self.proxy_var = tk.StringVar()
# View / Control
self.create_widgets()
# Connections
self.create_io_loop()
self.key_var.set(API_KEY)
self.filename_var.set(__file__)
self.proxy_var.set(PROXY)
def create_widgets(self):
"""
API Key: [ ]
<Connect>
Filename: [ ]
<Browse> <Upload>
Pushes:
+----------------------------+
| |
+----------------------------+
"""
row = 0
# API Key
lbl_key = tk.Label(self.window, text="API Key:")
lbl_key.grid(row=row, column=0, sticky=tk.W)
txt_key = tk.Entry(self.window, textvariable=self.key_var)
txt_key.grid(row=row, column=1, sticky=tk.W + tk.E)
tk.Grid.grid_columnconfigure(self.window, 1, weight=1)
txt_key.bind('<Return>', lambda x: self.connect_button_clicked())
row += 1
btn_connect = tk.Button(self.window, text="Connect", command=self.connect_button_clicked)
btn_connect.grid(row=row, column=1, sticky=tk.W)
row += 1
# Proxy, if we want to show it
# lbl_proxy = tk.Label(self.window, text="Proxy")
# lbl_proxy.grid(row=row, column=0, sticky=tk.W)
# txt_proxy = tk.Entry(self.window, textvariable=self.proxy_var)
# txt_proxy.grid(row=row, column=1, sticky=tk.W + tk.E)
# row += 1
# File: [ ]
lbl_file = tk.Label(self.window, text="File:")
lbl_file.grid(row=row, column=0, sticky=tk.W)
txt_file = tk.Entry(self.window, textvariable=self.filename_var)
txt_file.grid(row=row, column=1, sticky=tk.W + tk.E)
row += 1
# <Browse> <Upload>
button_frame = tk.Frame(self.window)
button_frame.grid(row=row, column=0, columnspan=2, sticky=tk.W + tk.E)
row += 1
btn_browse = tk.Button(button_frame, text="Browse...", command=self.browse_button_clicked)
btn_browse.grid(row=0, column=0, sticky=tk.E)
self.btn_upload = tk.Button(button_frame, text="Upload and Push", command=self.upload_button_clicked,
state=tk.DISABLED)
self.btn_upload.grid(row=0, column=1, sticky=tk.W)
# Incoming pushes
# +------------+
# | |
# +------------+
lbl_data = tk.Label(self.window, text="Incoming Pushes...")
lbl_data.grid(row=row, column=0, sticky=tk.W)
row += 1
txt_data = BindableTextArea(self.window, textvariable=self.pushes_var, width=80, height=10)
txt_data.grid(row=row, column=0, columnspan=2)
def create_io_loop(self):
"""Creates a new thread to manage an asyncio event loop specifically for IO to/from Pushbullet."""
assert self.ioloop is None # This should only ever be run once
def _run(loop):
asyncio.set_event_loop(loop)
loop.run_forever()
self.ioloop = asyncio.new_event_loop()
self.ioloop.set_exception_handler(self._ioloop_exc_handler)
threading.Thread(target=partial(_run, self.ioloop), name="Thread-asyncio", daemon=True).start()
def _ioloop_exc_handler(self, loop: asyncio.BaseEventLoop, context: dict):
if "exception" in context:
self.status = context["exception"]
self.status = str(context)
# Handle this more robustly in real-world code
def connect_button_clicked(self):
self.pushes_var.set("Connecting...")
self.close()
async def _listen():
try:
self.pushbullet = AsyncPushbullet(self.key_var.get(),
verify_ssl=False,
proxy=self.proxy_var.get())
async with LiveStreamListener(self.pushbullet) as pl2:
self.pushbullet_listener = pl2
await self.connected(pl2)
async for push in pl2:
await self.push_received(push, pl2)
except Exception as ex:
print("Exception:", ex)
finally:
await self.disconnected(self.pushbullet_listener)
asyncio.run_coroutine_threadsafe(_listen(), self.ioloop)
def close(self):
if self.pushbullet is not None:
self.pushbullet.close_all_threadsafe()
self.pushbullet = None
if self.pushbullet_listener is not None:
assert self.ioloop is not None
pl = self.pushbullet_listener
asyncio.run_coroutine_threadsafe(pl.close(), self.ioloop)
self.pushbullet_listener = None
def browse_button_clicked(self):
print("browse_button_clicked")
resp = filedialog.askopenfilename(parent=self.window, title="Open a File to Push")
if resp != "":
self.filename_var.set(resp)
def upload_button_clicked(self):
self.pushes_var.set(self.pushes_var.get() + "Uploading...")
self.btn_upload["state"] = tk.DISABLED
filename = self.filename_var.get()
asyncio.run_coroutine_threadsafe(self.upload_file(filename), loop=self.ioloop)
async def upload_file(self, filename: str):
# This is the actual upload command
info = await self.pushbullet.async_upload_file(filename)
# Push a notification of the upload "as a file":
await self.pushbullet.async_push_file(info["file_name"], info["file_url"], info["file_type"],
title="File Arrived!", body="Please enjoy your file")
# Push a notification of the upload "as a link":
await self.pushbullet.async_push_link("Link to File Arrived!", info["file_url"], body="Please enjoy your file")
self.btn_upload["state"] = tk.NORMAL
self.pushes_var.set(self.pushes_var.get() + "Uploaded\n")
async def connected(self, listener: LiveStreamListener):
self.btn_upload["state"] = tk.NORMAL
self.pushes_var.set(self.pushes_var.get() + "Connected\n")
async def disconnected(self, listener: LiveStreamListener):
self.btn_upload["state"] = tk.DISABLED
self.pushes_var.set(self.pushes_var.get() + "Disconnected\n")
async def push_received(self, p: dict, listener: LiveStreamListener):
print("Push received:", p)
prev = self.pushes_var.get()
prev += "{}\n\n".format(p)
self.pushes_var.set(prev)
def main():
""" Uses a callback scheduled on an event loop"""
pb = AsyncPushbullet(API_KEY, verify_ssl=False, proxy=PROXY)
loop = asyncio.get_event_loop()
loop.run_until_complete(upload_file(pb, __file__)) # Upload this source code file as an example
async def _run(args):
# Logging levels
if args.debug: # Debug?
print("Log level: DEBUG")
logging.basicConfig(level=logging.DEBUG)
elif args.verbose: # Verbose?
print("Log level: INFO")
logging.basicConfig(level=logging.INFO)
# Clear the oauth2 token?
if args.clear_oauth2:
oauth2.clear_oauth2_key()
print("Successfully cleared/unregistered the oauth2 token.")
print("The asyncpushbullet command line tools no longer have access to your pushbullet account.")
sys.exit(errors.__EXIT_NO_ERROR__)
# Request setting up oauth2 access?
if args.oauth2:
token = await oauth2.async_gain_oauth2_access()
if token:
print("Successfully authenticated using OAuth2.")
print("You should now be able to use the command line tools without specifying an API key.")
sys.exit(errors.__EXIT_NO_ERROR__)
else:
print("There was a problem authenticating.")
sys.exit(errors.__ERR_UNKNOWN__)
# Find a valid API key
api_key = try_to_find_key(args, not args.quiet)
if api_key is None:
print("You must specify an API key.", file=sys.stderr)
sys.exit(errors.__ERR_API_KEY_NOT_GIVEN__)
# Proxy
proxy = lambda: args.proxy or os.environ.get("https_proxy") or os.environ.get("http_proxy")
# List devices?
if args.list_devices:
print("Devices:")
try:
_proxy = proxy() if callable(proxy) else proxy
async with AsyncPushbullet(api_key, proxy=_proxy) as pb:
async for dev in pb.devices_asynciter():
print("\t", dev.nickname)
except InvalidKeyError as exc:
print(exc, file=sys.stderr)
return errors.__ERR_INVALID_API_KEY__
except PushbulletError as exc:
print(exc, file=sys.stderr)
return errors.__ERR_CONNECTING_TO_PB__
else:
# sys.exit(0)
return errors.__EXIT_NO_ERROR__
# Throttle
throttle_count = args.throttle_count
throttle_seconds = args.throttle_seconds
# Device
device = args.device
# Timeout
timeout = DEFAULT_COMMAND_TIMEOUT
if args.timeout:
timeout = float(args.timeout)
# Create ListenApp
listen_app = ListenApp(api_key,
proxy=proxy,
throttle_count=throttle_count,
throttle_seconds=throttle_seconds,
device=device,
timeout=timeout)
# Windows needs special event loop in order to launch processes on it
proc_loop: asyncio.BaseEventLoop
if sys.platform == 'win32':
proc_loop = asyncio.ProactorEventLoop()
else:
proc_loop = asyncio.new_event_loop() # Processes
asyncio.get_child_watcher() # Main loop
def _thread_run(loop):
asyncio.set_event_loop(loop)
loop.run_forever()
threading.Thread(target=partial(_thread_run, proc_loop), name="Thread-proc", daemon=True).start()
# Add actions from command line arguments
if args.exec:
for cmd_opts in args.exec:
cmd_path = cmd_opts[0]
cmd_args = cmd_opts[1:]
action = ExecutableAction(cmd_path, cmd_args, loop=proc_loop, timeout=timeout)
listen_app.add_action(action)
# Add actions from command line arguments
if args.exec_simple:
for cmd_opts in args.exec_simple:
cmd_path = cmd_opts[0]
cmd_args = cmd_opts[1:]
action = ExecutableActionSimplified(cmd_path, cmd_args, loop=proc_loop, timeout=timeout)
listen_app.add_action(action)
# Add actions from command line arguments
if args.exec_python:
for cmd_opts in args.exec_python:
cmd_path = cmd_opts[0]
action = ExecutableActionPython(cmd_path)
listen_app.add_action(action)
# Echo
if args.echo:
listen_app.add_action(EchoAction())
# Default action if none specified
if not listen_app._actions:
print("No actions specified -- defaulting to Echo.")
listen_app.add_action(EchoAction())
exit_code: int = None
try:
exit_code = await listen_app.run()
except KeyboardInterrupt:
print("Caught keyboard interrupt")
finally:
await listen_app.close()
if exit_code is None:
exit_code = errors.__EXIT_NO_ERROR__
return exit_code
async def run(self):
exit_code = 0
while self.persistent_connection:
try:
# Live update the proxy setting
_proxy = self.proxy() if callable(self.proxy) else self.proxy
if _proxy:
self.log.info("Proxy: {}".format(_proxy))
print("Connecting to pushbullet...", end="", flush=True)
async with AsyncPushbullet(api_key=self.api_key, proxy=_proxy) as pb:
self._account = pb
# If filtering on device, find or create device with that name
if self.device_name is not None:
dev = await pb.async_get_device(nickname=self.device_name)
if dev is None:
dev = await pb.async_new_device(nickname=self.device_name)
if dev is None:
self.log.error("Device {} was not found and could not be created.")
else:
self.log.info("Device {} was not found, so we created it.".format(self.device_name))
async with LiveStreamListener(pb, only_this_device_nickname=self.device_name) as lsl:
print("Connected.", flush=True)
self.log.info("Connected to Pushbullet websocket.")
self._listener = lsl
if self.device_name is None:
print("Awaiting pushes...")
else:
print("Awaiting pushes to device {}...".format(self.device_name))
async for push in lsl:
self.log.info("Received push (title={}, body={}) {}"
.format(push.get("title"), push.get("body"), push))
print("Received push (title={}, body={})"
.format(push.get("title"), push.get("body")))
await self._throttle()
if push.get("iden") in self._sent_push_idens:
# This is one we sent - ignore it
self.log.debug(
"Ignoring an incoming push that we sent. (iden={})".format(push.get('iden')))
continue
async def _call_on_push(_action: Action):
self.log.info("Calling action {}".format(repr(_action)))
try:
await asyncio.wait_for(_action.on_push(push, self.wrapped_account),
timeout=self.action_timeout)
await asyncio.sleep(0)
except asyncio.TimeoutError as te:
err_msg = "Action {} timed out after {}+ seconds".format(_action,
self.action_timeout)
await pb.async_push_note(title="AsyncPushbullet Error", body=err_msg)
if not self.log.isEnabledFor(logging.DEBUG):
err_msg += " (turn on --debug to see traceback)"
self.log.warning(err_msg)
if self.log.isEnabledFor(logging.DEBUG):
traceback.print_tb(sys.exc_info()[2])
del err_msg
except Exception as ex:
err_msg = "Action {} caused exception {}".format(_action, ex)
await pb.async_push_note(title="AsyncPushbullet Error", body=err_msg)
if not self.log.isEnabledFor(logging.DEBUG):
err_msg += " (turn on --debug to see traceback)"
self.log.warning(err_msg)
if self.log.isEnabledFor(logging.DEBUG):
traceback.print_tb(sys.exc_info()[2])
del err_msg
finally:
self.log.debug("Leaving action {}".format(repr(_action)))
for a in self._actions:
asyncio.get_event_loop().create_task(_call_on_push(a))
except InvalidKeyError as ex:
print(flush=True)
exit_code = errors.__ERR_INVALID_API_KEY__
self.log.warning(ex)
self.persistent_connection = False # Invalid key results in immediate exit
except Exception as ex:
print(flush=True)
err_msg = "{}: {}".format(ex.__class__.__name__, ex)
if not self.log.isEnabledFor(logging.DEBUG):
err_msg += " (turn on --debug to see traceback)"
self.log.warning(err_msg)
if self.log.isEnabledFor(logging.DEBUG):
traceback.print_tb(sys.exc_info()[2])
exit_code = errors.__ERR_UNKNOWN__ # exit code
else:
print("Connection closed.")
finally:
if self.persistent_connection:
print("Waiting {} seconds to try again...".format(self.persistent_connection_wait_interval),
flush=True)
await asyncio.sleep(self.persistent_connection_wait_interval)
return exit_code
def main():
recvd_push = json.loads(sys.stdin.read()) # Throw whatever exceptions to stderr
if recvd_push.get("body", "").lower().strip() == "imagesnap":
# Temp file to house the image file
temp_img = tempfile.NamedTemporaryFile(delete=False, suffix=".jpg")
temp_img.close()
try:
# Take a picture and upload
# PRETEND TO TAKE A PICTURE
import shutil
fakepic = os.path.join(os.path.dirname(os.path.abspath(__file__)), "snapshot.jpg")
shutil.copy(fakepic, temp_img.name)
# Take a picture
# proc = subprocess.run(["imagesnap", temp_img.name],
proc = subprocess.run(["notepad.exe"], # Debugging
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
timeout=10,
encoding=ENCODING)
# Upload picture
with AsyncPushbullet(API_KEY, proxy=PROXY) as pb:
# resp = pb.upload_file(temp_img.name) # Upload here
resp = pb.upload_file_to_transfer_sh(temp_img.name) # Upload here
del pb
file_type = resp.get("file_type")
file_url = resp.get("file_url")
file_name = resp.get("file_name")
# Provide a response via stdout
stdout_txt = proc.stdout
stderr_txt = proc.stderr
myresp = {
"type": "file",
"title": "Imagesnap",
"body": "{}\n{}".format(stdout_txt, stderr_txt).strip(),
"file_name": file_name,
"file_type": file_type,
"file_url": file_url,
"received_push": recvd_push
}
dev_iden = recvd_push.get("source_device_iden")
if dev_iden is not None:
myresp["device_iden"] = dev_iden
with open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "response.json"), "w") as fout:
fout.write(json.dumps(myresp, indent=4))
print(json.dumps(myresp), flush=True)
except Exception as e:
# raise e
print("Error:", e, file=sys.stderr)
finally:
os.remove(temp_img.name)
async def run_cmd_server(cmd, args: List = None):
print("Remote command server.", flush=True)
loop = asyncio.get_event_loop()
args = args or []
try:
key = oauth2.get_oauth2_key()
async with AsyncPushbullet(key, proxy=PROXY) as pb:
stdout_queue = asyncio.Queue()
stderr_queue = asyncio.Queue()
async with EphemeralComm(pb,
CMsg) as ec: # type: EphemeralComm[CMsg]
# msg = {"type": "console", "status": "command server connected to pushbullet"}
# await pb.async_push_ephemeral(msg)
kmsg = CMsg(status="command server connected to pushbullet")
await ec.send(kmsg)
async def _output_flusher(_q, name):
# name is from_stdout or from_stderr
while True:
lines = []
while len(lines) < 20:
line: bytes
try:
if lines:
# If we have something to send, wait only a moment
# to see if there's anything else coming.
# print("Waiting with timeout", name)
line = await asyncio.wait_for(_q.get(),
timeout=0.25)
else:
# print("Waiting without timeout", name)
# If we have an empty queue, no need for the timeout
line = await _q.get()
except asyncio.TimeoutError:
# print("TE")
break
# break # while loop for length of lines
else:
# print(f"{name}: {line}")
if line is None:
# print(f"{name} output flusher on server done!")
# return # We're done!
lines.append(None)
break
else:
line = line.decode().rstrip()
lines.append(line)
# print(f"{name} server LINES:", lines)
if lines:
try:
# msg = {"type": "console", name: lines}
# await pb.async_push_ephemeral(msg)
if name == "from_stdout":
kmsg = CMsg(from_stdout=lines)
await ec.send(kmsg)
elif name == "from_stderr":
kmsg = CMsg(from_stderr=lines)
await ec.send(kmsg)
if lines[-1] is None:
# print(f"{name} found None - output flusher is returning")
return # We're done
except Exception as ex:
print("ERROR:",
ex,
file=sys.stderr,
flush=True)
traceback.print_tb(sys.exc_info()[2])
t1 = loop.create_task(
_output_flusher(stdout_queue, "from_stdout"))
t2 = loop.create_task(
_output_flusher(stderr_queue, "from_stderr"))
# async with LiveStreamListener(pb, types="ephemeral:console") as lsl:
await async_execute_command(
cmd,
args,
provide_stdin=LiveStreamCommandListener(ec),
handle_stderr=stderr_queue.put,
# handle_stdout=print)
handle_stdout=stdout_queue.put)
# print("ADDING None TO BOTH OUTPUT QUEUES")
await stdout_queue.put(
None) # mark that we're done for the output flushers
await stderr_queue.put(None) # mark that we're done
await asyncio.gather(t1, t2)
# print("SERVER asyncpush WITH BLOCK EXITED")
except Exception as ex:
print("ERROR:", ex, file=sys.stderr, flush=True)
traceback.print_tb(sys.exc_info()[2])
finally:
print("Server tool closing ... ", end="", flush=True)
print("Closed.", flush=True)
async def run_console():
# Read console input from input() and write to pushbullet
# Echo pushbullet from_stdout through print()
print("Starting console for connecting with remote server", flush=True)
stdout_task = None # type: asyncio.Task
try:
key = oauth2.get_oauth2_key()
async with AsyncPushbullet(key, proxy=PROXY) as pb:
async with EphemeralComm(pb,
CMsg) as ec: # type: EphemeralComm[CMsg]
# msg = {"type": "console", "status": "Console input connected to pushbullet"}
# await pb.async_push_ephemeral(msg)
kmsg = CMsg(status="Console input connected to pushbullet")
await ec.send(kmsg)
async with AsyncReadConsole("cmd input: ") as arc:
async def _dump_stdout():
try:
remote_stdout_closed = False
remote_stderr_closed = False
async for kmsg in ec.with_timeout(
10, break_on_timeout=False):
if kmsg is None:
# print("TIMEDOUT")
if remote_stderr_closed or remote_stdout_closed:
# We received a close from one but not the other. Just quit.
print("Remote command exited.",
flush=True)
await ec.close() # TODO: error here
# break
continue
for line in kmsg.from_stdout:
if line is None:
# print("stdout closed.")
remote_stdout_closed = True
else:
print(line, flush=True)
for line in kmsg.from_stderr:
if line is None:
# print("stderr closed.")
remote_stderr_closed = True
else:
print(line,
file=sys.stderr,
flush=True)
if remote_stdout_closed and remote_stderr_closed:
print("Remote command exited.", flush=True)
await ec.close()
# print("end: async for kmsg in ec")
except Exception as ex:
print("ERROR in _dump_stdout:",
ex,
file=sys.stderr,
flush=True)
traceback.print_tb(sys.exc_info()[2])
finally:
print('FINALLY: closing arc')
await arc.close()
print("arc.close() returned")
stdout_task = asyncio.get_event_loop().create_task(
_dump_stdout())
async for line in arc:
if line is None:
assert line is not None, "This should never happen"
break
else:
# msg = {"type": "console", "for_stdin": line}
# await pb.async_push_ephemeral(msg)
# print("Sending command: " + line)
kmsg = CMsg(for_stdin=[line])
await ec.send(kmsg)
print("exited async for line in arc:")
except Exception as ex:
print("ERROR in run_console:", ex, file=sys.stderr, flush=True)
traceback.print_tb(sys.exc_info()[2])
finally:
print("Console tool closing ... ", end="", flush=True)
if stdout_task:
stdout_task.cancel()
print("Closed.", flush=True)
from asyncpushbullet import AsyncPushbullet
from config import *
pb = AsyncPushbullet(PUSHBULLET)
push = await pb.async_push_note("Title","Body")
class PushApp():
def __init__(self, root):
self.window = root
root.title("Async Pushbullet Demo")
self.log = logging.getLogger(__name__)
# Data
self.pushbullet = None # type: AsyncPushbullet
self.pushbullet_listener = None # type: LiveStreamListener
self.key_var = tk.StringVar() # API key
self.pushes_var = tk.StringVar()
self.ioloop = None # type: asyncio.BaseEventLoop
self.proxy_var = tk.StringVar()
# View / Control
self.create_widgets()
# Connections
self.create_io_loop()
self.key_var.set(API_KEY)
self.proxy_var.set(PROXY)
def create_widgets(self):
"""
API Key: [ ]
<Connect>
Pushes:
+----------------------------+
| |
+----------------------------+
"""
# API Key
lbl_key = tk.Label(self.window, text="API Key:")
lbl_key.grid(row=0, column=0, sticky=tk.W)
txt_key = tk.Entry(self.window, textvariable=self.key_var)
txt_key.grid(row=0, column=1, sticky=tk.W + tk.E)
tk.Grid.grid_columnconfigure(self.window, 1, weight=1)
txt_key.bind('<Return>', lambda x: self.connect_button_clicked())
btn_connect = tk.Button(self.window,
text="Connect",
command=self.connect_button_clicked)
btn_connect.grid(row=1, column=1, sticky=tk.W)
btn_disconnect = tk.Button(self.window,
text="Disconnect",
command=self.disconnect_button_clicked)
btn_disconnect.grid(row=2, column=1, sticky=tk.W)
lbl_data = tk.Label(self.window, text="Incoming Pushes...")
lbl_data.grid(row=4, column=0, sticky=tk.W)
txt_data = BindableTextArea(self.window,
textvariable=self.pushes_var,
width=80,
height=10)
txt_data.grid(row=5, column=0, columnspan=2, sticky="NSEW")
tk.Grid.grid_rowconfigure(self.window, 5, weight=1)
def connect_button_clicked(self):
self.close()
async def _listen():
try:
self.pushbullet = AsyncPushbullet(self.key_var.get(),
verify_ssl=False,
proxy=self.proxy_var.get())
async with LiveStreamListener(self.pushbullet) as pl2:
self.pushbullet_listener = pl2
await self.connected(pl2)
async for push in pl2:
await self.push_received(push, pl2)
except Exception as ex:
print("Exception:", ex)
finally:
await self.disconnected(self.pushbullet_listener)
asyncio.run_coroutine_threadsafe(_listen(), self.ioloop)
def create_io_loop(self):
"""Creates a new thread to manage an asyncio event loop specifically for IO to/from Pushbullet."""
assert self.ioloop is None # This should only ever be run once
def _run(loop):
asyncio.set_event_loop(loop)
loop.run_forever()
self.ioloop = asyncio.new_event_loop()
self.ioloop.set_exception_handler(self._ioloop_exc_handler)
threading.Thread(target=partial(_run, self.ioloop),
name="Thread-asyncio",
daemon=True).start()
def _ioloop_exc_handler(self, loop: asyncio.BaseEventLoop, context: dict):
if "exception" in context:
self.status = context["exception"]
self.status = str(context)
# Handle this more robustly in real-world code
def close(self):
if self.pushbullet is not None:
self.pushbullet.close_all_threadsafe()
self.pushbullet = None
if self.pushbullet_listener is not None:
assert self.ioloop is not None
pl = self.pushbullet_listener
asyncio.run_coroutine_threadsafe(pl.close(), self.ioloop)
self.pushbullet_listener = None
def disconnect_button_clicked(self):
self.close()
async def connected(self, listener: LiveStreamListener):
print("Connected to websocket")
async def disconnected(self, listener: LiveStreamListener):
print("Disconnected from websocket")
async def push_received(self, p: dict, listener: LiveStreamListener):
print("Push received:", p)
prev = self.pushes_var.get()
prev += "{}\n\n".format(p)
self.pushes_var.set(prev)
async def _run(args):
# Logging levels
if args.debug: # Debug?
print("Log level: DEBUG")
logging.basicConfig(level=logging.DEBUG)
elif args.verbose: # Verbose?
print("Log level: INFO")
logging.basicConfig(level=logging.INFO)
# Request setting up oauth2 access?
if args.oauth2:
token = await oauth2.async_gain_oauth2_access()
if token:
print("Successfully authenticated using OAuth2.")
print(
"You should now be able to use the command line tools without specifying an API key."
)
sys.exit(0)
else:
print("There was a problem authenticating.")
sys.exit(1)
# Find a valid API key
api_key = try_to_find_key(args, not args.quiet)
if api_key is None:
print("You must specify an API key.", file=sys.stderr)
sys.exit(errors.__ERR_API_KEY_NOT_GIVEN__)
# Proxy
proxy = lambda: args.proxy or os.environ.get(
"https_proxy") or os.environ.get("http_proxy")
try:
# List devices?
if args.list_devices:
print("Devices:")
async with AsyncPushbullet(api_key, proxy=proxy()) as pb:
async for dev in pb.devices_asynciter():
print("\t", dev.nickname)
return errors.__EXIT_NO_ERROR__
# Specify a device?
target_device = None # type: Device
if args.device:
async with AsyncPushbullet(api_key, proxy=proxy()) as pb:
target_device = await pb.async_get_device(nickname=args.device)
if target_device is None:
print("Device not found:", args.device, file=sys.stderr)
return errors.__ERR_DEVICE_NOT_FOUND__
else:
print("Target device:", target_device.nickname)
# Transfer single file?
if getattr(args, "file", False):
async with AsyncPushbullet(api_key, proxy=proxy()) as pb:
return await _transfer_file(pb=pb,
file_path=args.file,
use_transfer_sh=args.transfer_sh,
quiet=args.quiet,
title=args.title,
body=args.body,
target_device=target_device)
elif getattr(args, "files", False):
async with AsyncPushbullet(api_key, proxy=proxy()) as pb:
for file_path in args.files: # type str
_ = await _transfer_file(pb=pb,
file_path=file_path,
use_transfer_sh=args.transfer_sh,
quiet=args.quiet,
title=args.title,
body=args.body,
target_device=target_device)
# Push note
elif args.title or args.body:
async with AsyncPushbullet(api_key, proxy=proxy()) as pb:
if args.body is not None and args.body == "-":
body = sys.stdin.read().rstrip()
else:
body = args.body
url = args.url
if url is None:
if not args.quiet:
print("Pushing note...", end="", flush=True)
_ = await pb.async_push_note(title=args.title,
body=body,
device=target_device)
if not args.quiet:
print("Done.", flush=True)
else:
if not args.quiet:
print("Pushing link...")
_ = await pb.async_push_link(title=args.title,
url=url,
body=body,
device=target_device)
if not args.quiet:
print("Done.", flush=True)
else:
print("Nothing to do.")
return errors.__ERR_NOTHING_TO_DO__
except InvalidKeyError as exc:
print(exc, file=sys.stderr)
return errors.__ERR_INVALID_API_KEY__
except PushbulletError as exc:
print(exc, file=sys.stderr)
return errors.__ERR_CONNECTING_TO_PB__
class GuiToolApp(TkAsyncioBaseApp):
def __init__(self, root):
super().__init__(root)
self.window = root
root.title("Pushbullet Account Management")
self.log = logging.getLogger(__name__)
# Data
self._pushbullet = None # type: AsyncPushbullet
self.pushbullet_listener = None # type: LiveStreamListener
self.key_var = tk.StringVar() # type: tk.StringVar # API key
self.pushes_var = tk.StringVar(
) # type: tk.StringVar # Used in text box to display pushes received
self.status_var = tk.StringVar(
) # type: tk.StringVar # Bound to bottom of window status bar
self.proxy = os.environ.get("https_proxy") or os.environ.get(
"http_proxy") # type: str
# Related to Devices
self.device_detail_var = tk.StringVar(
) # type: tk.StringVar # Used in text box to display device details
self.devices_in_listbox = None # type: Tuple[Device] # Cached devices that were retrieved
self.device_tab_index = None # type: int # The index for the Devices tab
# View / Control
self.btn_connect = None # type: tk.Button
self.btn_disconnect = None # type: tk.Button
self.lb_device = None # type: tk.Listbox
self.btn_load_devices = None # type: tk.Button
self.lbl_photo = None # type: tk.Label
self.lbl_status = None # type: tk.Label
self.create_widgets()
# Connections / Bindings
tkinter_tools.bind_tk_var_to_method(partial(PREFS.set, "api_key"),
self.key_var)
self.key_var.set(API_KEY)
@property
def status(self):
return str(self.status_var.get())
@status.setter
def status(self, val):
self.tk(self.status_var.set, val)
@property
def pushbullet(self) -> AsyncPushbullet:
current_key = self.key_var.get()
if self._pushbullet is not None:
if current_key != self._pushbullet.api_key:
self._pushbullet.close_all_threadsafe()
self._pushbullet = None
if self._pushbullet is None:
self._pushbullet = AsyncPushbullet(
api_key=current_key,
# loop=self.ioloop,
verify_ssl=False,
proxy=self.proxy)
return self._pushbullet
@pushbullet.setter
def pushbullet(self, val: AsyncPushbullet):
if val is None and self._pushbullet is not None:
self._pushbullet.close_all_threadsafe()
self._pushbullet = val
def ioloop_exception_happened(self, extype, ex, tb, func):
self.status = ex
def create_widgets(self):
parent = self.window
# API Key
frm_key = tk.Frame(parent)
frm_key.grid(row=0, column=0, sticky="NSEW")
lbl_key = tk.Label(frm_key, text="API Key:")
lbl_key.grid(row=0, column=0, sticky=tk.W)
txt_key = tk.Entry(frm_key, textvariable=self.key_var)
txt_key.grid(row=0, column=1, sticky=tk.W + tk.E, columnspan=2)
btn_oauth2 = tk.Button(frm_key, text="Authenticate online...")
btn_oauth2.configure(command=partial(self.oauth2_clicked, btn_oauth2))
btn_oauth2.grid(row=0, column=2, sticky=tk.W)
tk.Grid.grid_columnconfigure(frm_key, 1, weight=1)
tk.Grid.grid_columnconfigure(parent, 0, weight=1)
# Top level notebook
notebook = ttk.Notebook(parent)
notebook.grid(row=1, column=0, sticky="NSEW", columnspan=2)
# tk.Grid.grid_columnconfigure(parent, 0, weight=1)
tk.Grid.grid_rowconfigure(parent, 1, weight=1)
notebook.bind("<<NotebookTabChanged>>", self.notebook_tab_changed)
# Status line
status_line = tk.Frame(parent, borderwidth=2, relief=tk.GROOVE)
status_line.grid(row=999, column=0, sticky="EW", columnspan=2)
self.lbl_photo = tk.Label(
status_line) # , text="", width=16, height=16)
self.lbl_photo.grid(row=0, column=0, sticky=tk.W)
self.lbl_status = tk.Label(status_line, textvar=self.status_var)
self.lbl_status.grid(row=0, column=1, sticky=tk.W)
# Tab: Pushes
pushes_frame = tk.Frame(notebook)
notebook.add(pushes_frame, text="Pushes")
self.create_widgets_pushes(pushes_frame)
# Tab: Devices
devices_frame = tk.Frame(notebook)
notebook.add(devices_frame, text="Devices")
self.device_tab_index = notebook.index(
tk.END) - 1 # save tab pos for later
self.create_widgets_devices(devices_frame)
def create_widgets_pushes(self, parent: tk.Frame):
self.btn_connect = tk.Button(parent,
text="Connect",
command=self.connect_button_clicked)
self.btn_connect.grid(row=0, column=0, sticky=tk.W)
self.btn_disconnect = tk.Button(parent,
text="Disconnect",
command=self.disconnect_button_clicked)
self.btn_disconnect.grid(row=0, column=1, sticky=tk.W)
self.btn_disconnect.configure(state=tk.DISABLED)
btn_clear = tk.Button(parent,
text="Clear",
command=partial(self.pushes_var.set, ""))
btn_clear.grid(row=0, column=2)
txt_data = tkinter_tools.BindableTextArea(parent,
textvariable=self.pushes_var,
width=60,
height=20)
txt_data.grid(row=1, column=0, sticky="NSEW", columnspan=3)
tk.Grid.grid_columnconfigure(parent, 0, weight=1)
tk.Grid.grid_columnconfigure(parent, 1, weight=1)
tk.Grid.grid_rowconfigure(parent, 1, weight=1)
def create_widgets_devices(self, parent: tk.Frame):
scrollbar = tk.Scrollbar(parent, orient=tk.VERTICAL)
self.lb_device = tk.Listbox(parent, yscrollcommand=scrollbar.set)
scrollbar.config(command=self.lb_device.yview)
self.lb_device.grid(row=0, column=0, sticky="NSEW")
self.lb_device.bind("<Double-Button-1>",
self.device_list_double_clicked)
self.btn_load_devices = tk.Button(parent,
text="Load Devices",
command=self.load_devices_clicked)
self.btn_load_devices.grid(row=1, column=0, sticky="EW")
txt_device_details = tkinter_tools.BindableTextArea(
parent, textvariable=self.device_detail_var, width=80, height=10)
txt_device_details.grid(row=0, column=1, sticky="NSEW")
tk.Grid.grid_columnconfigure(parent, 1, weight=1)
tk.Grid.grid_rowconfigure(parent, 0, weight=1)
# ######## G U I E V E N T S ########
def notebook_tab_changed(self, event):
nb = event.widget # type: ttk.Notebook
index = nb.index("current")
if index == self.device_tab_index:
# If there are no devices loaded, go ahead and try
if self.devices_in_listbox is None:
self.load_devices_clicked()
def oauth2_clicked(self, btn: tk.Button):
btn.configure(state=tk.DISABLED)
self.status = "Authenticating online using OAuth2..."
async def _auth():
token = await oauth2.async_gain_oauth2_access()
if token:
self.tk(self.key_var.set, token)
self.status = "Authentication using OAuth2 succeeded."
else:
self.status = "Authentication using OAuth2 failed."
btn.configure(state=tk.NORMAL)
self.io(_auth())
def connect_button_clicked(self):
self.status = "Connecting to Pushbullet..."
self.btn_connect.configure(state=tk.DISABLED)
self.btn_disconnect.configure(state=tk.DISABLED)
if self.pushbullet is not None:
self.pushbullet = None
if self.pushbullet_listener is not None:
pl = self.pushbullet_listener # type: LiveStreamListener
if pl is not None:
self.io(pl.close())
self.pushbullet_listener = None
async def _listen():
pl2 = None # type: LiveStreamListener
try:
await self.verify_key()
async with LiveStreamListener(self.pushbullet,
types=()) as pl2:
self.pushbullet_listener = pl2
await self.pushlistener_connected(pl2)
async for push in pl2:
await self.push_received(push, pl2)
except Exception as ex:
pass
print("guitool _listen caught exception", ex)
finally:
# if pl2 is not None:
await self.pushlistener_closed(pl2)
self.io(_listen())
def disconnect_button_clicked(self):
self.status = "Disconnecting from Pushbullet..."
self.io(self.pushbullet_listener.close())
def load_devices_clicked(self):
self.btn_load_devices.configure(state=tk.DISABLED)
self.status = "Loading devices..."
self.lb_device.delete(0, tk.END)
self.lb_device.insert(tk.END, "Loading...")
self.devices_in_listbox = None
async def _load():
try:
await self.verify_key()
self.devices_in_listbox = tuple(
await self.pushbullet.async_get_devices())
self.tk(self.lb_device.delete, 0, tk.END)
for dev in self.devices_in_listbox:
self.tk(self.lb_device.insert, tk.END, str(dev.nickname))
self.status = "Loaded {} devices".format(
len(self.devices_in_listbox))
except Exception as ex:
self.tk(self.lb_device.delete, 0, tk.END)
self.status = "Error retrieving devices: {}".format(ex)
raise ex
finally:
self.tk(self.btn_load_devices.configure, state=tk.NORMAL)
# asyncio.run_coroutine_threadsafe(_load(), self.ioloop)
self.io(_load())
def device_list_double_clicked(self, event):
items = self.lb_device.curselection()
if len(items) == 0:
print("No item selected")
return
if self.devices_in_listbox is None:
print("No devices have been loaded")
device = self.devices_in_listbox[int(items[0])]
self.device_detail_var.set(repr(device))
# ######## C A L L B A C K S ########
async def pushlistener_connected(self, listener: LiveStreamListener):
self.status = "Connected to Pushbullet"
try:
me = await self.pushbullet.async_get_user()
self.status = "Connected to Pushbullet: {}".format(me.get("name"))
except Exception as ex:
# print("To include image support: pip install pillow")
pass
finally:
self.tk(self.btn_connect.configure, state=tk.DISABLED)
self.tk(self.btn_disconnect.configure, state=tk.NORMAL)
async def pushlistener_closed(self, listener: LiveStreamListener):
# print_function_name()
self.status = "Disconnected from Pushbullet"
self.tk(self.btn_connect.configure, state=tk.NORMAL)
self.tk(self.btn_disconnect.configure, state=tk.DISABLED)
async def push_received(self, p: dict, listener: LiveStreamListener):
# print("Push received:", p)
push_type = p.get("type")
if push_type == "push":
push_type = "ephemeral"
prev = self.pushes_var.get()
prev += "Type: {}\n{}\n\n".format(push_type, pprint.pformat(p))
self.tk(self.pushes_var.set, prev)
# ######## O T H E R ########
async def verify_key(self):
self.status = "Verifying API key..."
api_key = self.key_var.get()
try:
await self.pushbullet.async_verify_key()
self.status = "Valid API key: {}".format(api_key)
if getattr(self.lbl_photo, "image_ref", None) is None:
async def _load_pic():
try:
me = await self.pushbullet.async_get_user()
if "image_url" in me:
image_url = me.get("image_url")
try:
msg = await self.pushbullet._async_get_data(
image_url)
except Exception as ex_get:
self.log.info(
"Could not retrieve user photo from url {}"
.format(image_url))
else:
photo_bytes = io.BytesIO(msg.get("raw"))
img = Image.open(photo_bytes)
label_size = self.lbl_photo.winfo_height()
img = img.resize((label_size, label_size),
Image.ANTIALIAS)
photo = PhotoImage(img)
self.tk(self.lbl_photo.configure, image=photo)
self.lbl_photo.image_ref = photo # Save for garbage collection protection
self.log.info(
"Loaded user image from url {}".format(
image_url))
except Exception as ex:
# print(ex)
print("To include image support: pip install pillow")
# ex.with_traceback()
# raise ex
asyncio.get_event_loop().create_task(_load_pic())
except Exception as e:
self.status = "Invalid API key: {}".format(api_key)
self.tk(self.lbl_photo.configure, image="")
self.lbl_photo.image_ref = None
raise e