UncountablePythonSDK 0.0.111__py3-none-any.whl → 0.0.113__py3-none-any.whl

docs/conf.py

@@ -6,10 +6,10 @@
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
-from datetime import date
+import datetime
 
 project = "Uncountable SDK"
-copyright = f"{date.today().year}, Uncountable Inc"
+copyright = f"{datetime.datetime.now(tz=datetime.UTC).date().year}, Uncountable Inc"
 author = "Uncountable Inc"
 
 # -- General configuration ---------------------------------------------------

docs/justfile

@@ -1,5 +1,5 @@
 docs-setup-python:
-  curl -LsSf https://astral.sh/uv/0.6.1/install.sh | sh
+  curl -LsSf https://astral.sh/uv/0.7.1/install.sh | sh
   uv pip install -r requirements.txt
 
 docs-clean:

examples/integration-server/jobs/materials_auto/example_runsheet_wh.py

@@ -0,0 +1,35 @@
+from io import BytesIO
+
+from uncountable.core.file_upload import DataFileUpload, FileUpload
+from uncountable.integration.job import JobArguments, RunsheetWebhookJob, register_job
+from uncountable.types import entity_t
+
+
+@register_job
+class StandardRunsheetGenerator(RunsheetWebhookJob):
+    def build_runsheet(
+        self,
+        *,
+        args: JobArguments,
+        entities: list[entity_t.Entity],
+    ) -> FileUpload:
+        args.logger.log_info(f"Generating runsheet for {len(entities)} entities")
+
+        content = []
+        content.append("STANDARD LAB RUNSHEET\n")
+        content.append("=" * 30 + "\n\n")
+
+        for entity in entities:
+            content.append(f"Type: {entity.type}\n")
+            content.append(f"ID: {entity.id}\n")
+
+            if hasattr(entity, "field_values") and entity.field_values:
+                content.append("Field Values:\n")
+                for field in entity.field_values:
+                    content.append(f"  - {field.name}: {field.value}\n")
+
+            content.append("\n")
+
+        runsheet_data = "".join(content).encode("utf-8")
+
+        return DataFileUpload(name="lab_runsheet.txt", data=BytesIO(runsheet_data))

examples/integration-server/jobs/materials_auto/profile.yaml

@@ -41,3 +41,12 @@ jobs:
     executor:
       type: script
       import_path: example_wh
+  - id: example_runsheet_wh
+    type: webhook
+    name: Runsheet Webhook
+    signature_key_secret:
+      type: env
+      env_key: WH_RUNSHEET_SIGNATURE_KEY
+    executor:
+      type: script
+      import_path: example_runsheet_wh

examples/integration-server/pyproject.toml

@@ -16,7 +16,8 @@ dependencies = [
   "types-requests == 2.*",
   "types-simplejson == 3.*",
   "pandas-stubs",
-  "xlrd == 2.*"
+  "xlrd == 2.*",
+  "msgspec == 0.19.*"
 ]
 
 [tool.mypy]
@@ -221,4 +222,3 @@ max-locals=50
 
 [tool.setuptools]
 py-modules = []
-

pkgs/argument_parser/argument_parser.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import dataclasses
+import datetime
 import math
 import types
 import typing
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from datetime import date, datetime
+from datetime import date
 from decimal import Decimal
 from enum import Enum, auto
 from importlib import resources
@@ -335,10 +336,12 @@ def _build_parser_inner(
 
         return parse_int
 
-    if parsed_type is datetime:
+    if parsed_type is datetime.datetime:
 
         def parse_datetime(value: typing.Any) -> T:
-            if context.options.allow_direct_type and isinstance(value, datetime):
+            if context.options.allow_direct_type and isinstance(
+                value, datetime.datetime
+            ):
                 return value  # type: ignore
             return dateutil.parser.isoparse(value)  # type:ignore
 

pkgs/filesystem_utils/_blob_session.py

@@ -1,5 +1,6 @@
 from io import BytesIO
 
+from azure.core.credentials import AzureSasCredential
 from azure.storage.blob import BlobServiceClient, ContainerClient
 
 from pkgs.filesystem_utils.file_type_utils import (
@@ -122,7 +123,13 @@ class BlobSession(FileSystemSession):
             )
             dest_blob_client = self.container_client.get_blob_client(dest_file.filepath)
 
-            dest_blob_client.start_copy_from_url(source_blob_client.url)
+            source_url = (
+                f"{source_blob_client.url}?{self.config.credential.signature}"
+                if isinstance(self.config.credential, AzureSasCredential)
+                else source_blob_client.url
+            )
+
+            dest_blob_client.start_copy_from_url(source_url)
             source_blob_client.delete_blob()
 
     def delete_files(self, filepaths: list[FileSystemObject]) -> None:

pkgs/type_spec/emit_python.py

@@ -5,7 +5,7 @@ from decimal import Decimal
 from typing import Any
 
 from . import builder, util
-from .builder import EndpointEmitType, EndpointSpecificPath
+from .builder import EndpointEmitType, EndpointSpecificPath, base_namespace_name
 from .config import PythonConfig
 from .cross_output_links import get_path_links
 from .emit_open_api_util import EmitOpenAPIStabilityLevel
@@ -907,13 +907,19 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
 
     # Emit dataclass decorator
     dataclass = "@dataclasses.dataclass"
-    dc_args = []
+    refer_to(
+        ctx,
+        builder.SpecTypeDefnAlias(
+            namespace=ctx.builder.namespaces[base_namespace_name], name="ENABLE_SLOTS"
+        ),
+    )
+    dc_args = ["slots=base_t.ENABLE_SLOTS"]
     if stype.is_kw_only():
         dc_args.append("kw_only=True")
     if stype.is_hashable:
         dc_args.extend(["frozen=True", "eq=True"])
     if len(dc_args) > 0:
-        dataclass += f"({', '.join(dc_args)})"
+        dataclass += f"({', '.join(dc_args)})  # type: ignore[literal-required]"
 
     ctx.out.write(f"{dataclass}\n")
     ctx.out.write(class_out.getvalue())

pkgs/type_spec/emit_typescript_util.py

@@ -103,7 +103,7 @@ def emit_value_ts(
     elif isinstance(stype, builder.SpecTypeDefnStringEnum):
         return f"{refer_to(ctx, stype)}.{ts_enum_name(value, stype.name_case)}"
 
-    raise Exception("invalid constant type", value, stype)
+    raise Exception("invalid constant type", value, stype, type(stype))
 
 
 def emit_type_ts(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
@@ -266,3 +266,18 @@ def emit_namespace_imports_ts(
         )
         import_from = f"{import_path}{resolve_namespace_name(ns)}"
         out.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501
+
+
+def emit_namespace_imports_from_root_ts(
+    namespaces: set[builder.SpecNamespace],
+    out: io.StringIO,
+    root: str,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda name: resolve_namespace_name(name),
+    ):
+        import_as = resolve_namespace_ref(ns)
+        out.write(
+            f'import * as {import_as} from "{root}/{resolve_namespace_name(ns)}"\n'
+        )  # noqa: E501

pkgs/type_spec/parts/base.py.prepart

@@ -28,6 +28,10 @@ REF_NAME_STRICT_REGEX = rf"{REF_NAME_STRICT_REGEX_STRING}"
 ID_REGEX = r"-?[1-9][0-9]{0,20}"
 
 
+# ENABLE_SLOTS should be removed after slots have been tested locally
+import os
+ENABLE_SLOTS = os.environ.get("UNC_ENABLE_DATACLASS_SLOTS") == "true"
+
 if TYPE_CHECKING:
     JsonValue = Union[JsonScalar, Mapping[str, "JsonValue"], Sequence["JsonValue"]]
     ExtJsonValue = JsonValue

pkgs/type_spec/ui_entry_actions/__init__.py

@@ -0,0 +1,4 @@
+# CLOSED MODULE
+from .generate_ui_entry_actions import (
+    generate_entry_actions_typescript as generate_entry_actions_typescript,
+)

pkgs/type_spec/ui_entry_actions/generate_ui_entry_actions.py

@@ -0,0 +1,294 @@
+import json
+from dataclasses import dataclass
+from io import StringIO
+from pathlib import Path
+from typing import assert_never
+
+from main.base.types import (
+    ui_entry_actions_t,
+)
+from pkgs.argument_parser import snake_to_camel_case
+from pkgs.serialization_util import serialize_for_api
+from pkgs.type_spec import emit_typescript_util
+from pkgs.type_spec.builder import (
+    BaseTypeName,
+    NameCase,
+    RawDict,
+    SpecBuilder,
+    SpecNamespace,
+    SpecTypeDefnObject,
+)
+from pkgs.type_spec.config import Config
+from pkgs.type_spec.load_types import load_types
+from pkgs.type_spec.util import rewrite_file
+from pkgs.type_spec.value_spec.convert_type import convert_from_value_spec_type
+
+_INIT_ACTION_INDEX_TYPE_DATA = {
+    "EntryActionInfo<InputT, OutputT>": {
+        "type": BaseTypeName.s_object,
+        "properties": {"inputs": {"type": "InputT"}, "outputs": {"type": "OutputT"}},
+    }
+}
+_TYPES_ROOT = "unc_types"
+
+
+@dataclass(kw_only=True)
+class EntryActionTypeInfo:
+    inputs_type: SpecTypeDefnObject
+    outputs_type: SpecTypeDefnObject
+    name: str
+
+
+def ui_entry_variable_to_type_spec_type(
+    variable: ui_entry_actions_t.UiEntryActionVariable,
+) -> str:
+    match variable:
+        case ui_entry_actions_t.UiEntryActionVariableString():
+            return BaseTypeName.s_string
+        case ui_entry_actions_t.UiEntryActionVariableEntityFields():
+            return "entity.Entity"
+        case _:
+            assert_never(variable)
+
+
+def construct_inputs_type_data(
+    vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
+) -> RawDict:
+    if len(vars) == 0:
+        return {"type": BaseTypeName.s_object}
+    properties: dict[str, dict[str, str]] = {}
+    for input_name, input_defn in (vars).items():
+        properties[f"{input_name}"] = {
+            "type": ui_entry_variable_to_type_spec_type(input_defn)
+        }
+    return {"type": BaseTypeName.s_object, "properties": properties}
+
+
+def construct_outputs_type_data(
+    vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
+) -> RawDict:
+    if len(vars) == 0:
+        return {"type": BaseTypeName.s_object}
+    properties: dict[str, dict[str, str]] = {}
+    for output_name, output_defn in (vars).items():
+        # All outputs are optional
+        properties[f"{output_name}"] = {
+            "type": f"Optional<{convert_from_value_spec_type(output_defn.vs_type)}>"
+        }
+    return {"type": BaseTypeName.s_object, "properties": properties}
+
+
+def construct_outputs_type(
+    *,
+    action_scope: ui_entry_actions_t.ActionScope,
+    vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
+    builder: SpecBuilder,
+    namespace: SpecNamespace,
+) -> SpecTypeDefnObject:
+    stype = SpecTypeDefnObject(
+        namespace=namespace,
+        name=emit_typescript_util.ts_type_name(f"{action_scope}_outputs"),
+    )
+    namespace.types[stype.name] = stype
+    stype.process(
+        builder=builder,
+        data=construct_outputs_type_data(vars=vars),
+    )
+    return stype
+
+
+def construct_inputs_type(
+    *,
+    action_scope: ui_entry_actions_t.ActionScope,
+    vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
+    builder: SpecBuilder,
+    namespace: SpecNamespace,
+) -> SpecTypeDefnObject:
+    stype = SpecTypeDefnObject(
+        namespace=namespace,
+        name=emit_typescript_util.ts_type_name(f"{action_scope}_inputs"),
+    )
+    stype.process(builder=builder, data=construct_inputs_type_data(vars))
+    namespace.types[stype.name] = stype
+    return stype
+
+
+def _get_types_root(destination_root: Path) -> Path:
+    return destination_root / "types"
+
+
+def emit_imports_ts(
+    namespaces: set[SpecNamespace],
+    out: StringIO,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda ns: ns.name,
+    ):
+        import_as = emit_typescript_util.resolve_namespace_ref(ns)
+        import_from = f"{_TYPES_ROOT}/{ns.name}"
+        out.write(f'import * as {import_as} from "{import_from}"\n')
+
+
+def emit_entry_action_definition(
+    *,
+    ctx: emit_typescript_util.EmitTypescriptContext,
+    defn: ui_entry_actions_t.UiEntryActionDefinition,
+    builder: SpecBuilder,
+    action_scope: ui_entry_actions_t.ActionScope,
+) -> EntryActionTypeInfo:
+    inputs_type = construct_inputs_type(
+        action_scope=action_scope,
+        vars=defn.inputs,
+        builder=builder,
+        namespace=ctx.namespace,
+    )
+    outputs_type = construct_outputs_type(
+        action_scope=action_scope,
+        vars=defn.outputs,
+        builder=builder,
+        namespace=ctx.namespace,
+    )
+
+    return EntryActionTypeInfo(
+        inputs_type=inputs_type,
+        outputs_type=outputs_type,
+        name=action_scope,
+    )
+
+
+def emit_query_index(
+    ctx: emit_typescript_util.EmitTypescriptContext,
+    defn_infos: list[EntryActionTypeInfo],
+    index_path: Path,
+    builder: SpecBuilder,
+    definitions: dict[
+        ui_entry_actions_t.ActionScope, ui_entry_actions_t.UiEntryActionDefinition
+    ],
+) -> bool:
+    query_index_type_data = {
+        **_INIT_ACTION_INDEX_TYPE_DATA,
+        "EntityActionTypeLookup": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                defn_info.name: {
+                    "type": f"EntryActionInfo<{defn_info.inputs_type.name},{defn_info.outputs_type.name}>",
+                    "name_case": NameCase.preserve,
+                }
+                for defn_info in defn_infos
+            },
+        },
+        "InputInfo": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                "value_spec_var": {"type": "String"},
+                "variable": {"type": "ui_entry_actions.UiEntryActionVariable"},
+            },
+        },
+        "OutputInfo": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                "name": {"type": "String"},
+                "desc": {"type": "String"},
+                "type": {"type": "value_spec.BaseType"},
+            },
+        },
+        "DefinitionInfo": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                "inputs": {
+                    "type": "ReadonlyArray<InputInfo>",
+                },
+                "outputs": {
+                    "type": "ReadonlyArray<OutputInfo>",
+                },
+            },
+        },
+    }
+    ctx.namespace.prescan(query_index_type_data)
+    ctx.namespace.process(
+        builder=builder,
+        data=query_index_type_data,
+    )
+
+    defn_lookup_info = {}
+    for scope, defn in definitions.items():
+        inputs = []
+        outputs = []
+        for name, input in defn.inputs.items():
+            inputs.append(
+                serialize_for_api({
+                    "value_spec_var": snake_to_camel_case(name),
+                    "variable": input,
+                })
+            )
+        for name, output in defn.outputs.items():
+            outputs.append(
+                serialize_for_api({
+                    "name": name,
+                    "desc": output.description,
+                    "type": output.vs_type,
+                })
+            )
+        defn_lookup_info[scope] = {"inputs": inputs, "outputs": outputs}
+
+    defn_lookup_out = f"export const DEFINITION_LOOKUP = {json.dumps(defn_lookup_info, sort_keys=True, indent=2)} as const\n\nexport const DEFINITION_LOOKUP_TYPED = DEFINITION_LOOKUP as Record<UiEntryActionsT.ActionScope, DefinitionInfo>\n"
+
+    for stype in ctx.namespace.types.values():
+        emit_typescript_util.emit_type_ts(
+            ctx=ctx,
+            stype=stype,
+        )
+
+    import_buffer = StringIO()
+    emit_typescript_util.emit_namespace_imports_from_root_ts(
+        namespaces=ctx.namespaces,
+        out=import_buffer,
+        root=_TYPES_ROOT,
+    )
+
+    return rewrite_file(
+        content=import_buffer.getvalue() + ctx.out.getvalue() + defn_lookup_out,
+        filename=str(index_path),
+    )
+
+
+def generate_entry_actions_typescript(
+    *,
+    definitions: dict[
+        ui_entry_actions_t.ActionScope, ui_entry_actions_t.UiEntryActionDefinition
+    ],
+    destination_root: Path,
+    materials_type_spec_config: Config,
+) -> None:
+    builder = load_types(materials_type_spec_config)
+    assert builder is not None
+
+    definition_buffer = StringIO()
+    index_namespace = SpecNamespace(name="index")
+    ctx = emit_typescript_util.EmitTypescriptContext(
+        out=definition_buffer,
+        namespace=index_namespace,
+    )
+    builder.namespaces[index_namespace.name] = index_namespace
+
+    defn_infos: list[EntryActionTypeInfo] = []
+
+    for action_scope, defn in definitions.items():
+        defn_infos.append(
+            emit_entry_action_definition(
+                action_scope=action_scope,
+                ctx=ctx,
+                defn=defn,
+                builder=builder,
+            )
+        )
+
+    index_path = _get_types_root(destination_root) / "index.ts"
+    emit_query_index(
+        ctx=ctx,
+        builder=builder,
+        defn_infos=defn_infos,
+        definitions=definitions,
+        index_path=index_path,
+    )

pkgs/type_spec/value_spec/convert_type.py

@@ -61,3 +61,16 @@ def convert_to_value_spec_type(parsed: ParsedTypePath) -> value_spec_t.ValueType
     return value_spec_t.ValueType(base_type=mapped.base_type, parameters=parameters)
 
     # Our formatter was duplicating the previous line for an unknown reason, this comment blocks that
+
+
+def convert_from_value_spec_type(
+    base_type: value_spec_t.BaseType,
+) -> str:
+    for type_spec_type, mapped_type in TYPE_MAP.items():
+        if (
+            mapped_type.base_type == base_type
+            and mapped_type.param_count == 0
+            and mapped_type.variable_param_count is False
+        ):
+            return type_spec_type
+    raise ValueError(f"invalid value spec type {base_type}")

uncountable/core/client.py

@@ -1,8 +1,9 @@
 import base64
+import datetime
 import re
 import typing
 from dataclasses import dataclass
-from datetime import datetime, timedelta
+from datetime import UTC, timedelta
 from enum import StrEnum
 from io import BytesIO
 from urllib.parse import unquote, urljoin
@@ -145,7 +146,7 @@ class SDKError(Exception):
 @dataclass(kw_only=True)
 class OAuthBearerTokenCache:
     token: str
-    expires_at: datetime
+    expires_at: datetime.datetime
 
 
 @dataclass(kw_only=True)
@@ -274,7 +275,8 @@ class Client(ClientMethods):
         if (
             self._oauth_bearer_token_cache is None
             or (
-                self._oauth_bearer_token_cache.expires_at - datetime.now()
+                self._oauth_bearer_token_cache.expires_at
+                - datetime.datetime.now(tz=UTC)
             ).total_seconds()
             < OAUTH_REFRESH_WINDOW_SECONDS
         ):
@@ -290,7 +292,8 @@ class Client(ClientMethods):
             token_data = oauth_bearer_token_data_parser.parse_storage(data)
             self._oauth_bearer_token_cache = OAuthBearerTokenCache(
                 token=token_data.access_token,
-                expires_at=datetime.now() + timedelta(seconds=token_data.expires_in),
+                expires_at=datetime.datetime.now(tz=UTC)
+                + timedelta(seconds=token_data.expires_in),
             )
 
         return self._oauth_bearer_token_cache.token

uncountable/integration/executors/generic_upload_executor.py

@@ -1,7 +1,8 @@
+import datetime
 import io
 import os
 import re
-from datetime import datetime, timezone
+from datetime import UTC
 
 import paramiko
 
@@ -164,7 +165,7 @@ def _move_files_post_upload(
     appended_text = ""
 
     if remote_directory_scope.prepend_date_on_archive:
-        appended_text = f"-{datetime.now(timezone.utc).timestamp()}"
+        appended_text = f"-{datetime.datetime.now(UTC).timestamp()}"
 
     for file_path in success_file_paths:
         filename = os.path.split(file_path)[-1]

uncountable/integration/job.py

@@ -6,8 +6,9 @@ from dataclasses import dataclass
 from pkgs.argument_parser import CachedParser
 from uncountable.core.async_batch import AsyncBatchProcessor
 from uncountable.core.client import Client
+from uncountable.core.file_upload import FileUpload
 from uncountable.integration.telemetry import JobLogger
-from uncountable.types import base_t, webhook_job_t
+from uncountable.types import base_t, entity_t, webhook_job_t
 from uncountable.types.job_definition_t import JobDefinition, JobResult, ProfileMetadata
 
 
@@ -91,3 +92,25 @@ class RunsheetWebhookJob(WebhookJob[webhook_job_t.RunsheetWebhookPayload]):
     @property
     def webhook_payload_type(self) -> type:
         return webhook_job_t.RunsheetWebhookPayload
+
+    @abstractmethod
+    def build_runsheet(
+        self,
+        *,
+        args: JobArguments,
+        entities: list[entity_t.Entity],
+    ) -> FileUpload: ...
+
+    def run(
+        self, args: JobArguments, payload: webhook_job_t.RunsheetWebhookPayload
+    ) -> JobResult:
+        runsheet = self.build_runsheet(args=args, entities=payload.entities)
+
+        files = args.client.upload_files(file_uploads=[runsheet])
+        args.client.complete_async_upload(
+            async_job_id=payload.async_job_id, file_id=files[0].file_id
+        )
+
+        return JobResult(
+            success=True,
+        )

uncountable/integration/queue_runner/datastore/datastore_sqlite.py

@@ -1,5 +1,6 @@
+import datetime
 import uuid
-from datetime import datetime, timezone
+from datetime import UTC
 
 from sqlalchemy import delete, insert, select, update
 from sqlalchemy.engine import Engine
@@ -30,7 +31,7 @@ class DatastoreSqlite(Datastore):
             serialized_payload = serialize_for_storage(job_payload)
             queued_job_uuid = str(uuid.uuid4())
             num_attempts = 0
-            submitted_at = datetime.now(timezone.utc)
+            submitted_at = datetime.datetime.now(UTC)
             insert_stmt = insert(QueuedJob).values({
                 QueuedJob.id.key: queued_job_uuid,
                 QueuedJob.job_ref_name.key: job_ref_name,

uncountable/integration/scan_profiles.py

@@ -26,7 +26,7 @@ def load_profiles() -> list[job_definition_t.ProfileMetadata]:
         profile_name = profile_file.name
         try:
             definition = profile_parser.parse_yaml_resource(
-                package=".".join([profiles_module, profile_name]),
+                package=f"{profiles_module}.{profile_name}",
                 resource="profile.yaml",
             )
             for job in definition.jobs:

uncountable/integration/scheduler.py

@@ -1,9 +1,10 @@
+import datetime
 import multiprocessing
 import subprocess
 import sys
 import time
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import UTC
 
 from opentelemetry.trace import get_current_span
 
@@ -96,7 +97,7 @@ def _wait_queue_runner_online() -> None:
     QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS = 1
 
     num_attempts = 0
-    before = datetime.now(timezone.utc)
+    before = datetime.datetime.now(UTC)
     while num_attempts < MAX_QUEUE_RUNNER_HEALTH_CHECKS:
         try:
             if check_health(port=get_local_admin_server_port()):
@@ -105,7 +106,7 @@ def _wait_queue_runner_online() -> None:
             pass
         num_attempts += 1
         time.sleep(QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS)
-    after = datetime.now(timezone.utc)
+    after = datetime.datetime.now(UTC)
     duration_secs = (after - before).seconds
     raise Exception(f"queue runner failed to come online after {duration_secs} seconds")