fractal-server 2.7.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

fractal_server/tasks/v2/templates/_1_create_venv.sh

@@ -33,14 +33,6 @@ write_log "START create venv in ${PACKAGE_ENV_DIR}"
 "$PYTHON" -m venv "$PACKAGE_ENV_DIR" --copies
 write_log "END   create venv in ${PACKAGE_ENV_DIR}"
 echo
-VENVPYTHON=${PACKAGE_ENV_DIR}/bin/python
-if [ -f "$VENVPYTHON" ]; then
-    write_log "OK: $VENVPYTHON exists."
-    echo
-else
-    write_log "ERROR: $VENVPYTHON not found"
-    exit 2
-fi
 
 # End
 TIME_END=$(date +%s)

fractal_server/tasks/v2/templates/_2_preliminary_pip_operations.sh

@@ -14,8 +14,8 @@ VENVPYTHON=${PACKAGE_ENV_DIR}/bin/python
 
 # Upgrade pip
 write_log "START upgrade pip"
-"$VENVPYTHON" -m pip install "pip<=__FRACTAL_MAX_PIP_VERSION__" --upgrade
-"$VENVPYTHON" -m pip install setuptools
+"$VENVPYTHON" -m pip install --no-cache-dir "pip<=__FRACTAL_MAX_PIP_VERSION__" --upgrade
+"$VENVPYTHON" -m pip install --no-cache-dir setuptools
 write_log "END   upgrade pip"
 echo
 

fractal_server/tasks/v2/templates/_3_pip_install.sh

@@ -9,6 +9,7 @@ write_log(){
 # Variables to be filled within fractal-server
 PACKAGE_ENV_DIR=__PACKAGE_ENV_DIR__
 INSTALL_STRING=__INSTALL_STRING__
+PINNED_PACKAGE_LIST="__PINNED_PACKAGE_LIST__"
 
 TIME_START=$(date +%s)
 
@@ -16,10 +17,30 @@ VENVPYTHON=${PACKAGE_ENV_DIR}/bin/python
 
 # Install package
 write_log "START install ${INSTALL_STRING}"
-"$VENVPYTHON" -m pip install "$INSTALL_STRING"
+"$VENVPYTHON" -m pip install --no-cache-dir "$INSTALL_STRING"
 write_log "END   install ${INSTALL_STRING}"
 echo
 
+
+# Optionally install pinned versions
+if [ "$PINNED_PACKAGE_LIST" != "" ]; then
+    write_log "START installing pinned versions $PINNED_PACKAGE_LIST"
+    for PINNED_PKG_VERSION in $PINNED_PACKAGE_LIST; do
+
+        PKGNAME=$(echo "$PINNED_PKG_VERSION" | cut -d '=' -f 1)
+        write_log "INFO: package name $PKGNAME"
+        "$VENVPYTHON" -m pip show "$PKGNAME"
+
+    done
+
+    write_log "All packages in ${PINNED_PACKAGE_LIST} are already installed, proceed with specific versions."
+    "$VENVPYTHON" -m pip install --no-cache-dir "$PINNED_PACKAGE_LIST"
+    write_log "END installing pinned versions $PINNED_PACKAGE_LIST"
+else
+    write_log "SKIP installing pinned versions $PINNED_PACKAGE_LIST (empty list)"
+fi
+
+
 # End
 TIME_END=$(date +%s)
 write_log "All good up to here."

fractal_server/tasks/v2/templates/_5_pip_show.sh

@@ -26,16 +26,16 @@ write_log "START pip show"
 $VENVPYTHON -m pip show ${PACKAGE_NAME}
 write_log "END   pip show"
 echo
-PACKAGE_NAME=$($VENVPYTHON -m pip show ${PACKAGE_NAME} | grep "Name:" | cut -d ":" -f 2 | tr -d "[:space:]")
+PACKAGE_NAME=$($VENVPYTHON -m pip show "$PACKAGE_NAME" | grep "Name:" | cut -d ":" -f 2 | tr -d "[:space:]")
 write_log "Package name: $PACKAGE_NAME"
 echo
-PACKAGE_VERSION=$($VENVPYTHON -m pip show ${PACKAGE_NAME} | grep "Version:" | cut -d ":" -f 2 | tr -d "[:space:]")
+PACKAGE_VERSION=$($VENVPYTHON -m pip show "$PACKAGE_NAME" | grep "Version:" | cut -d ":" -f 2 | tr -d "[:space:]")
 write_log "Package version: $PACKAGE_VERSION"
 echo
-PACKAGE_PARENT_FOLDER=$($VENVPYTHON -m pip show ${PACKAGE_NAME} | grep "Location:" | cut -d ":" -f 2 | tr -d "[:space:]")
+PACKAGE_PARENT_FOLDER=$($VENVPYTHON -m pip show "$PACKAGE_NAME" | grep "Location:" | cut -d ":" -f 2 | tr -d "[:space:]")
 write_log "Package parent folder: $PACKAGE_PARENT_FOLDER"
 echo
-MANIFEST_RELATIVE_PATH=$($VENVPYTHON -m pip show ${PACKAGE_NAME} --files | grep "__FRACTAL_MANIFEST__.json" | tr -d "[:space:]")
+MANIFEST_RELATIVE_PATH=$($VENVPYTHON -m pip show "$PACKAGE_NAME" --files | grep "__FRACTAL_MANIFEST__.json" | tr -d "[:space:]")
 write_log "Manifest relative path: $MANIFEST_RELATIVE_PATH"
 echo
 MANIFEST_ABSOLUTE_PATH="${PACKAGE_PARENT_FOLDER}/${MANIFEST_RELATIVE_PATH}"
@@ -46,7 +46,7 @@ if [ -f "$MANIFEST_ABSOLUTE_PATH" ]; then
     echo
 else
     write_log "ERROR: manifest path not found at $MANIFEST_ABSOLUTE_PATH"
-    exit 3
+    exit 2
 fi
 
 # End

fractal_server/tasks/v2/utils_background.py

@@ -0,0 +1,209 @@
+from pathlib import Path
+from typing import Optional
+
+from sqlalchemy.orm import Session as DBSyncSession
+from sqlalchemy.orm.attributes import flag_modified
+from sqlmodel import select
+
+from fractal_server.app.models.v2 import CollectionStateV2
+from fractal_server.app.models.v2 import TaskGroupV2
+from fractal_server.app.schemas.v2 import CollectionStatusV2
+from fractal_server.app.schemas.v2 import TaskCreateV2
+from fractal_server.app.schemas.v2.manifest import ManifestV2
+from fractal_server.logger import get_logger
+from fractal_server.logger import reset_logger_handlers
+
+
+def _set_collection_state_data_status(
+    *,
+    state_id: int,
+    new_status: CollectionStatusV2,
+    logger_name: str,
+    db: DBSyncSession,
+):
+    logger = get_logger(logger_name)
+    logger.debug(f"{state_id=} - set state.data['status'] to {new_status}")
+    collection_state = db.get(CollectionStateV2, state_id)
+    collection_state.data["status"] = CollectionStatusV2(new_status)
+    flag_modified(collection_state, "data")
+    db.commit()
+
+
+def _set_collection_state_data_log(
+    *,
+    state_id: int,
+    new_log: str,
+    logger_name: str,
+    db: DBSyncSession,
+):
+    logger = get_logger(logger_name)
+    logger.debug(f"{state_id=} - set state.data['log']")
+    collection_state = db.get(CollectionStateV2, state_id)
+    collection_state.data["log"] = new_log
+    flag_modified(collection_state, "data")
+    db.commit()
+
+
+def _set_collection_state_data_info(
+    *,
+    state_id: int,
+    new_info: str,
+    logger_name: str,
+    db: DBSyncSession,
+):
+    logger = get_logger(logger_name)
+    logger.debug(f"{state_id=} - set state.data['info']")
+    collection_state = db.get(CollectionStateV2, state_id)
+    collection_state.data["info"] = new_info
+    flag_modified(collection_state, "data")
+    db.commit()
+
+
+def _handle_failure(
+    state_id: int,
+    logger_name: str,
+    exception: Exception,
+    db: DBSyncSession,
+    task_group_id: int,
+    log_file_path: Path,
+):
+    logger = get_logger(logger_name)
+    logger.error(f"Task collection failed. Original error: {str(exception)}")
+
+    _set_collection_state_data_status(
+        state_id=state_id,
+        new_status=CollectionStatusV2.FAIL,
+        logger_name=logger_name,
+        db=db,
+    )
+
+    new_log = log_file_path.open("r").read()
+
+    _set_collection_state_data_log(
+        state_id=state_id,
+        new_log=new_log,
+        logger_name=logger_name,
+        db=db,
+    )
+    # For backwards-compatibility, we also set state.data["info"]
+    _set_collection_state_data_info(
+        state_id=state_id,
+        new_info=f"Original error: {exception}",
+        logger_name=logger_name,
+        db=db,
+    )
+
+    # Delete TaskGroupV2 object / and apply cascade operation to FKs
+    logger.info(f"Now delete TaskGroupV2 with {task_group_id=}")
+    logger.info("Start of CollectionStateV2 cascade operations.")
+    stm = select(CollectionStateV2).where(
+        CollectionStateV2.taskgroupv2_id == task_group_id
+    )
+    res = db.execute(stm)
+    collection_states = res.scalars().all()
+    for collection_state in collection_states:
+        logger.info(
+            f"Setting CollectionStateV2[{collection_state.id}].taskgroupv2_id "
+            "to None."
+        )
+        collection_state.taskgroupv2_id = None
+        db.add(collection_state)
+    logger.info("End of CollectionStateV2 cascade operations.")
+    task_group = db.get(TaskGroupV2, task_group_id)
+    db.delete(task_group)
+    db.commit()
+    logger.info(f"TaskGroupV2 with {task_group_id=} deleted")
+
+    reset_logger_handlers(logger)
+    return
+
+
+def _prepare_tasks_metadata(
+    *,
+    package_manifest: ManifestV2,
+    python_bin: Path,
+    package_root: Path,
+    package_version: Optional[str] = None,
+) -> list[TaskCreateV2]:
+    """
+    Based on the package manifest and additional info, prepare the task list.
+
+    Args:
+        package_manifest:
+        python_bin:
+        package_root:
+        package_version:
+    """
+    task_list = []
+    for _task in package_manifest.task_list:
+        # Set non-command attributes
+        task_attributes = {}
+        if package_version is not None:
+            task_attributes["version"] = package_version
+        if package_manifest.has_args_schemas:
+            task_attributes[
+                "args_schema_version"
+            ] = package_manifest.args_schema_version
+        # Set command attributes
+        if _task.executable_non_parallel is not None:
+            non_parallel_path = package_root / _task.executable_non_parallel
+            task_attributes["command_non_parallel"] = (
+                f"{python_bin.as_posix()} " f"{non_parallel_path.as_posix()}"
+            )
+        if _task.executable_parallel is not None:
+            parallel_path = package_root / _task.executable_parallel
+            task_attributes[
+                "command_parallel"
+            ] = f"{python_bin.as_posix()} {parallel_path.as_posix()}"
+        # Create object
+        task_obj = TaskCreateV2(
+            **_task.dict(
+                exclude={
+                    "executable_non_parallel",
+                    "executable_parallel",
+                }
+            ),
+            **task_attributes,
+            authors=package_manifest.authors,
+        )
+        task_list.append(task_obj)
+    return task_list
+
+
+def check_task_files_exist(task_list: list[TaskCreateV2]) -> None:
+    """
+    Check that the modules listed in task commands point to existing files.
+
+    Args:
+        task_list:
+    """
+    for _task in task_list:
+        if _task.command_non_parallel is not None:
+            _task_path = _task.command_non_parallel.split()[1]
+            if not Path(_task_path).exists():
+                raise FileNotFoundError(
+                    f"Task `{_task.name}` has `command_non_parallel` "
+                    f"pointing to missing file `{_task_path}`."
+                )
+        if _task.command_parallel is not None:
+            _task_path = _task.command_parallel.split()[1]
+            if not Path(_task_path).exists():
+                raise FileNotFoundError(
+                    f"Task `{_task.name}` has `command_parallel` "
+                    f"pointing to missing file `{_task_path}`."
+                )
+
+
+def _refresh_logs(
+    *,
+    state_id: int,
+    log_file_path: Path,
+    db: DBSyncSession,
+) -> None:
+    """
+    Read logs from file and update them in the db.
+    """
+    collection_state = db.get(CollectionStateV2, state_id)
+    collection_state.data["log"] = log_file_path.open("r").read()
+    flag_modified(collection_state, "data")
+    db.commit()

fractal_server/tasks/v2/utils_package_names.py

@@ -0,0 +1,77 @@
+import re
+
+from fractal_server.logger import get_logger
+
+
+def _parse_wheel_filename(wheel_filename: str) -> dict[str, str]:
+    """
+    Extract distribution and version from a wheel filename.
+
+    The structure of a wheel filename is fixed, and it must start with
+    `{distribution}-{version}` (see
+    https://packaging.python.org/en/latest/specifications/binary-distribution-format
+    ).
+
+    Note that we transform exceptions in `ValueError`s, since this function is
+    also used within Pydantic validators.
+    """
+    if "/" in wheel_filename:
+        raise ValueError(
+            "[_parse_wheel_filename] Input must be a filename, not a full "
+            f"path (given: {wheel_filename})."
+        )
+    try:
+        parts = wheel_filename.split("-")
+        return dict(distribution=parts[0], version=parts[1])
+    except Exception as e:
+        raise ValueError(
+            f"Invalid {wheel_filename=}. Original error: {str(e)}."
+        )
+
+
+def normalize_package_name(name: str) -> str:
+    """
+    Implement PyPa specifications for package-name normalization
+
+    The name should be lowercased with all runs of the characters `.`, `-`,
+    or `_` replaced with a single `-` character. This can be implemented in
+    Python with the re module.
+    (https://packaging.python.org/en/latest/specifications/name-normalization)
+
+    Args:
+        name: The non-normalized package name.
+
+    Returns:
+        The normalized package name.
+    """
+    return re.sub(r"[-_.]+", "-", name).lower()
+
+
+def compare_package_names(
+    *,
+    pkg_name_pip_show: str,
+    pkg_name_task_group: str,
+    logger_name: str,
+) -> None:
+    """
+    Compare the package names from `pip show` and from the db.
+    """
+    logger = get_logger(logger_name)
+
+    if pkg_name_pip_show == pkg_name_task_group:
+        return
+
+    logger.warning(
+        f"Package name mismatch: "
+        f"{pkg_name_task_group=}, {pkg_name_pip_show=}."
+    )
+    normalized_pkg_name_pip = normalize_package_name(pkg_name_pip_show)
+    normalized_pkg_name_taskgroup = normalize_package_name(pkg_name_task_group)
+    if normalized_pkg_name_pip != normalized_pkg_name_taskgroup:
+        error_msg = (
+            f"Package name mismatch persists, after normalization: "
+            f"{pkg_name_task_group=}, "
+            f"{pkg_name_pip_show=}."
+        )
+        logger.error(error_msg)
+        raise ValueError(error_msg)

fractal_server/tasks/v2/{utils.py → utils_python_interpreter.py}

@@ -31,29 +31,3 @@ def get_python_interpreter_v2(
     if value is None:
         raise ValueError(f"Requested {python_version=}, but {key}={value}.")
     return value
-
-
-def _parse_wheel_filename(wheel_filename: str) -> dict[str, str]:
-    """
-    Extract distribution and version from a wheel filename.
-
-    The structure of a wheel filename is fixed, and it must start with
-    `{distribution}-{version}` (see
-    https://packaging.python.org/en/latest/specifications/binary-distribution-format
-    ).
-
-    Note that we transform exceptions in `ValueError`s, since this function is
-    also used within Pydantic validators.
-    """
-    if "/" in wheel_filename:
-        raise ValueError(
-            "[_parse_wheel_filename] Input must be a filename, not a full "
-            f"path (given: {wheel_filename})."
-        )
-    try:
-        parts = wheel_filename.split("-")
-        return dict(distribution=parts[0], version=parts[1])
-    except Exception as e:
-        raise ValueError(
-            f"Invalid {wheel_filename=}. Original error: {str(e)}."
-        )

fractal_server/tasks/v2/utils_templates.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+
+
+def customize_template(
+    *,
+    template_name: str,
+    replacements: list[tuple[str, str]],
+    script_path: str,
+) -> str:
+    """
+    Customize a bash-script template and write it to disk.
+
+    Args:
+        template_filename:
+        templates_folder:
+        replacements:
+    """
+    # Read template
+    template_path = TEMPLATES_DIR / template_name
+    with template_path.open("r") as f:
+        template_data = f.read()
+    # Customize template
+    script_data = template_data
+    for old_new in replacements:
+        script_data = script_data.replace(old_new[0], old_new[1])
+    # Write script locally
+    with open(script_path, "w") as f:
+        f.write(script_data)
+
+
+def parse_script_5_stdout(stdout: str) -> dict[str, str]:
+    """
+    Parse standard output of template 5.
+    """
+    searches = [
+        ("Python interpreter:", "python_bin"),
+        ("Package name:", "package_name"),
+        ("Package version:", "package_version"),
+        ("Package parent folder:", "package_root_parent"),
+        ("Manifest absolute path:", "manifest_path"),
+    ]
+    stdout_lines = stdout.splitlines()
+    attributes = dict()
+    for search, attribute_name in searches:
+        matching_lines = [_line for _line in stdout_lines if search in _line]
+        if len(matching_lines) == 0:
+            raise ValueError(f"String '{search}' not found in stdout.")
+        elif len(matching_lines) > 1:
+            raise ValueError(
+                f"String '{search}' found too many times "
+                f"({len(matching_lines)})."
+            )
+        else:
+            actual_line = matching_lines[0]
+            attribute_value = actual_line.split(search)[-1].strip(" ")
+            attributes[attribute_name] = attribute_value
+    return attributes

fractal_server/utils.py

@@ -14,13 +14,15 @@ This module provides general purpose utilities that are not specific to any
 subsystem.
 """
 import asyncio
+import shlex
+import subprocess  # nosec
 from datetime import datetime
 from datetime import timezone
 from pathlib import Path
-from shlex import split as shlex_split
 from typing import Optional
 
 from .logger import get_logger
+from .string_tools import validate_cmd
 
 
 def get_timestamp() -> datetime:
@@ -30,7 +32,7 @@ def get_timestamp() -> datetime:
     return datetime.now(tz=timezone.utc)
 
 
-async def execute_command(
+async def execute_command_async(
     *,
     command: str,
     cwd: Optional[Path] = None,
@@ -56,7 +58,7 @@ async def execute_command(
         RuntimeError: if the process exited with non-zero status. The error
             string is set to the `stderr` of the process.
     """
-    command_split = shlex_split(command)
+    command_split = shlex.split(command)
     cmd, *args = command_split
 
     logger = get_logger(logger_name)
@@ -75,3 +77,46 @@ async def execute_command(
     if proc.returncode != 0:
         raise RuntimeError(stderr.decode("utf-8"))
     return stdout.decode("utf-8")
+
+
+def execute_command_sync(
+    *,
+    command: str,
+    logger_name: Optional[str] = None,
+    allow_char: Optional[str] = None,
+) -> str:
+    """
+    Execute arbitrary command
+
+    If the command returns a return code different from zero, a `RuntimeError`
+    is raised.
+
+    Arguments:
+        command: Command to be executed.
+        logger_name: Name of the logger.
+        allow_char: Argument propagated to `validate_cmd`.
+    """
+    logger = get_logger(logger_name)
+    logger.debug(f"START subprocess call to '{command}'")
+    validate_cmd(command=command, allow_char=allow_char)
+    res = subprocess.run(  # nosec
+        shlex.split(command),
+        capture_output=True,
+        encoding="utf-8",
+    )
+    returncode = res.returncode
+    stdout = res.stdout
+    stderr = res.stderr
+    logger.debug(f"{returncode=}")
+    logger.debug(f"{stdout=}")
+    logger.debug(f"{stderr=}")
+    if res.returncode != 0:
+        logger.debug(f"ERROR in subprocess call to '{command}'")
+        raise RuntimeError(
+            f"Command {command} failed.\n"
+            f"returncode={res.returncode}\n"
+            f"{stdout=}\n"
+            f"{stderr=}\n"
+        )
+    logger.debug(f"END   subprocess call to '{command}'")
+    return stdout

{fractal_server-2.7.1.dist-info → fractal_server-2.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fractal-server
-Version: 2.7.1
+Version: 2.8.0
 Summary: Server component of the Fractal analytics platform
 Home-page: https://github.com/fractal-analytics-platform/fractal-server
 License: BSD-3-Clause
@@ -37,15 +37,20 @@ Description-Content-Type: text/markdown
 
 # Fractal Server
 
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/16e9cf11-d47d-4db8-a9b1-f5349e4175b7" alt="Fractal server" width="400">
+</p>
+
 [![PyPI version](https://img.shields.io/pypi/v/fractal-server?color=gree)](https://pypi.org/project/fractal-server/)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 [![CI Status](https://github.com/fractal-analytics-platform/fractal-server/actions/workflows/ci.yml/badge.svg)](https://github.com/fractal-analytics-platform/fractal-server/actions/workflows/ci.yml?query=branch%3Amain)
 [![Coverage](https://raw.githubusercontent.com/fractal-analytics-platform/fractal-server/python-coverage-comment-action-data/badge.svg)](https://htmlpreview.github.io/?https://github.com/fractal-analytics-platform/fractal-server/blob/python-coverage-comment-action-data/htmlcov/index.html)
-[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![Documentation Status](https://github.com/fractal-analytics-platform/fractal-server/actions/workflows/documentation.yaml/badge.svg)](https://fractal-analytics-platform.github.io/fractal-server)
 [![Benchmarks](https://img.shields.io/badge/Benchmarks-Done-blue)](https://htmlpreview.github.io/?https://github.com/fractal-analytics-platform/fractal-server/blob/benchmark-api/benchmarks/bench.html)
 
 [Fractal](https://fractal-analytics-platform.github.io/) is a framework developed at the [BioVisionCenter](https://www.biovisioncenter.uzh.ch/en.html) to process bioimaging data at scale in the OME-Zarr format and prepare the images for interactive visualization.
 
-![Fractal_overview](https://github.com/user-attachments/assets/286122d9-08cf-48e8-996d-3cf53e0a81c6)
+![Fractal_overview](https://github.com/user-attachments/assets/666c8797-2594-4b8e-b1d2-b43fca66d1df)
 
 This is the server component of the fractal analytics platform.
 Find more information about Fractal in general and the other repositories at
@@ -58,14 +63,12 @@ See https://fractal-analytics-platform.github.io/fractal-server.
 
 # Contributors and license
 
-Unless otherwise stated in each individual module, all Fractal components are
-released according to a BSD 3-Clause License, and Copyright is with Friedrich
-Miescher Institute for Biomedical Research and University of Zurich.
+Fractal was conceived in the Liberali Lab at the Friedrich Miescher Institute for Biomedical Research and in the Pelkmans Lab at the University of Zurich by [@jluethi](https://github.com/jluethi) and [@gusqgm](https://github.com/gusqgm). The Fractal project is now developed at the [BioVisionCenter](https://www.biovisioncenter.uzh.ch/en.html) at the University of Zurich and the project lead is with [@jluethi](https://github.com/jluethi). The core development is done under contract by [eXact lab S.r.l.](https://www.exact-lab.it).
+
+Unless otherwise specified, Fractal components are released under the BSD 3-Clause License, and copyright is with the BioVisionCenter at the University of Zurich.
 
 The SLURM compatibility layer is based on
 [`clusterfutures`](https://github.com/sampsyo/clusterfutures), by
 [@sampsyo](https://github.com/sampsyo) and collaborators, and it is released
 under the terms of the MIT license.
 
-Fractal was conceived in the Liberali Lab at the Friedrich Miescher Institute for Biomedical Research and in the Pelkmans Lab at the University of Zurich by [@jluethi](https://github.com/jluethi) and [@gusqgm](https://github.com/gusqgm). The Fractal project is now developed at the [BioVisionCenter](https://www.biovisioncenter.uzh.ch/en.html) at the University of Zurich and the project lead is with [@jluethi](https://github.com/jluethi). The core development is done under contract by [eXact lab S.r.l.](https://www.exact-lab.it/).
-