privateer-elements-sdk 2025.11.5__py3-none-any.whl

elements/cli/commands/algorithm.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python
+
+import click
+import asyncio
+import pandas as pd
+import yaml
+import json
+import elements.cli.lib.utils as tsu
+from elements.cli.lib.aliased_group import AliasedSuperGroup
+import elements.cli.lib.workflow as wf
+from elements.cli.commands.algorithm_version import version
+from elements.cli.commands.algorithm_computation import computation
+from elements.cli.commands.algorithm_config import config
+
+
+@click.command(cls=AliasedSuperGroup, help="'algorithm' super-group")
+@click.pass_context
+def algorithm(ctx):
+    pass
+
+
+algorithm.add_command(version)
+algorithm.add_command(computation)
+algorithm.add_command(config)
+
+
+@algorithm.command('get', help="Get algorithm info")
+@click.pass_context
+@click.option('-ia', '--algorithm_id', type=str, default=None)
+@click.option('-na', '--algorithm_name', type=str, default=None)
+@click.option('-t', '--truncate', type=int, default=36,
+              help="Truncate columns to this many chars. Use 0 for no truncation. (a full UUID is 36).")
+@click.option('-v', '--verbose', is_flag=True, default=False)
+def algorithm_get(ctx, algorithm_id=None, algorithm_name=None, truncate=0, verbose=False):
+
+    wf.check_environment_complete(raise_on_failure=True, verbose=verbose)
+    algos = []
+    if algorithm_id:
+        algos += asyncio.run(wf.get_algorithms(algorithm_ids=[algorithm_id]))
+    if algorithm_name:
+        algos += asyncio.run(wf.list_algorithms(algorithm_name=algorithm_name))
+
+    data = []
+    for algo in algos:
+        row = [algo.name, algo.id, algo.author]
+        if truncate:
+            row = [v[:truncate] for v in row]
+        data.append(row)
+
+    df = pd.DataFrame(data=data, columns=['name', 'algorithm_id', 'author'])
+    tsu.set_pandas_display()
+    click.echo(df)
+
+
+@algorithm.command('create', help="Create an algorithm object (no manifest)")
+@click.pass_context
+@click.option('-na', '--algorithm_name', type=str)
+@click.option('-a', '--author', type=str, default='TERRASCOPE_AUTHOR')
+@click.option('-dn', '--display_name', type=str)
+@click.option('-v', '--verbose', is_flag=True, default=False)
+@click.option('--dry_run', is_flag=True, default=False)
+def algorithm_create(
+        ctx,
+        algorithm_name,
+        author,
+        display_name,
+        verbose=False,
+        dry_run=False,
+):
+
+    wf.check_environment_complete(raise_on_failure=True, verbose=verbose)
+
+    author = tsu.get_author(author, raise_on_failure=True)
+    click.echo("Using the following information:")
+    click.echo(f"--> name:         {algorithm_name}")
+    click.echo(f"--> author:       {author}")
+    click.echo(f"--> display_name: {display_name}")
+
+    # create the manifest
+    if not dry_run:
+        algorithm_id = asyncio.run(wf.create_algorithm(
+            algorithm_name,
+            author,
+            display_name,
+        ))
+        tsu.echo_highlight_suffix("You're new algorithm_id is: ", algorithm_id, 'green')
+
+
+@algorithm.command('register', help="Create an algorithm, and register it. (with manifest)")
+@click.pass_context
+@click.option('-m', '--manifest_yaml', type=str)
+@click.option('-om', '--output_manifest', type=str, help="Can be json or yaml file")
+@click.option('-na', '--algorithm_name', type=str)
+@click.option('-a', '--author', type=str, default='TERRASCOPE_AUTHOR')
+@click.option('-dn', '--display_name', type=str)
+@click.option('-d', '--docker_version_hash', type=str)
+@click.option('-pv', '--value_price', default=wf.VALUE_PRICE_DEFAULT, type=float)
+@click.option('-pe', '--execution_price', default=wf.EXECUTION_PRICE_DEFAULT, type=float)
+@click.option('-nc', '--config_name', default=None, type=str,
+              help="Specify this to create an initial algorithm config.")
+@click.option('--dry_run', is_flag=True, default=False)
+@click.option('-V', '--version', type=str, default=None)
+@click.option('-v', '--verbose', is_flag=True, default=False)
+def algorithm_register(
+        ctx,
+        manifest_yaml,
+        output_manifest=None,
+        algorithm_name=None,
+        author=None,
+        display_name=None,
+        docker_version_hash=None,
+        value_price=wf.VALUE_PRICE_DEFAULT,
+        execution_price=wf.EXECUTION_PRICE_DEFAULT,
+        config_name=None,
+        dry_run=False,
+        version=None,
+        verbose=False,
+):
+
+    wf.check_environment_complete(raise_on_failure=True, verbose=verbose)
+    # create the manifest
+    input_manifest = None
+    with open(manifest_yaml, 'r') as fp:
+        input_manifest = yaml.safe_load(fp)
+    algorithm_name = tsu.override_manifest_param('name', algorithm_name, input_manifest, do_overwrite=True)
+    display_name = tsu.override_manifest_param('display_name', display_name, input_manifest, do_overwrite=True)
+    author = tsu.get_author(author, raise_on_failure=True)
+    # if the author is in the manifest, overwrite it with the command line / env-var value.
+    # This is only done in case the user wants to write the manifest to a file,
+    # ... we want that file to contain what was actually used.
+    if 'author' in input_manifest:
+        input_manifest['author'] = author
+    new_version = input_manifest['metadata']['version']
+    if version:
+        new_version = tsu.set_version(version, input_manifest, do_overwrite=True)
+
+    visualizer_config_names = input_manifest.get('visualizer_config_names', None)
+    image = wf.update_manifest_docker_hash(input_manifest, docker_version_hash)
+    manifest = wf.create_algorithm_manifest(input_manifest)
+
+    click.echo("Using the following information:")
+    click.echo(f"--> name:         {algorithm_name}")
+    click.echo(f"--> version:      {new_version}")
+    click.echo(f"--> author:       {author}")
+    click.echo(f"--> display_name: {display_name}")
+    click.echo(f"--> image:        {image}")
+    click.echo(f"--> prices:       {value_price} / {execution_price}")
+    click.echo(f"--> vis-names:    {visualizer_config_names}")
+
+    # create the manifest
+    if not dry_run:
+        algorithm_id, algorithm_version_id = asyncio.run(wf.new_algorithm(
+            algorithm_name,
+            author,
+            display_name,
+            manifest,
+            value_price=value_price,
+            execution_price=execution_price,
+            visualizer_config_names=visualizer_config_names,
+        ))
+        tsu.echo_highlight_suffix("You're new algorithm_id is: ", algorithm_id, 'green')
+        tsu.echo_highlight_suffix("You're new algorithm_version_id is: ", algorithm_version_id, 'green')
+
+        if config_name:
+            algorithm_config_id = create_config(algorithm_version_id, config_name, input_manifest)
+            tsu.echo_highlight_suffix("You're new algorithm_config_id is: ", algorithm_config_id, 'green')
+
+    if output_manifest:
+        with open(output_manifest, 'w') as fp:
+            if output_manifest.endswith('json'):
+                json.dump(input_manifest, fp, indent=4)
+            else:
+                yaml.dump(input_manifest, fp)
+
+
+@algorithm.command('update', help="Update an existing algorithm with manifest or pricing.")
+@click.pass_context
+@click.option('-m', '--manifest_yaml', type=str, required=True)
+@click.option('-ia', '--algorithm_id', type=str, required=True)
+@click.option('-om', '--output_manifest', type=str)
+@click.option('-d', '--docker_version_hash', type=str, default=None)
+@click.option('-pv', '--value_price', default=wf.VALUE_PRICE_DEFAULT, type=float)
+@click.option('-pe', '--execution_price', default=wf.EXECUTION_PRICE_DEFAULT, type=float)
+@click.option('--dry_run', is_flag=True, default=False)
+@click.option('-nc', '--config_name', default=None, type=str,
+              help="Specify this to create an initial algorithm config.")
+@click.option('-V', '--version', type=str, default=None)
+@click.option('-v', '--verbose', is_flag=True, default=False)
+def algorithm_update(
+        ctx,
+        manifest_yaml,
+        algorithm_id,
+        output_manifest=None,
+        docker_version_hash=None,
+        value_price=wf.VALUE_PRICE_DEFAULT,
+        execution_price=wf.EXECUTION_PRICE_DEFAULT,
+        config_name=None,
+        dry_run=False,
+        version=None,
+        verbose=False,
+):
+
+    wf.check_environment_complete(raise_on_failure=True, verbose=verbose)
+    command_line_version = version
+
+    # create the manifest
+    input_manifest = None
+    with open(manifest_yaml, 'r') as fp:
+        input_manifest = yaml.safe_load(fp)
+    algorithm_version = input_manifest['metadata']['version']
+    visualizer_config_names = input_manifest.get('visualizer_config_names', None)
+    if command_line_version:
+        if command_line_version in ['patch', 'minor', 'major']:
+            level = command_line_version
+            current_algorithm_version = asyncio.run(wf.get_current_algorithm_version(algorithm_id=algorithm_id))
+            new_algorithm_version = tsu.increment_version(current_algorithm_version, level=level)
+            click.echo(f"The current algorithm version is: {current_algorithm_version}.")
+            click.echo(f"Auto-incrementing at {level}-level to: {new_algorithm_version}")
+        else:
+            new_algorithm_version = command_line_version
+        algorithm_version = tsu.set_version(new_algorithm_version, input_manifest, do_overwrite=True)
+
+    image = wf.update_manifest_docker_hash(input_manifest, docker_version_hash)
+    manifest = wf.create_algorithm_manifest(input_manifest)
+
+    click.echo("Using the following information:")
+    click.echo(f"--> algorithm_id:  {algorithm_id}")
+    click.echo(f"--> image:         {image}")
+    click.echo(f"--> prices:        {value_price} / {execution_price}")
+    click.echo(f"--> version:       {algorithm_version}")
+    click.echo(f"--> viz-names:     {visualizer_config_names}")
+
+    # create the manifest
+    if not dry_run:
+        algorithm_version_id = asyncio.run(wf.update_algorithm(
+            algorithm_id,
+            manifest,
+            value_price=value_price,
+            execution_price=execution_price,
+            visualizer_config_names=visualizer_config_names,
+        ))
+        tsu.echo_highlight_suffix("Your updated algorithm_version_id is: ", algorithm_version_id, 'green')
+
+        if config_name:
+            algorithm_config_id = create_config(algorithm_version_id, config_name, input_manifest)
+            tsu.echo_highlight_suffix("You're new algorithm_config_id is: ", algorithm_config_id, 'green')
+
+    if output_manifest:
+        with open(output_manifest, 'w') as fp:
+            if output_manifest.endswith('json'):
+                json.dump(input_manifest, fp, indent=4)
+            else:
+                yaml.dump(input_manifest, fp)
+
+
+def create_config(algorithm_version_id, config_name, input_manifest):
+
+    # use a canned description as this is the first config for this algo version
+    config_desc = f"Initial algorithm config for {config_name}"
+
+    # if a config_name is provided, then we'll create an initial config
+    # Get the necessary params from the manifest.
+    try:
+        data_source = input_manifest['inputs'][0]['data_source_name']
+    except Exception:
+        click.secho("Data source must be provided in manifest", fg='red')
+        raise
+
+    try:
+        data_type = input_manifest['inputs'][0]['data_type_name']
+    except Exception:
+        click.secho("Data Type must be provided in manifest", fg='red')
+        raise
+
+    image_processing_spec = None
+    if 'parameters' in input_manifest['inputs'][0]:
+        image_processing_spec = input_manifest['inputs'][0]['parameters'].get('image_processing_spec', None)
+    data_parameters = {}
+    if image_processing_spec:
+        data_parameters['image_processing_spec'] = image_processing_spec
+
+    algorithm_config_id = asyncio.run(
+        wf.create_algorithm_config(
+            algorithm_version_id,
+            config_name,
+            config_desc,
+            tsu.FakeDataSource(data_source),
+            data_type,
+            data_parameters,
+        )
+    )
+    return algorithm_config_id

elements/cli/commands/algorithm_computation.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python
+
+import click
+import asyncio
+import os
+import elements.cli.lib.utils as tsu
+from elements.cli.lib.aliased_group import AliasedGroup
+import elements.cli.lib.workflow as wf
+
+
+@click.group(cls=AliasedGroup, help="Algorithm 'computation' command group")
+@click.pass_context
+def computation(ctx):
+    pass
+
+
+@computation.command(name='get')
+@click.pass_context
+@click.option('-ip', '--algorithm_computation_id', type=str)
+@click.option('-v', '--verbose', is_flag=True)
+def algorithm_computation_get(ctx, algorithm_computation_id, verbose):
+
+    wf.check_environment_complete(raise_on_failure=True)
+
+    algorithm_computation_info = asyncio.run(
+        wf.get_algorithm_computation_info([algorithm_computation_id])
+    )[0]
+    info = tsu.protobuf_to_dict(algorithm_computation_info)
+
+    click.secho(algorithm_computation_id, fg='cyan')
+    for k, v in info.items():
+        click.echo(f"{k:20s} {v}")
+
+
+@computation.command(name='create')
+@click.pass_context
+@click.option('-ic', '--algorithm_config_id', type=str)
+@click.option('-iac', '--aoi_collection_id', type=str)
+@click.option('-it', '--toi_id', type=str)
+@click.option('-s', '--start_date', type=str)
+@click.option('-e', '--end_date', type=str)
+@click.option('-af', '--aoi_file', type=str)
+@click.option('-d', '--date_format', type=str, default='%Y-%m-%d')
+@click.option('-f', '--frequency', type=click.IntRange(min=2, max=3, clamp=False), default=3,
+              help="HOURLY=2, DAILY=3")
+@click.option('--dry_run', is_flag=True)
+@click.option('-v', '--verbose', is_flag=True)
+def algorithm_computation_create(
+        ctx,
+        algorithm_config_id,
+        start_date,
+        end_date,
+        aoi_file,
+        date_format,
+        frequency,
+        dry_run,
+        verbose,
+        aoi_collection_id=None,
+        toi_id=None,
+):
+
+    wf.check_environment_complete(raise_on_failure=True)
+    click.echo("Using the following information:")
+    click.echo(f"--> algorithm_config_id:      {algorithm_config_id}")
+    click.echo(f"--> start_date:               {start_date}")
+    click.echo(f"--> end_date:                 {end_date}")
+    click.echo(f"--> aoi_file:                 {aoi_file}")
+    click.echo(f"--> date_format:              {date_format}")
+    click.echo(f"--> frequency:                {frequency}")
+    click.echo(f"--> aoi_collectin_id:         {aoi_collection_id}")
+    click.echo(f"--> toi_id:                   {toi_id}")
+
+    if not dry_run:
+
+        if aoi_collection_id and toi_id:
+            computation_id = asyncio.run(
+                wf.create_algorithm_computation(
+                    algorithm_config_id,
+                    toi_id,
+                    aoi_collection_id,
+                )
+            )
+        else:
+            computation_id = asyncio.run(
+                wf.create_algorithm_computation_aoi_toi(
+                    algorithm_config_id,
+                    start_date,
+                    end_date,
+                    aoi_file,
+                    date_format=date_format,
+                    frequency=frequency,
+                )
+            )
+
+        tsu.echo_highlight_suffix("computation_id: ", computation_id, 'green')
+
+
+@computation.command(name='run')
+@click.pass_context
+@click.option('-ip', '--algorithm_computation_id', type=str)
+@click.option('--dry_run', is_flag=True)
+@click.option('-v', '--verbose', is_flag=True)
+def algorithm_computation_run(
+        ctx,
+        algorithm_computation_id,
+        dry_run,
+        verbose,
+):
+
+    wf.check_environment_complete(raise_on_failure=True)
+    click.echo(f"Running algorithm_computation_id={algorithm_computation_id}  (dry_run={dry_run})")
+    if not dry_run:
+        asyncio.run(wf.run_algorithm_computations([algorithm_computation_id]))
+
+
+@computation.command(name='download')
+@click.pass_context
+@click.option('-ip', '--algorithm_computation_id', type=str)
+@click.option('-a', '--source_aoi_version', type=str)
+@click.option('-os', '--min_observation_start_ts', type=str)
+@click.option('-oe', '--max_observation_start_ts', type=str)
+@click.option('-d', '--download_dir', type=str)
+@click.option('-c', '--clobber', is_flag=True, help="Overwrite existing output")
+def algorithm_computation_download(
+    ctx,
+    algorithm_computation_id,
+    source_aoi_version=None,
+    min_observation_start_ts=None,
+    max_observation_start_ts=None,
+    download_dir=None,
+    clobber=False,
+):
+    wf.check_environment_complete(raise_on_failure=True)
+
+    if os.path.exists(download_dir):
+        if not clobber:
+            click.secho(f"Directory: {download_dir} exists. Run with '-c' to overwrite.  Exiting.", fg='red')
+            raise RuntimeError("Output file already exists.")
+        else:
+            click.secho(f"Directory: {download_dir} exists.  I'm removing it.", fg='yellow')
+            os.rmdir(download_dir)
+
+    asyncio.run(
+        wf.download_algorithm_computation_results(
+            algorithm_computation_ids=[algorithm_computation_id], source_aoi_version=source_aoi_version,
+            min_observation_start_ts=min_observation_start_ts, max_observation_start_ts=max_observation_start_ts,
+            download_dir=download_dir
+        )
+    )
+
+    if not os.path.exists(download_dir):
+        click.secho("NOT written", fg='red')
+    else:
+        click.secho("written.", fg='green')

elements/cli/commands/algorithm_config.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python
+
+import click
+import asyncio
+import pandas as pd
+import yaml
+import elements.cli.lib.utils as tsu
+from elements.cli.lib.aliased_group import AliasedGroup
+import elements.cli.lib.workflow as wf
+
+
+@click.group(cls=AliasedGroup, help="Algorithm 'config' command group")
+@click.pass_context
+def config(ctx):
+    pass
+
+
+@config.command('get')
+@click.pass_context
+@click.option('-ic', '--algorithm_config_id', type=str, default=None,
+              help="UUID of the algorithm config to look up.")
+@click.option('-iv', '--algorithm_version_id', type=str, default=None,
+              help="UUID of an algorithm version to look up associated algorithm configs.")
+@click.option('-n', '--algorithm_name', type=str, default=None,
+              help="Name of the algorithm to look up.  All matching algo versions will be queried")
+@click.option('-C', '--only_columns', multiple=True,
+              help="Include only the listed columns in output.")
+@click.option('-c', '--append_columns', multiple=True,
+              help="Append these columns to those shown by default.")
+@click.option('-T', '--transpose', is_flag=True,
+              help="Display the result in transpose (helpful to show algorithms with long string values).")
+def algorithm_config_get(
+        ctx,
+        algorithm_config_id,
+        algorithm_version_id,
+        algorithm_name,
+        only_columns,
+        append_columns,
+        transpose,
+):
+    algorithm_version_ids = []
+    if algorithm_version_id is not None:
+        algorithm_version_ids.append([algorithm_version_id, None, None])
+
+    # if requested by name, we'll look up the available version ids and run all of them.
+    if algorithm_name is not None:
+        algos = asyncio.run(wf.list_algorithms(algorithm_name))
+        for algo in algos:
+            algorithm_versions = asyncio.run(wf.get_algorithm_versions(algo.id))
+            for algorithm_version in algorithm_versions:
+                algorithm_version_ids.append([algorithm_version.id, algo.name, algo.id])
+
+    for algorithm_version_info in algorithm_version_ids:
+        algorithm_version_id = algorithm_version_info[0]
+        algorithm_configs = asyncio.run(wf.get_algorithm_configs(algorithm_version_id=algorithm_version_id))
+        _print_algorithm_configs(algorithm_version_info, algorithm_configs, only_columns, append_columns, transpose)
+
+    if algorithm_config_id:
+        algorithm_configs = asyncio.run(wf.get_algorithm_configs(algorithm_config_id=algorithm_config_id))
+        algorithm_version_info = [algorithm_version_id, None, None]
+        _print_algorithm_configs(algorithm_version_info, algorithm_configs, only_columns, append_columns, transpose)
+
+
+def _print_algorithm_configs(
+        algorithm_version_info,
+        algorithm_configs,
+        only_columns,
+        append_columns,
+        transpose
+):
+
+    algo_version_id, algo_name, algo_id = algorithm_version_info
+    click.secho(f"name: {algo_name}", fg='magenta')
+    click.secho(f"      algo_id:         {algo_id}", fg='magenta')
+    click.secho(f"      algo_version_id: {algo_version_id}", fg='magenta')
+
+    columns = ['name', 'id', 'description', 'created_on']
+    if only_columns:
+        columns = list(only_columns)
+    if append_columns:
+        columns = columns + list(append_columns)
+
+    algorithm_configs = tsu.protobuf_to_dict(algorithm_configs[0])
+    if 'algorithm_configs' in algorithm_configs:
+        algorithm_configs = algorithm_configs['algorithm_configs']
+    else:
+        algorithm_configs = [algorithm_configs]
+
+    data = []
+    for algorithm_config in algorithm_configs:
+        data.append(algorithm_config)
+    df = pd.DataFrame(data)
+    if 'all' not in columns:
+        df = df[tsu.match_columns(df.columns, columns)]
+    if transpose:
+        df = df.T.rename(columns={0: ""})
+    df = df.rename(columns={'id': 'algorithm_config_id'})
+    tsu.set_pandas_display()
+    click.secho(f"algorithm_version_id: {algo_version_id}", fg='cyan')
+    click.echo(df)
+
+
+@config.command('create')
+@click.pass_context
+@click.option('-iv', '--algorithm_version_id', type=str)
+@click.option('-m', '--manifest_yaml', type=str)
+@click.option('-nc', '--config_name', type=str)
+@click.option('-d', '--config_desc', type=str)
+@click.option('-s', '--data_source', type=str)
+@click.option('-t', '--data_type', type=str)
+@click.option('-p', '--image_processing_spec', type=str, default=None)
+@click.option('--dry_run', is_flag=True)
+def algorithm_config_create(
+        ctx,
+        algorithm_version_id,
+        manifest_yaml,
+        config_name,
+        config_desc,
+        data_source,
+        data_type,
+        image_processing_spec=None,
+        dry_run=False,
+):
+
+    wf.check_environment_complete(raise_on_failure=True)
+    input_manifest = None
+    with open(manifest_yaml, 'r') as fp:
+        input_manifest = yaml.safe_load(fp)
+
+    if not data_source:
+        try:
+            data_source = input_manifest['inputs'][0]['data_source_name']
+        except Exception:
+            click.secho("Data source must be provided in manifest or on commandline", fg='red')
+            raise
+
+    if not data_type:
+        try:
+            data_type = input_manifest['inputs'][0]['data_type_name']
+        except Exception:
+            click.secho("Data Type must be provided in manifest or on command line", fg='red')
+            raise
+
+    # image proc spec isn't always required.  if not given, check the manifest.  use it if it's provided.
+    if not image_processing_spec:
+        image_processing_spec = input_manifest['inputs'][0]['parameters'].get('image_processing_spec', None)
+    data_parameters = {}
+    if image_processing_spec:
+        data_parameters['image_processing_spec'] = image_processing_spec
+
+    click.echo("Using the following information:")
+    click.echo(f"--> algorithm_version_id:     {algorithm_version_id}")
+    click.echo(f"--> config_name:              {config_name}")
+    click.echo(f"--> config_desc:              {config_desc}")
+    click.echo(f"--> data_source:              {data_source}")
+    click.echo(f"--> data_type:                {data_type}")
+    click.echo(f"--> image_processing_spec:    {image_processing_spec}")
+
+    if not dry_run:
+        algorithm_config_id = asyncio.run(
+            wf.create_algorithm_config(
+                algorithm_version_id,
+                config_name,
+                config_desc,
+                data_source,
+                data_type,
+                data_parameters,
+            )
+        )
+        tsu.echo_highlight_suffix("You're new algorithm_config_id is: ", algorithm_config_id, 'green')
+
+
+@config.command('deactivate')
+@click.pass_context
+@click.option('-ic', '--algorithm_config_ids', type=str, multiple=True, required=True,
+              help="UUIDs of the algorithm_configs to deactivate")
+def algorithm_config_deactivate(
+        ctx,
+        algorithm_config_ids,
+):
+
+    response = asyncio.run(wf.deactivate_algorithm_configs(algorithm_config_ids=algorithm_config_ids))
+
+    click.echo("Deactivation response code: ", nl=False)
+    if response:
+        click.secho(f" {response} (FAILURE)", fg='red')
+    else:
+        click.secho(f" {response} (SUCCESS)", fg='green')