dara-core 1.20.1a1__py3-none-any.whl → 1.20.1a3__py3-none-any.whl

dara/core/internal/utils.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import asyncio
 import inspect
 import os
+from collections.abc import Awaitable, Coroutine, Sequence
 from functools import wraps
 from importlib import import_module
 from importlib.util import find_spec
@@ -27,21 +28,21 @@ from types import ModuleType
 from typing import (
     TYPE_CHECKING,
     Any,
-    Awaitable,
     Callable,
-    Coroutine,
     Dict,
     Literal,
     Optional,
-    Sequence,
     Tuple,
+    Type,
+    TypeVar,
     Union,
 )
 
 import anyio
 from anyio import from_thread
-from exceptiongroup import ExceptionGroup
+from exceptiongroup import BaseExceptionGroup, ExceptionGroup
 from starlette.concurrency import run_in_threadpool
+from typing_extensions import ParamSpec
 
 from dara.core.auth.definitions import SESSION_ID, USER
 from dara.core.base_definitions import CacheType
@@ -79,7 +80,7 @@ def get_cache_scope(cache_type: Optional[CacheType]) -> CacheScope:
     return 'global'
 
 
-async def run_user_handler(handler: Callable, args: Sequence = [], kwargs: dict = {}):
+async def run_user_handler(handler: Callable, args: Union[Sequence, None] = None, kwargs: Union[dict, None] = None):
     """
     Run a user-defined handler function. Runs sync functions in a threadpool.
     Handles SystemExits cleanly.
@@ -88,6 +89,10 @@ async def run_user_handler(handler: Callable, args: Sequence = [], kwargs: dict
     :param args: list of arguments to pass to the function
     :param kwargs: dict of kwargs to past to the function
     """
+    if args is None:
+        args = []
+    if kwargs is None:
+        kwargs = {}
     with handle_system_exit('User defined function quit unexpectedly'):
         if inspect.iscoroutinefunction(handler):
             return await handler(*args, **kwargs)
@@ -164,17 +169,21 @@ def enforce_sso(conf: ConfigurationBuilder):
     Raises if SSO is not used
     """
     try:
-        from dara.enterprise import SSOAuthConfig
+        from dara.enterprise import SSOAuthConfig  # pyright: ignore[reportMissingImports]
 
         if conf.auth_config is None or not isinstance(conf.auth_config, SSOAuthConfig):
             raise ValueError('Config does not have SSO auth enabled. Please update your application to configure SSO.')
-    except ImportError:
+    except ImportError as err:
         raise ValueError(
             'SSO is not enabled. Please install the dara_enterprise package and configure SSO to use this feature.'
-        )
+        ) from err
 
 
-def async_dedupe(fn: Callable[..., Awaitable]):
+P = ParamSpec('P')
+T = TypeVar('T')
+
+
+def async_dedupe(fn: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
     """
     Decorator to deduplicate concurrent calls to asynchronous functions based on their arguments.
 
@@ -192,7 +201,7 @@ def async_dedupe(fn: Callable[..., Awaitable]):
     is_method = 'self' in inspect.signature(fn).parameters
 
     @wraps(fn)
-    async def wrapped(*args, **kwargs):
+    async def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
         non_self_args = args[1:] if is_method else args
         key = (non_self_args, frozenset(kwargs.items()))
         lock = locks.get(key)
@@ -228,8 +237,22 @@ def resolve_exception_group(error: Any):
 
     :param error: The error to resolve
     """
-    if isinstance(error, ExceptionGroup):
-        if len(error.exceptions) == 1:
-            return resolve_exception_group(error.exceptions[0])
+    if isinstance(error, ExceptionGroup) and len(error.exceptions) == 1:
+        return resolve_exception_group(error.exceptions[0])
 
     return error
+
+
+def exception_group_contains(err_type: Type[BaseException], group: BaseExceptionGroup) -> bool:
+    """
+    Check if an ExceptionGroup contains an error of a given type, recursively
+
+    :param err_type: The type of error to check for
+    :param group: The ExceptionGroup to check
+    """
+    for exc in group.exceptions:
+        if isinstance(exc, err_type):
+            return True
+        if isinstance(exc, BaseExceptionGroup):
+            return exception_group_contains(err_type, exc)
+    return False

dara/core/internal/websocket.py

@@ -204,28 +204,27 @@ class WebSocketHandler:
             message_id = message.channel
 
             # If the message has a channel ID, it's a response to a previous message
-            if message_id:
-                if message_id in self.pending_responses:
-                    event, existing_messages = self.pending_responses[message_id]
-
-                    # If the response is chunked then collect the messages in pending responses
-                    if message.chunk_count is not None:
-                        if existing_messages is not None and isinstance(existing_messages, list):
-                            existing_messages.append(message.message)
-                        else:
-                            existing_messages = [message.message]
-                            self.pending_responses[message_id] = (
-                                event,
-                                existing_messages,
-                            )
+            if message_id and message_id in self.pending_responses:
+                event, existing_messages = self.pending_responses[message_id]
 
-                        # If all chunks have been received, set the event to notify the waiting coroutine
-                        if len(existing_messages) == message.chunk_count:
-                            event.set()
+                # If the response is chunked then collect the messages in pending responses
+                if message.chunk_count is not None:
+                    if existing_messages is not None and isinstance(existing_messages, list):
+                        existing_messages.append(message.message)
                     else:
-                        # Store the response and set the event to notify the waiting coroutine
-                        self.pending_responses[message_id] = (event, message.message)
+                        existing_messages = [message.message]
+                        self.pending_responses[message_id] = (
+                            event,
+                            existing_messages,
+                        )
+
+                    # If all chunks have been received, set the event to notify the waiting coroutine
+                    if len(existing_messages) == message.chunk_count:
                         event.set()
+                else:
+                    # Store the response and set the event to notify the waiting coroutine
+                    self.pending_responses[message_id] = (event, message.message)
+                    event.set()
 
             return None
 
@@ -475,7 +474,7 @@ async def ws_handler(websocket: WebSocket, token: Optional[str] = Query(default=
     if pending_tokens_registry.has(token):
         pending_tokens_registry.remove(token)
 
-    user_identifier = token_content.identity_id or token_content.identity_name
+    user_identifier = token_content.identity_id
 
     # Add the new session ID to known sessions for that user
     if sessions_registry.has(user_identifier):
@@ -497,6 +496,8 @@ async def ws_handler(websocket: WebSocket, token: Optional[str] = Query(default=
         SESSION_ID.set(token_data.session_id)
         ID_TOKEN.set(token_data.id_token)
 
+    WS_CHANNEL.set(channel)
+
     # Set initial Auth context vars for the WS connection
     update_context(token_content)
 

dara/core/js_tooling/js_utils.py

@@ -15,6 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+import contextlib
 import importlib
 import json
 import os
@@ -236,10 +237,8 @@ class BuildCache(BaseModel):
 
         # Create a symlink from the custom js folder into the static files directory
         new_path = os.path.abspath(os.path.join(self.static_files_dir, self.build_config.js_config.local_entry))
-        try:
+        with contextlib.suppress(FileNotFoundError):
             os.unlink(new_path)
-        except FileNotFoundError:
-            pass
         os.symlink(absolute_path, new_path)
 
         # Create a symlink for the node modules in the custom_js folder
@@ -247,10 +246,8 @@ class BuildCache(BaseModel):
         new_node_modules_path = os.path.abspath(
             os.path.join(os.getcwd(), self.build_config.js_config.local_entry, 'node_modules')
         )
-        try:
+        with contextlib.suppress(FileNotFoundError):
             os.unlink(new_node_modules_path)
-        except FileNotFoundError:
-            pass
         os.symlink(node_modules_path, new_node_modules_path)
 
     def get_importers(self) -> Dict[str, str]:
@@ -274,7 +271,7 @@ class BuildCache(BaseModel):
         """
         py_modules = set()
 
-        for module in self.package_map.keys():
+        for module in self.package_map:
             py_modules.add(module)
 
         if 'dara.core' in py_modules:
@@ -316,8 +313,9 @@ class BuildCache(BaseModel):
         # Append core deps required for building/dev mode
         pkg_json['dependencies'] = {
             **deps,
-            '@vitejs/plugin-react': '2.1.0',
-            'vite': '3.1.8',
+            '@vitejs/plugin-react': '4.6.0',
+            'vite': '7.0.4',
+            'vite-plugin-node-polyfills': '0.24.0',
         }
 
         return pkg_json
@@ -434,13 +432,16 @@ def _get_module_file(module: str) -> str:
         return cast(str, imported_module.__file__)
 
 
-def rebuild_js(build_cache: BuildCache, build_diff: BuildCacheDiff = BuildCacheDiff.full_diff()):
+def rebuild_js(build_cache: BuildCache, build_diff: Union[BuildCacheDiff, None] = None):
     """
     Generic 'rebuild' function which bundles/prepares assets depending on the build mode chosen
 
     :param build_cache: current build configuration cache
     :param build_diff: the difference between the current build cache and the previous build cache
     """
+    if build_diff is None:
+        build_diff = BuildCacheDiff.full_diff()
+
     # If we are in docker mode, skip the JS build
     if os.environ.get('DARA_DOCKER_MODE', 'FALSE') == 'TRUE':
         dev_logger.debug('Docker mode, skipping JS build')
@@ -485,17 +486,16 @@ def bundle_js(build_cache: BuildCache, copy_js: bool = False):
     :param copy_js: whether to copy JS instead of symlinking it
     """
     # If custom JS is present, symlink it
-    if build_cache.build_config.js_config is not None:
-        if os.path.isdir(build_cache.build_config.js_config.local_entry):
-            if copy_js:
-                # Just move the directory to output
-                js_folder_name = os.path.basename(build_cache.build_config.js_config.local_entry)
-                shutil.copytree(
-                    build_cache.build_config.js_config.local_entry,
-                    os.path.join(build_cache.static_files_dir, js_folder_name),
-                )
-            else:
-                build_cache.symlink_js()
+    if build_cache.build_config.js_config is not None and os.path.isdir(build_cache.build_config.js_config.local_entry):
+        if copy_js:
+            # Just move the directory to output
+            js_folder_name = os.path.basename(build_cache.build_config.js_config.local_entry)
+            shutil.copytree(
+                build_cache.build_config.js_config.local_entry,
+                os.path.join(build_cache.static_files_dir, js_folder_name),
+            )
+        else:
+            build_cache.symlink_js()
 
     # Determine template paths
     entry_template = os.path.join(pathlib.Path(__file__).parent.absolute(), 'templates/_entry.template.tsx')
@@ -544,16 +544,18 @@ def bundle_js(build_cache: BuildCache, copy_js: bool = False):
 
     cwd = os.getcwd()
     os.chdir(build_cache.static_files_dir)
-    exit_code = os.system(f'{package_manager} install')   # nosec B605 # package_manager is validated
+    dev_logger.info('Installing JS dependencies...')
+    exit_code = os.system(f'{package_manager} install')  # nosec B605 # package_manager is validated
     if exit_code > 0:
         raise SystemError(
             "Failed to install the JS dependencies - there's likely a connection issue or a broken package"
         )
+    dev_logger.info('JS dependencies installed successfully')
 
     # Load entry template as a string
-    with open(entry_template, 'r', encoding='utf-8') as f:
+    with open(entry_template, encoding='utf-8') as f:
         entry_template_str = f.read()
-    with open(vite_template, 'r', encoding='utf-8') as f:
+    with open(vite_template, encoding='utf-8') as f:
         vite_template_str = f.read()
 
     # Convert importers dict to a string for injection into the template
@@ -574,7 +576,7 @@ def bundle_js(build_cache: BuildCache, copy_js: bool = False):
         dev_logger.warning('App is in DEV mode, running `dara dev` CLI command alongside this process is required')
     else:
         # Run build pointed at the generated entry file
-        exit_code = os.system(f'{package_manager} run build')   # nosec B605 # package_manager is validated
+        exit_code = os.system(f'{package_manager} run build')  # nosec B605 # package_manager is validated
         if exit_code > 0:
             raise SystemError('Failed to build the JS part of the project')
 
@@ -640,7 +642,7 @@ def build_autojs_template(html_template: str, build_cache: BuildCache, config: C
     """
     settings = get_settings()
     entry_template = os.path.join(pathlib.Path(__file__).parent.absolute(), 'templates/_entry_autojs.template.tsx')
-    with open(entry_template, 'r', encoding='utf-8') as f:
+    with open(entry_template, encoding='utf-8') as f:
         entry_template_str = f.read()
 
     importers_dict = build_cache.get_importers()

dara/core/js_tooling/templates/vite.config.template.ts

@@ -1,18 +1,27 @@
 import react from '@vitejs/plugin-react';
 import { defineConfig } from 'vite';
+import { nodePolyfills } from 'vite-plugin-node-polyfills';
 
 export default defineConfig({
     base: '',
     plugins: [
         react({
             jsxRuntime: 'classic',
-        })
+        }),
+        // Some package we're pulling requires node polyfills for stream
+        nodePolyfills({
+            globals: {
+                process: true,
+                Buffer: true,
+                global: true,
+            },
+        }),
     ],
     publicDir: false,
     build: {
         outDir: '$$output$$',
         assetsDir: '',
-        manifest: true,
+        manifest: 'manifest.json',
         rollupOptions: {
             input: './_entry.tsx',
         },
@@ -35,5 +44,5 @@ export default defineConfig({
     },
     worker: {
         format: 'es',
-    }
+    },
 });

dara/core/logging.py

@@ -74,7 +74,7 @@ class Logger:
 
         self._logger.warning(payload, extra={'content': extra})
 
-    def error(self, title: str, error: Exception, extra: Optional[Dict[str, Any]] = None):
+    def error(self, title: str, error: BaseException, extra: Optional[Dict[str, Any]] = None):
         """
         Log a message at the ERROR level
 
@@ -135,6 +135,7 @@ class LoggingMiddleware(BaseHTTPMiddleware):
             # This is required so that requesting the body content doesn't hang the request
             if request.headers.get('Content-Type') == 'application/json' and content_length < one_mb:
                 old_recieve = request._receive
+
                 # Add the debug logging into a new receive call that wraps the old one. This is required to make
                 # streaming requests and responses work as streaming sends further messages to trigger
                 # sending/receiving further data
@@ -170,11 +171,14 @@ class LoggingMiddleware(BaseHTTPMiddleware):
         return response
 
 
-def _print_stacktrace():
+def _print_stacktrace(err: Optional[BaseException] = None) -> str:
     """
     Prints out the current stack trace whilst unwinding all the logging calls on the way so it just shows the relevant
     parts. Will also extract any exceptions and print them at the end.
     """
+    if err is not None:
+        return ''.join(traceback.format_exception(type(err), err, err.__traceback__))
+
     exc = sys.exc_info()[0]
     stack = traceback.extract_stack()[:-1]
     if exc is not None:
@@ -192,7 +196,7 @@ def _print_stacktrace():
     trc = 'Traceback (most recent call last):\n'
     stackstr = trc + ''.join(traceback.format_list(stack))
     if exc is not None:
-        stackstr += '  ' + traceback.format_exc().lstrip(trc)   # pylint:disable=bad-str-strip-call
+        stackstr += '  ' + traceback.format_exc().lstrip(trc)
     return stackstr
 
 
@@ -204,11 +208,7 @@ class DaraProdFormatter(logging.Formatter):
 
     @staticmethod
     def _get_payload(record: logging.LogRecord) -> Dict[str, JsonSerializable]:
-        timestamp = time.strftime(
-            '%Y-%m-%dT%H:%M:%S', time.localtime(record.created)
-        ) + '.%s' % int(  # pylint:disable=consider-using-f-string
-            record.msecs
-        )
+        timestamp = time.strftime('%Y-%m-%dT%H:%M:%S', time.localtime(record.created)) + '.%s' % int(record.msecs)
         if isinstance(record.msg, dict):
             payload: Dict[str, JsonSerializable] = {
                 'timestamp': timestamp,
@@ -218,8 +218,9 @@ class DaraProdFormatter(logging.Formatter):
             }
 
             if record.levelname == 'ERROR':
-                payload['error'] = str(payload.pop('error'))
-                payload['stacktrace'] = _print_stacktrace()
+                err = payload.pop('error')
+                payload['error'] = str(err)
+                payload['stacktrace'] = _print_stacktrace(err if isinstance(err, BaseException) else None)
 
             return payload
 
@@ -284,8 +285,8 @@ class DaraDevFormatter(logging.Formatter):
 
             if record.levelname == 'ERROR':
                 error = ''
-                if payload.get('error'):
-                    error = _print_stacktrace()
+                if err := payload.get('error'):
+                    error = _print_stacktrace(err if isinstance(err, BaseException) else None)
                 content = base_msg
                 if record.__dict__.get('content'):
                     content = content + '\r\n' + self.extra_template % (spacer, record.__dict__['content'])

dara/core/main.py

@@ -14,6 +14,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 """
+
 import asyncio
 import os
 import sys
@@ -91,10 +92,11 @@ def _start_application(config: Configuration):
     os.environ['VITE_MANIFEST_PATH'] = f'{config.static_files_dir}/manifest.json'
     os.environ['VITE_STATIC_PATH'] = config.static_files_dir
     import fastapi_vite_dara
+    import fastapi_vite_dara.config
 
     if len(config.pages) > 0:
         BASE_DIR = Path(__file__).parent
-        jinja_templates = Jinja2Templates(directory=str((Path(BASE_DIR, 'jinja'))))
+        jinja_templates = Jinja2Templates(directory=str(Path(BASE_DIR, 'jinja')))
         jinja_templates.env.globals['vite_hmr_client'] = fastapi_vite_dara.vite_hmr_client
         jinja_templates.env.globals['vite_asset'] = fastapi_vite_dara.vite_asset
         jinja_templates.env.globals['static_url'] = fastapi_vite_dara.config.settings.static_url
@@ -107,7 +109,7 @@ def _start_application(config: Configuration):
 
     # Configure the default executor for threads run via the async loop
     loop = asyncio.get_event_loop()
-    loop.set_default_executor(ThreadPoolExecutor(max_workers=int(os.environ.get('DARA_NUM_COMPONENT_THREADS', 8))))
+    loop.set_default_executor(ThreadPoolExecutor(max_workers=int(os.environ.get('DARA_NUM_COMPONENT_THREADS', '8'))))
 
     is_production = os.environ.get('DARA_DOCKER_MODE') == 'TRUE'
 
@@ -169,7 +171,7 @@ def _start_application(config: Configuration):
                     worker_parameters={'task_module': config.task_module},
                     max_workers=max_workers,
                 )
-                await task_pool.start(60)   # timeout after 60s
+                await task_pool.start(60)  # timeout after 60s
                 utils_registry.set('TaskPool', task_pool)
                 dev_logger.info('Task pool initialized')
 
@@ -337,15 +339,15 @@ def _start_application(config: Configuration):
 
     # Start metrics server in a daemon thread
     if os.environ.get('DARA_DISABLE_METRICS') != 'TRUE' and os.environ.get('DARA_TEST_FLAG', None) is None:
-        port = int(os.environ.get('DARA_METRICS_PORT', 10000))
+        port = int(os.environ.get('DARA_METRICS_PORT', '10000'))
         start_http_server(port)
 
     # Start profiling server in a daemon thread if explicitly enabled (only works on linux)
     if os.environ.get('DARA_PYPPROF_PORT', None) is not None:
-        profiling_port = int(os.environ.get('DARA_PYPPROF_PORT', 10001))
+        profiling_port = int(os.environ.get('DARA_PYPPROF_PORT', '10001'))
         dev_logger.warning('Starting cpu/memory profiling server', extra={'port': profiling_port})
 
-        from pypprof.net_http import start_pprof_server
+        from pypprof.net_http import start_pprof_server  # pyright: ignore[reportMissingImports]
 
         start_pprof_server(port=profiling_port)
 
@@ -358,7 +360,7 @@ def _start_application(config: Configuration):
     app.include_router(core_api_router, prefix='/api/core')
 
     @app.get('/api/{rest_of_path:path}')
-    async def not_found():  # pylint: disable=unused-variable
+    async def not_found():
         raise HTTPException(status_code=404, detail='API endpoint not found')
 
     if len(config.pages) > 0:
@@ -369,22 +371,23 @@ def _start_application(config: Configuration):
         # Auto-js mode - serve the built template with UMDs
         if build_cache.build_config.mode == BuildMode.AUTO_JS:
             # Load template
-            with open(os.path.join(Path(BASE_DIR, 'jinja'), 'index_autojs.html'), 'r', encoding='utf-8') as fp:
+            template_path = os.path.join(Path(BASE_DIR, 'jinja'), 'index_autojs.html')  # type: ignore
+            with open(template_path, encoding='utf-8') as fp:
                 template = fp.read()
 
             # Generate tags for the template
             template = build_autojs_template(template, build_cache, config)
 
             @app.get('/{full_path:path}', include_in_schema=False, response_class=HTMLResponse)
-            async def serve_app(request: Request):  # pylint: disable=unused-variable
+            async def serve_app(request: Request):  # pyright: ignore[reportRedeclaration]
                 return HTMLResponse(template)
 
         else:
             # Otherwise serve the Vite template
 
             @app.get('/{full_path:path}', include_in_schema=False, response_class=_TemplateResponse)
-            async def serve_app(request: Request):  # pylint: disable=unused-variable
-                return jinja_templates.TemplateResponse(request, 'index.html')
+            async def serve_app(request: Request):  # pyright: ignore[reportRedeclaration]
+                return jinja_templates.TemplateResponse(request, 'index.html')  # type: ignore
 
     return app
 

dara/core/metrics/cache.py

@@ -47,7 +47,7 @@ def format_bytes(num: Union[int, float]) -> str:
             # We only shrink the number if we HAVEN'T reached the last unit.
             num /= unit_step
 
-    return f'{num:.2f} {unit}'
+    return f'{num:.2f} {unit}'  # type: ignore
 
 
 class CacheMetricsTracker(BaseModel):

dara/core/metrics/utils.py

@@ -51,11 +51,11 @@ def total_size(o: object):
 
     try:
         all_handlers = {tuple: iter, list: iter, dict: dict_handler, set: iter, BaseModel: pydantic_handler}
-        seen = set()                      # track which object id's have already been seen
-        default_size = getsizeof(0)       # estimate sizeof object without __sizeof__
+        seen = set()  # track which object id's have already been seen
+        default_size = getsizeof(0)  # estimate sizeof object without __sizeof__
 
         def sizeof(o):
-            if id(o) in seen:       # do not double count the same object
+            if id(o) in seen:  # do not double count the same object
                 return 0
             seen.add(id(o))
             s = getsizeof(o, default_size)

dara/core/persistence.py

@@ -1,10 +1,10 @@
 import abc
 import json
 import os
+from collections.abc import Awaitable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Awaitable,
     Callable,
     Dict,
     List,
@@ -255,7 +255,7 @@ class BackendStore(PersistenceStore):
         user = USER.get()
 
         if user:
-            user_key = user.identity_id or user.identity_name
+            user_key = user.identity_id
 
             # Make sure the store is initialized
             if user_key not in self.initialized_scopes:
@@ -277,7 +277,7 @@ class BackendStore(PersistenceStore):
         if key == 'global':
             return None
 
-        # otherwise key is a user identity_id or identity_name
+        # otherwise key is a user identity_id
         return key
 
     def _register(self):
@@ -374,7 +374,7 @@ class BackendStore(PersistenceStore):
         if not user:
             return
 
-        user_identifier = user.identity_id or user.identity_name
+        user_identifier = user.identity_id
         return await self._notify_user(user_identifier, value=value, ignore_channel=ignore_channel)
 
     async def _notify_patches(self, patches: List[Dict[str, Any]]):
@@ -393,7 +393,7 @@ class BackendStore(PersistenceStore):
         if not user:
             return
 
-        user_identifier = user.identity_id or user.identity_name
+        user_identifier = user.identity_id
         return await self._notify_user(user_identifier, patches=patches)
 
     async def init(self, variable: 'Variable'):
@@ -540,3 +540,25 @@ class BackendStoreEntry(BaseModel):
     uid: str
     store: BackendStore
     """Store instance"""
+
+
+class BrowserStore(PersistenceStore):
+    """
+    Persistence store implementation that uses browser local storage
+    """
+
+    async def init(self, variable: 'Variable'):
+        # noop
+        pass
+
+
+class QueryParamStore(PersistenceStore):
+    """
+    Persistence store implementation that uses a URL query parameter
+    """
+
+    query: str
+
+    async def init(self, variable: 'Variable'):
+        # noop
+        pass