h2o-wave 0.25.3__py3-none-macosx_12_0_arm64.whl → 0.26.1__py3-none-macosx_12_0_arm64.whl

h2o_wave/cli.py

@@ -12,34 +12,43 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import time
-import tarfile
+import asyncio
+import os
+import platform
 import shutil
-import sys
 import socket
-from contextlib import closing
 import subprocess
+import sys
+import tarfile
+import time
+from contextlib import closing
 from pathlib import Path
-import platform
-import uvicorn
-import click
-import inquirer
-import os
 from urllib import request
 from urllib.parse import urlparse
+
+import click
+import httpx
+import inquirer
+import uvicorn
+from click import Choice, option
+from h2o_wave.share import listen_on_socket
+
+from .metadata import __arch__, __platform__
 from .version import __version__
-from .metadata import __platform__, __arch__
 
 _localhost = '127.0.0.1'
 
+
 def read_file(file: str) -> str:
     with open(file, 'r') as f:
         return f.read()
 
+
 def write_file(file: str, content: str) -> None:
     with open(file, 'w') as f:
         f.write(content)
 
+
 def _scan_free_port(port: int = 8000):
     while True:
         with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
@@ -52,7 +61,7 @@ def is_within_directory(directory, target):
     abs_directory = os.path.abspath(directory)
     abs_target = os.path.abspath(target)
     prefix = os.path.commonprefix([abs_directory, abs_target])
-    
+
     return prefix == abs_directory
 
 
@@ -62,8 +71,8 @@ def safe_extract(tar, path=".", members=None, *, numeric_owner=False):
         if not is_within_directory(path, member_path):
             raise Exception("Attempted Path Traversal in Tar File")
 
-    tar.extractall(path, members, numeric_owner=numeric_owner) 
-    
+    tar.extractall(path, members, numeric_owner=numeric_owner)
+
 
 @click.group()
 def main():
@@ -115,15 +124,18 @@ def run(app: str, no_reload: bool, no_autostart: bool):
     # Try to start Wave daemon if not running or turned off.
     server_port = int(os.environ.get('H2O_WAVE_LISTEN', ':10101').split(':')[-1])
     server_not_running = _scan_free_port(server_port) == server_port
+
+    waved_process = None
+    if no_autostart:
+        autostart = False
+    else:
+        autostart = os.environ.get('H2O_WAVE_NO_AUTOSTART', 'false').lower() in ['false', '0', 'f']
+
+    waved = 'waved.exe' if 'Windows' in platform.system() else './waved'
+    # OS agnostic wheels do not have waved - needed for HAC.
+    is_waved_present = os.path.isfile(os.path.join(sys.exec_prefix, waved))
+
     try:
-        waved = 'waved.exe' if 'Windows' in platform.system() else './waved'
-        waved_process = None
-        # OS agnostic wheels do not have waved - needed for HAC.
-        is_waved_present = os.path.isfile(os.path.join(sys.exec_prefix, waved))
-        if no_autostart:
-            autostart = False
-        else:
-            autostart = os.environ.get('H2O_WAVE_NO_AUTOSTART', 'false').lower() in ['false', '0', 'f']
         if autostart and is_waved_present and server_not_running:
             waved_process = subprocess.Popen([waved], cwd=sys.exec_prefix, env=os.environ.copy(), shell=True)
             time.sleep(1)
@@ -154,14 +166,23 @@ def ide():
 
 
 @main.command()
-def fetch():
+@option('--platform', help='Operating system type.', type=Choice(['linux', 'windows', 'darwin']))
+@option('--arch', default=__arch__, help='Processor architecture type.', type=Choice(['amd64', 'arm64']))
+def fetch(platform: str, arch: str):
     """Download examples and related files to ./wave.
 
     \b
     $ wave fetch
     """
+    if not platform:
+        platform = __platform__
+
+    if platform == 'any':
+        print('Platform could not be detected. Please specify manually via --platform param.')
+        return
+
     print('Fetching examples and related files. Please wait...')
-    tar_name = f'wave-{__version__}-{__platform__}-{__arch__}'
+    tar_name = f'wave-{__version__}-{platform}-{arch}'
     tar_file = f'{tar_name}.tar.gz'
     tar_url = f'https://github.com/h2oai/wave/releases/download/v{__version__}/{tar_file}'
     tar_path = Path(tar_file)
@@ -263,4 +284,72 @@ def learn():
         from h2o_wave_university import cli
         cli.main()
     except ImportError:
-        print('You need to run \x1b[7;30;43mpip install h2o_wave_university\x1b[0m first.')
+        print('You need to run \x1b[7;30;43mpip install h2o_wave_university\x1b[0m first.')
+
+
+@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('--remote-host', default='h2oai.app', help='Remote host to use (defaults to h2oai.app).')
+def share(port: int, subdomain: str, remote_host: str):
+    """Share your locally running app with the world.
+
+    \b
+    $ wave share
+    """
+    if 'Windows' in platform.system():
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    if 'Windows' in platform.system():
+
+        async def wakeup():
+            while True:
+                await asyncio.sleep(1)
+
+        # HACK: Enable Ctrl-C on Windows when opening multiple TCP connections.
+        # https://stackoverflow.com/questions/27480967/why-does-the-asyncios-event-loop-suppress-the-keyboardinterrupt-on-windows.
+        loop.create_task(wakeup())
+
+    try:
+        loop.run_until_complete(_share(port, subdomain, remote_host))
+    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()
+
+
+async def _share(port: int, subdomain: str, remote_host: str):
+    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'})
+    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.')
+
+    max_conn_count = res['max_conn_count']
+    # The server can be configured to either support 10 concurrent connections (default) or more.
+    # If more, connect in batches of 100 for better performance.
+    step = 100 if max_conn_count > 10 else max_conn_count
+
+    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'])))
+        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'])))
+
+    await asyncio.gather(*tasks)

h2o_wave/core.py

@@ -299,6 +299,13 @@ class Ref:
             raise ValueError('Data instances cannot be used in assignments.')
         getattr(self, PAGE)._track(_set_op(self, key, _dump(value)))
 
+    def __iadd__(self, value):
+        if not getattr(self, KEY).endswith('data'):
+            raise ValueError('+= can only be used on list data buffers.')
+        page = getattr(self, PAGE)
+        page._track(_set_op(self, '__append__', _dump(value)))
+        page._skip_next_track = True
+
 
 class Data:
     """
@@ -306,35 +313,38 @@ class Data:
 
     Args:
         fields: The names of the fields (columns names) in the data, either a list or tuple or string containing space-separated names.
-        size: The number of rows to allocate memory for. Positive for fixed buffers, negative for circular buffers and zero for variable length buffers.
-        data: Initial data. Must be either a key-row ``dict`` for variable-length buffers OR a row ``list`` for fixed-size and circular buffers.
+        size: The number of rows to allocate memory for. Positive for fixed buffers, negative for cyclic buffers and zero for variable length buffers.
+        data: Initial data. Must be either a key-row ``dict`` for variable-length buffers OR a row ``list`` for fixed-size and cyclic buffers.
+        t: Buffer type. One of 'list', 'map', 'cyclic' or 'fixed'. Overrides the buffer type inferred from the size.
     """
 
-    def __init__(self, fields: Union[str, tuple, list], size: int = 0, data: Optional[Union[dict, list]] = None):
+    def __init__(self, fields: Union[str, tuple, list], size: int = 0, data: Optional[Union[dict, list]] = None, t: Optional[str] = None):
         self.fields = fields
         self.data = data
         self.size = size
+        self.type = t
 
     def dump(self):
         f = self.fields
         d = self.data
         n = self.size
+        t = self.type
         if d:
-            if isinstance(d, dict):
+            if t == 'list':
+                return dict(l=dict(f=f, d=d))
+            if t == 'map' or isinstance(d, dict):
                 return dict(m=dict(f=f, d=d))
-            else:
-                if n < 0:
-                    return dict(c=dict(f=f, d=d))
-                else:
-                    return dict(f=dict(f=f, d=d))
+            if t == 'cyclic' or n < 0:
+                return dict(c=dict(f=f, d=d))
+            return dict(f=dict(f=f, d=d))
         else:
-            if n == 0:
+            if t == 'list':
+                return dict(l=dict(f=f, n=n))
+            if t == 'map' or n == 0:
                 return dict(m=dict(f=f))
-            else:
-                if n < 0:
-                    return dict(c=dict(f=f, n=-n))
-                else:
-                    return dict(f=dict(f=f, n=n))
+            if t == 'cyclic' or n < 0:
+                return dict(c=dict(f=f, n=-n))
+            return dict(f=dict(f=f, n=n))
 
 
 def data(
@@ -343,6 +353,7 @@ def data(
         rows: Optional[Union[dict, list]] = None,
         columns: Optional[Union[dict, list]] = None,
         pack=False,
+        t: Optional[str] = None,
 ) -> Union[Data, str]:
     """
     Create a `h2o_wave.core.Data` instance for associating data with cards.
@@ -355,10 +366,11 @@ def data(
 
     Args:
         fields: The names of the fields (columns names) in the data, either a list or tuple or string containing space-separated names.
-        size: The number of rows to allocate memory for. Positive for fixed buffers, negative for circular buffers and zero for variable length buffers.
+        size: The number of rows to allocate memory for. Positive for fixed buffers, negative for cyclic buffers and zero for variable length buffers.
         rows: The rows in this data.
         columns: The columns in this data.
         pack: True to return a packed string representing the data instead of a `h2o_wave.core.Data` placeholder.
+        t: Buffer type. One of 'list', 'map', 'cyclic' or 'fixed'. Overrides the buffer type inferred from the size.
 
     Returns:
         Either a `h2o_wave.core.Data` placeholder or a packed string representing the data.
@@ -404,7 +416,7 @@ def data(
     if not _is_int(size):
         raise ValueError('size must be int')
 
-    return Data(fields, size, rows)
+    return Data(fields, size, rows, t)
 
 
 class _ServerCacheBase:
@@ -468,6 +480,8 @@ class PageBase:
     def __init__(self, url: str):
         self.url = url
         self._changes = []
+        # HACK: Overloading += operator makes unnecessary __setattr__ call. Skip it to prevent redundant ops.
+        self._skip_next_track = False
 
     def add(self, key: str, card: Any) -> Ref:
         """
@@ -510,6 +524,9 @@ class PageBase:
         return Ref(self, key)
 
     def _track(self, op: dict):
+        if self._skip_next_track:
+            self._skip_next_track = False
+            return
         self._changes.append(op)
 
     def _diff(self):
@@ -1151,4 +1168,4 @@ def _can_do_local_upload(data_dir: str, waved_dir: str) -> bool:
     if not _is_loopback_address():
         return False
 
-    return os.path.isabs(data_dir) or (waved_dir and data_dir)
+    return bool(os.path.isabs(data_dir) or (waved_dir and data_dir))

h2o_wave/routing.py

@@ -62,7 +62,7 @@ def on(arg: str = None, predicate: Optional[Callable] = None):
     A function annotated with `@on('foo.bar', lambda x: 42 <= x <= 420)` is invoked whenever `q.events.foo.bar` between 42 and 420.
     A function annotated with `@on('#foo')` is invoked whenever `q.args['#']` equals 'foo'.
     A function annotated with `@on('#foo/bar')` is invoked whenever `q.args['#']` equals 'foo/bar'.
-    A function annotated with `@on('#foo/&lcub;fruit&rcub;')` is invoked whenever `q.args['#']` matches 'foo/apple', 'foo/orange', etc. The parameter 'fruit' is passed to the function (in this case, 'apple', 'orange', etc.)
+    A function annotated with `@on('#foo/{"{fruit}"}')` is invoked whenever `q.args['#']` matches 'foo/apple', 'foo/orange', etc. The parameter 'fruit' is passed to the function (in this case, 'apple', 'orange', etc.)
 
     Parameters in patterns (indicated within curly braces) can be converted to `str`, `int`, `float` or `uuid.UUID` instances by suffixing the parameters with `str`, `int`, `float` or `uuid`, respectively.
 

h2o_wave/server.py

@@ -80,6 +80,9 @@ class Auth:
         """
         Explicitly refresh OIDC tokens when needed, e.g. during long-running background jobs.
         """
+        if not self.refresh_token:
+            return
+
         async with httpx.AsyncClient(auth=(_config.hub_access_key_id, _config.hub_access_key_secret), verify=False) as http:
             res = await http.get(_config.hub_address + '_auth/refresh', headers={'Wave-Session-ID': self._session_id})
             return self.__extract_tokens(res.headers)
@@ -89,10 +92,12 @@ class Auth:
         Explicitly refresh OIDC tokens when needed, e.g. during long-running background jobs - synchronous version.
         Prefer async version. Use sync only when absolutely necessary - will block your app, making it slow for all users.
         """
+        if not self.refresh_token:
+            return
+
         with httpx.Client(auth=(_config.hub_access_key_id, _config.hub_access_key_secret), verify=False) as http:
             res = http.get(_config.hub_address + '_auth/refresh', headers={'Wave-Session-ID': self._session_id})
             return self.__extract_tokens(res.headers)
-      
 
     def __extract_tokens(self, headers: httpx.Headers):
         access_token = headers.get('Wave-Access-Token', None)
@@ -104,6 +109,7 @@ class Auth:
 
         return access_token
 
+
 class Query:
     """
     Represents the query context.
@@ -373,7 +379,7 @@ class _App:
                 q.page.drop()
                 # TODO replace this with a custom-designed error display
                 q.page['__unhandled_error__'] = markdown_card(
-                    box='1 1 12 10',
+                    box='1 1 -1 -1',
                     title='Error',
                     content=f'```\n{traceback.format_exc()}\n```',
                 )

h2o_wave/share.py

@@ -0,0 +1,26 @@
+import asyncio
+
+
+async def pipe(r: asyncio.StreamReader, w: asyncio.StreamWriter) -> None:
+    while True:
+        data = await r.read(4096)
+        if not data:
+            break
+        w.write(data)
+        await w.drain()
+
+
+async def listen_on_socket(local_host: str, local_port: int, remote_host: str, remote_port: int) -> None:
+    while True:
+        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)
+
+            await asyncio.gather(pipe(local_reader, remote_writer), pipe(remote_reader, local_writer))
+
+        # Swallow exceptions and reconnect.
+        except Exception:
+            pass
+        finally:
+            local_writer.close()
+            remote_writer.close()