h2o-wave 0.26.3__py3-none-any.whl → 1.0.1__py3-none-any.whl

h2o_wave/__init__.py

@@ -30,8 +30,8 @@ realtime state synchronization between Python and web browsers.
 .. include:: ../../docs/index.md
 """
 from .core import Site, AsyncSite, site, Page, Ref, data, pack, Expando, expando_to_dict, clone_expando, copy_expando
-from .server import listen, Q, app, main
-from .routing import on, handle_on
+from .server import Q, app, main
+from .routing import on, handle_on, run_on
 from .db import connect, WaveDBConnection, WaveDB, WaveDBError
 from .types import *
 from .test import cypress, Cypress

h2o_wave/cli.py

@@ -25,6 +25,7 @@ from contextlib import closing
 from pathlib import Path
 from urllib import request
 from urllib.parse import urlparse
+import webbrowser
 
 import click
 import httpx
@@ -75,6 +76,22 @@ def safe_extract(tar, path=".", members=None, *, numeric_owner=False):
     tar.extractall(path, members, numeric_owner=numeric_owner)
 
 
+def _print_launch_bar(local: str, remote: str):
+    logo = ''' _       _____ _    ________   _____ __  _____    ____  ______
+| |     / /   | |  / / ____/  / ___// / / /   |  / __ \/ ____/
+| | /| / / /| | | / / __/     \__ \/ /_/ / /| | / /_/ / __/
+| |/ |/ / ___ | |/ / /___    ___/ / __  / ___ |/ _, _/ /___
+|__/|__/_/  |_|___/_____/   /____/_/ /_/_/  |_/_/ |_/_____/
+    '''
+    message = f'Sharing {local} ==> {remote}'
+    bar = "─" * (len(message) + 4)
+    print(logo)
+    print('┌' + bar + '┐')
+    print('│  ' + message + '  │')
+    print('└' + bar + '┘\n')
+    print('\x1b[7;30;43mDO NOT SHARE IF YOUR APP CONTAINS SENSITIVE INFO\x1b[0m')
+
+
 @click.group()
 def main():
     pass
@@ -108,8 +125,6 @@ def run(app: str, no_reload: bool, no_autostart: bool):
     port = app_address.port
 
     addr = f'http://{host}:{port}'
-    os.environ['H2O_WAVE_INTERNAL_ADDRESS'] = addr  # TODO deprecated
-    os.environ['H2O_WAVE_EXTERNAL_ADDRESS'] = addr  # TODO deprecated
     os.environ['H2O_WAVE_APP_ADDRESS'] = addr
 
     # Make "python -m h2o_wave run" behave identical to "wave run":
@@ -132,9 +147,9 @@ def run(app: str, no_reload: bool, no_autostart: bool):
     else:
         autostart = os.environ.get('H2O_WAVE_NO_AUTOSTART', 'false').lower() in ['false', '0', 'f']
 
-    waved = 'waved.exe' if IS_WINDOWS else './waved'
+    waved_path = os.path.join(sys.exec_prefix, 'waved.exe' if IS_WINDOWS else 'waved')
     # OS agnostic wheels do not include waved - needed for HAC.
-    is_waved_present = os.path.isfile(os.path.join(sys.exec_prefix, waved))
+    is_waved_present = os.path.isfile(waved_path)
 
     try:
         if autostart and is_waved_present and server_not_running:
@@ -142,7 +157,7 @@ def run(app: str, no_reload: bool, no_autostart: bool):
             if IS_WINDOWS:
                 kwargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP
 
-            waved_process = subprocess.Popen([waved], cwd=sys.exec_prefix, env=os.environ.copy(), **kwargs)
+            waved_process = subprocess.Popen([waved_path], cwd=sys.exec_prefix, env=os.environ.copy(), **kwargs)
             time.sleep(1)
             server_not_running = _scan_free_port(server_port) == server_port
             retries = 3
@@ -151,23 +166,22 @@ def run(app: str, no_reload: bool, no_autostart: bool):
                 time.sleep(2)
                 server_not_running = _scan_free_port(server_port) == server_port
                 retries = retries - 1
-    finally:
+
         if autostart and server_not_running:
             print('Could not connect to Wave server. Please start the Wave server (waved or waved.exe) prior to running any app.')
             return
-        try:
-            if not os.environ.get('H2O_WAVE_WAVED_DIR') and is_waved_present:
-                os.environ['H2O_WAVE_WAVED_DIR'] = sys.exec_prefix
-            uvicorn.run(f'{app}:main', host=host, port=port, reload=not no_reload)
-        except Exception as e:
-            if waved_process:
-                waved_process.kill()
-            raise e
-
 
-@main.command()
-def ide():
-    uvicorn.run('h2o_wave.ide:ide', host=_localhost, port=10100)
+        if not os.environ.get('H2O_WAVE_WAVED_DIR') and is_waved_present:
+            os.environ['H2O_WAVE_WAVED_DIR'] = sys.exec_prefix
+        reload_exclude = os.environ.get('H2O_WAVE_RELOAD_EXCLUDE', None)
+        if reload_exclude:
+            reload_exclude = reload_exclude.split(os.pathsep)
+        uvicorn.run(f'{app}:main', host=host, port=port, reload=not no_reload, reload_excludes=reload_exclude)
+    except Exception as e:
+        raise e
+    finally:
+        if waved_process:
+            waved_process.kill()
 
 
 @main.command()
@@ -245,33 +259,26 @@ def init():
     """
     try:
         theme = inquirer.themes.load_theme_from_dict({"List": {"selection_color": "yellow"}})
-        project = inquirer.prompt([inquirer.List('project', message="Choose a starter template",
-              choices=[
-                  'Hello World app (for beginners)',
-                  'App with header',
-                  'App with header + navigation',
-                  'App with sidebar + navigation',
-                  'App with header & sidebar + navigation'
-              ]),
+        project = inquirer.prompt([
+            inquirer.List(
+                name='project',
+                message="Choose a starter template",
+                choices=[
+                    ('Hello World app (for beginners)', 'hello_world.py'),
+                    ('Chat app', 'chat.py'),
+                    ('App with header', 'header.py'),
+                    ('App with header + navigation', 'header_nav.py'),
+                    ('App with sidebar + navigation', 'sidebar_nav.py'),
+                    ('App with header & sidebar + navigation', 'header_sidebar_nav.py'),
+                ]
+            ),
         ], theme=theme)['project']
     # Ctrl-C causes TypeError within inquirer, resulting in ugly stacktrace. Catch the error and return early on CTRL-C.
     except (KeyboardInterrupt, TypeError):
         return
 
-    app_content = ''
     base_path = os.path.join(sys.exec_prefix, 'project_templates')
-    if 'Hello World' in project:
-        app_content = read_file(os.path.join(base_path, 'hello_world.py'))
-    elif 'header & sidebar' in project:
-        app_content = read_file(os.path.join(base_path, 'header_sidebar_nav.py'))
-    elif 'header +' in project:
-        app_content = read_file(os.path.join(base_path, 'header_nav.py'))
-    elif 'header' in project:
-        app_content = read_file(os.path.join(base_path, 'header.py'))
-    elif 'sidebar +' in project:
-        app_content = read_file(os.path.join(base_path, 'sidebar_nav.py'))
-
-    write_file('app.py', app_content)
+    write_file('app.py', read_file(os.path.join(base_path, project)))
     write_file('requirements.txt', f'h2o-wave=={__version__}')
     write_file('README.md', read_file(os.path.join(base_path, 'README.md')))
 
@@ -294,9 +301,11 @@ def learn():
 
 @main.command()
 @click.option('--port', default=10101, help='Port your app is running on (defaults to 10101).')
-@click.option('--subdomain', default='?new', help='Subdomain to use. If not available, a random one is generated.')
+@click.option('--subdomain', default='my-app', help='Subdomain to use. If not available, a random one is generated.')
 @click.option('--remote-host', default='h2oai.app', help='Remote host to use (defaults to h2oai.app).')
-def share(port: int, subdomain: str, remote_host: str):
+@click.option('--remote-port', default=443, help='Remote port to use (defaults to 443).')
+@click.option('--open', is_flag=True, default=False, help='Open the shared app in your browser automatically.')
+def share(port: int, subdomain: str, remote_host: str, remote_port: int, open: bool):
     """Share your locally running app with the world.
 
     \b
@@ -319,29 +328,35 @@ def share(port: int, subdomain: str, remote_host: str):
         loop.create_task(wakeup())
 
     try:
-        loop.run_until_complete(_share(port, subdomain, remote_host))
+        loop.run_until_complete(_share(port, subdomain, remote_host, remote_port, open))
     except KeyboardInterrupt:
         tasks = asyncio.all_tasks(loop)
         for task in tasks:
             task.cancel()
         loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
         loop.close()
+        print('Sharing stopped.')
 
 
-async def _share(port: int, subdomain: str, remote_host: str):
+async def _share(port: int, subdomain: str, remote_host: str, remote_port: int, should_open: bool):
     if _scan_free_port(port) == port:
         print(f'Could not connect to localhost:{port}. Please make sure your app is running.')
         exit(1)
 
-    res = httpx.get(f'https://{remote_host}/{subdomain}', headers={'Content-Type': 'application/json'})
+    protocol = 'https' if remote_port == 443 else 'http'
+    res = httpx.get(f'{protocol}://{remote_host}:{remote_port}/register/{subdomain}')
     if res.status_code != 200:
         print('Could not connect to the remote sharing server.')
         exit(1)
 
     res = res.json()
-    print(f'BETA: Proxying localhost:{port} ==> {res["url"]}')
-    print('\x1b[7;30;43mDO NOT SHARE YOUR APP IF IT CONTAINS SENSITIVE INFO\x1b[0m.')
-    print('Press Ctrl+C to stop sharing.')
+    share_id = res['id']
+
+    remote = f'{protocol}://{share_id}.{remote_host}'
+    if remote_port != 80 and remote_port != 443:
+        remote += f':{remote_port}'
+
+    _print_launch_bar(f'http://localhost:{port}', remote)
 
     max_conn_count = res['max_conn_count']
     # The server can be configured to either support 10 concurrent connections (default) or more.
@@ -351,10 +366,15 @@ async def _share(port: int, subdomain: str, remote_host: str):
     tasks = []
     for _ in range(max_conn_count // step):
         for _ in range(step):
-            tasks.append(asyncio.create_task(listen_on_socket('127.0.0.1', port, remote_host, res['port'])))
+            tasks.append(asyncio.create_task(listen_on_socket('127.0.0.1', port, remote_host, remote_port, share_id)))
         await asyncio.sleep(1)
     # Handle the rest if any.
     for _ in range(max_conn_count % step):
-        tasks.append(asyncio.create_task(listen_on_socket('127.0.0.1', port, remote_host, res['port'])))
+        tasks.append(asyncio.create_task(listen_on_socket('127.0.0.1', port, remote_host, remote_port, share_id)))
+
+    if should_open:
+        await asyncio.sleep(1)
+        webbrowser.open(remote)
 
     await asyncio.gather(*tasks)
+    print('Could not establish connection with the server.')

h2o_wave/core.py

@@ -18,7 +18,6 @@ import ipaddress
 import json
 import platform
 import secrets
-import shutil
 import subprocess
 from urllib.parse import urlparse
 from uuid import uuid4
@@ -46,14 +45,12 @@ def _get_env(key: str, value: Any):
     return os.environ.get(f'H2O_WAVE_{key}', value)
 
 
-_default_internal_address = 'http://127.0.0.1:8000'
 _base_url = _get_env('BASE_URL', '/')
 
 
 class _Config:
     def __init__(self):
-        self.internal_address = _get_env('INTERNAL_ADDRESS', _default_internal_address)
-        self.app_address = _get_env('APP_ADDRESS', _get_env('EXTERNAL_ADDRESS', self.internal_address))
+        self.app_address = _get_env('APP_ADDRESS', 'http://127.0.0.1:8000')
         self.app_mode = _get_env('APP_MODE', UNICAST)
         self.hub_base_url = _get_env('BASE_URL', '/')
         self.hub_host_address = _get_env('ADDRESS', 'http://127.0.0.1:10101')
@@ -99,17 +96,6 @@ def _are_primitives(xs: Any) -> bool:
     return True
 
 
-def _guard_primitive_list(xs: Any):
-    if not _are_primitives(xs):
-        raise ValueError('value must be a primitive list or tuple')
-
-
-def _guard_primitive_dict_values(d: Dict[str, Any]):
-    if d:
-        for x in d.values():
-            _guard_primitive(x)
-
-
 def _guard_str_key(key: str):
     if not _is_str(key):
         raise KeyError('key must be str')
@@ -271,6 +257,38 @@ def _dump(xs: Any):
         return xs
 
 
+def _fill_data_buffers(props: Dict, data: list, bufs: list, keys=[], is_form_card=False):
+    for k, v in props.items():
+        if isinstance(v, Data):
+            keys.append(k)
+            data.append(('.'.join(keys), len(bufs)))
+            bufs.append(v.dump())
+            keys.pop()
+        elif not is_form_card:
+            continue
+        elif isinstance(v, list):
+            keys.append(k)
+            for idx, e in enumerate(v):
+                if isinstance(e, dict):
+                    keys.append(str(idx))
+                    _fill_data_buffers(e, data, bufs, keys, is_form_card)
+                    keys.pop()
+            keys.pop()
+        elif isinstance(v, dict):
+            keys.append(k)
+            _fill_data_buffers(v, data, bufs, keys, is_form_card)
+            keys.pop()
+
+
+def _del_dict_key(d: dict, keys: List[str]):
+    if len(keys) == 1:
+        del d[keys[0]]
+    else:
+        next_key = keys[0]
+        key = int(next_key) if next_key.isdigit() else next_key
+        _del_dict_key(d[key], keys[1:])
+
+
 class Ref:
     """
     Represents a local reference to an element on a `h2o_wave.core.Page`.
@@ -507,13 +525,10 @@ class PageBase:
 
         data = []
         bufs = []
-        for k, v in props.items():
-            if isinstance(v, Data):
-                data.append((k, len(bufs)))
-                bufs.append(v.dump())
+        _fill_data_buffers(props, data, bufs, [], props.get('view') == 'form')
 
         for k, v in data:
-            del props[k]
+            _del_dict_key(props, k.split('.'))
             props[f'~{k}'] = v
 
         if len(bufs) > 0:
@@ -576,13 +591,6 @@ class Page(PageBase):
         """
         return self.site.load(self.url)
 
-    def sync(self):
-        """
-        DEPRECATED: Use `h2o_wave.core.Page.save` instead.
-        """
-        warnings.warn('page.sync() is deprecated. Please use page.save() instead.', DeprecationWarning)
-        self.save()
-
     def save(self):
         """
         Save the page. Sends all local changes made to this page to the remote site.
@@ -616,13 +624,6 @@ class AsyncPage(PageBase):
         """
         return await self.site.load(self.url)
 
-    async def push(self):
-        """
-        DEPRECATED: Use `h2o_wave.core.AsyncPage.save` instead.
-        """
-        warnings.warn('page.push() is deprecated. Please use page.save() instead.', DeprecationWarning)
-        await self.save()
-
     async def save(self):
         """
         Save the page. Sends all local changes made to this page to the remote site.

h2o_wave/metadata.py

@@ -1,4 +1,5 @@
 
-# Generated in setup.py.
-__platform__ = "any"
-__arch__ = "amd64"
+# Generated in hatch_build.py.
+__platform__ = "macosx_12_0_arm64"
+__arch__ = "arm64"
+        

h2o_wave/routing.py

@@ -14,7 +14,6 @@
 
 from typing import Optional, Callable
 from inspect import signature
-import asyncio
 import logging
 from starlette.routing import compile_path
 from .core import expando_to_dict
@@ -25,6 +24,8 @@ logger = logging.getLogger(__name__)
 _event_handlers = {}  # dictionary of event_source => [(event_type, predicate, handler)]
 _arg_handlers = {}  # dictionary of arg_name => [(predicate, handler)]
 _path_handlers = []
+_arg_with_params_handlers = []
+_handle_on_deprecated_warning_printed = False
 
 
 def _get_arity(func: Callable) -> int:
@@ -86,9 +87,8 @@ def on(arg: str = None, predicate: Optional[Callable] = None):
         # if not asyncio.iscoroutinefunction(func):
         #    raise ValueError(f"@on function '{func_name}' must be async")
 
-        if predicate:
-            if not callable(predicate):
-                raise ValueError(f"@on predicate must be callable for '{func_name}'")
+        if predicate and not callable(predicate):
+            raise ValueError(f"@on predicate must be callable for '{func_name}'")
         if isinstance(arg, str) and len(arg):
             if arg.startswith('#'):  # location hash
                 rx, _, conv = compile_path(arg[1:])
@@ -100,6 +100,9 @@ def on(arg: str = None, predicate: Optional[Callable] = None):
                 if not len(event):
                     raise ValueError(f"@on event type cannot be empty in '{arg}' for '{func_name}'")
                 _add_event_handler(source, event, func, predicate)
+            elif "{" in arg and "}" in arg:
+                rx, _, conv = compile_path(arg)
+                _arg_with_params_handlers.append((predicate, func, _get_arity(func), rx, conv))
             else:
                 _add_handler(arg, func, predicate)
         else:
@@ -110,28 +113,32 @@ def on(arg: str = None, predicate: Optional[Callable] = None):
     return wrap
 
 
-async def _invoke_handler(func: Callable, arity: int, q: Q, arg: any):
+async def _invoke_handler(func: Callable, arity: int, q: Q, arg: any, **params: any):
     if arity == 0:
         await func()
     elif arity == 1:
         await func(q)
-    else:
+    elif len(params) == 0:
         await func(q, arg)
+    elif arity == len(params) + 1:
+        await func(q, **params)
+    else:
+        await func(q, arg, **params)
 
 
-async def _match_predicate(predicate: Callable, func: Callable, arity: int, q: Q, arg: any) -> bool:
+async def _match_predicate(predicate: Callable, func: Callable, arity: int, q: Q, arg: any, **params: any) -> bool:
     if predicate:
         if predicate(arg):
-            await _invoke_handler(func, arity, q, arg)
+            await _invoke_handler(func, arity, q, arg, **params)
             return True
     else:
-        if arg:
-            await _invoke_handler(func, arity, q, arg)
+        if arg is not None:
+            await _invoke_handler(func, arity, q, arg, **params)
             return True
     return False
 
 
-async def handle_on(q: Q) -> bool:
+async def run_on(q: Q) -> bool:
     """
     Handle the query using a query handler (a function annotated with `@on()`).
 
@@ -141,6 +148,67 @@ async def handle_on(q: Q) -> bool:
     Returns:
         True if a matching query handler was found and invoked, else False.
     """
+    submitted = str(q.args['__wave_submission_name__'])
+
+    # Event handlers.
+    for event_source in expando_to_dict(q.events):
+        for entry in _event_handlers.get(event_source, []):
+            event_type, predicate, func, arity = entry
+            event = q.events[event_source]
+            if event_type in event:
+                arg_value = event[event_type]
+                if await _match_predicate(predicate, func, arity, q, arg_value):
+                    return True
+
+    # Hash handlers.
+    if submitted == '#':
+        for rx, conv, func, arity in _path_handlers:
+            match = rx.match(q.args[submitted])
+            if match:
+                params = match.groupdict()
+                for key, value in params.items():
+                    params[key] = conv[key].convert(value)
+                if len(params):
+                    if arity <= 1:
+                        await _invoke_handler(func, arity, q, None)
+                    else:
+                        await func(q, **params)
+                else:
+                    await _invoke_handler(func, arity, q, None)
+                return True
+
+    # Arg handlers.
+    for entry in _arg_handlers.get(submitted, []):
+        predicate, func, arity = entry
+        if await _match_predicate(predicate, func, arity, q, q.args[submitted]):
+            return True
+    for predicate, func, arity, rx, conv in _arg_with_params_handlers:
+        match = rx.match(submitted)
+        if match:
+            params = match.groupdict()
+            for key, value in params.items():
+                params[key] = conv[key].convert(value)
+            if await _match_predicate(predicate, func, arity, q, q.args[submitted], **params):
+                return True
+
+    return False
+
+
+async def handle_on(q: Q) -> bool:
+    """
+    DEPRECATED: Handle the query using a query handler (a function annotated with `@on()`).
+
+    Args:
+        q: The query context.
+
+    Returns:
+        True if a matching query handler was found and invoked, else False.
+    """
+    global _handle_on_deprecated_warning_printed
+    if not _handle_on_deprecated_warning_printed:
+        print('\033[93m' + 'WARNING: handle_on() is deprecated, use run_on() instead.' + '\033[0m')
+        _handle_on_deprecated_warning_printed = True
+
     event_sources = expando_to_dict(q.events)
     for event_source in event_sources:
         event = q.events[event_source]

h2o_wave/server.py

@@ -17,22 +17,16 @@ import datetime
 import asyncio
 from concurrent.futures import Executor
 
-try:
-    import contextvars  # Python 3.7+ only.
-except ImportError:
-    contextvars = None
+import contextvars
 
 import logging
 import functools
-import warnings
 import pickle
 import traceback
 import base64
 import binascii
 from typing import Dict, List, Tuple, Callable, Any, Awaitable, Optional
-from urllib.parse import urlparse
 
-import uvicorn
 import httpx
 from starlette.types import Scope, Receive, Send
 from starlette.applications import Router
@@ -149,8 +143,6 @@ class Query:
         """A `h2o_wave.core.Expando` instance containing arguments from the active request."""
         self.events = events
         """A `h2o_wave.core.Expando` instance containing events from the active request."""
-        self.username = auth.username
-        """The username of the user who initiated the active request. (DEPRECATED: Use q.auth.username instead)"""
         self.route = route
         """The route served by the server."""
         self.auth = auth
@@ -191,17 +183,11 @@ class Query:
 
         loop = asyncio.get_event_loop()
 
-        if contextvars is not None:  # Python 3.7+ only.
-            return await loop.run_in_executor(
-                executor,
-                contextvars.copy_context().run,
-                functools.partial(func, *args, **kwargs)
-            )
-
-        if kwargs:
-            return await loop.run_in_executor(executor, functools.partial(func, *args, **kwargs))
-
-        return await loop.run_in_executor(executor, func, *args)
+        return await loop.run_in_executor(
+            executor,
+            contextvars.copy_context().run,
+            functools.partial(func, *args, **kwargs)
+        )
 
     async def run(self, func: Callable, *args: Any, **kwargs: Any) -> Any:
         """
@@ -300,7 +286,7 @@ class _App:
                 elapsed_time = current_time - start_time
                 if elapsed_time.seconds > connection_timeout:
                     logger.debug(f'Register: giving up after retrying for {connection_timeout} seconds')
-                    raise exception
+                    raise ConnectionError('Could not connect to Wave server. Make sure it is running.') from exception
                 await asyncio.sleep(1)
                 logger.debug('Register: retrying...')
 
@@ -504,20 +490,3 @@ def app(route: str, mode=None, on_startup: Optional[Callable] = None,
         return handle
 
     return wrap
-
-
-def listen(route: str, handle: HandleAsync, mode=None):
-    """
-    Launch an application server.
-
-    Args:
-        route: The route to listen to. e.g. `'/foo'` or `'/foo/bar/baz'`.
-        handle: The handler function.
-        mode: The server mode. One of `'unicast'` (default),`'multicast'` or `'broadcast'`.
-    """
-    warnings.warn("'listen()' is deprecated. Instead, import 'main' and annotate your 'serve()' function with '@app'.",
-                  DeprecationWarning)
-
-    internal_address = urlparse(_config.internal_address)
-    logger.info(f'Listening on host "{internal_address.hostname}", port "{internal_address.port}"...')
-    uvicorn.run(_Main(_App(route, handle, mode)), host=internal_address.hostname, port=internal_address.port)

h2o_wave/share.py

@@ -10,17 +10,26 @@ async def pipe(r: asyncio.StreamReader, w: asyncio.StreamWriter) -> None:
         await w.drain()
 
 
-async def listen_on_socket(local_host: str, local_port: int, remote_host: str, remote_port: int) -> None:
+async def listen_on_socket(local_host: str, local_port: int, remote_host: str, remote_port: int, id: str) -> None:
+    local_reader, local_writer = None, None
+    remote_reader, remote_writer = None, None
+    retries = 0
     while True:
+        if retries > 5:
+            break
         try:
             local_reader, local_writer = await asyncio.open_connection(local_host, local_port)
             remote_reader, remote_writer = await asyncio.open_connection(remote_host, remote_port, ssl=True)
+            remote_writer.write(f'__h2o_leap__ {id}\n'.encode())
 
+            retries = 0
             await asyncio.gather(pipe(local_reader, remote_writer), pipe(remote_reader, local_writer))
 
         # Swallow exceptions and reconnect.
         except Exception:
-            pass
+            retries += 1
         finally:
-            local_writer.close()
-            remote_writer.close()
+            if local_writer:
+                local_writer.close()
+            if remote_writer:
+                remote_writer.close()