snowflake-ml-python 1.1.1__py3-none-any.whl → 1.1.2__py3-none-any.whl

snowflake/ml/model/_client/ops/model_ops.py

@@ -0,0 +1,308 @@
+import pathlib
+import tempfile
+from typing import Any, Dict, List, Optional, Union, cast
+
+import yaml
+
+from snowflake.ml._internal.utils import sql_identifier
+from snowflake.ml.model import model_signature, type_hints
+from snowflake.ml.model._client.ops import metadata_ops
+from snowflake.ml.model._client.sql import (
+    model as model_sql,
+    model_version as model_version_sql,
+    stage as stage_sql,
+)
+from snowflake.ml.model._model_composer import model_composer
+from snowflake.ml.model._model_composer.model_manifest import (
+    model_manifest,
+    model_manifest_schema,
+)
+from snowflake.ml.model._packager.model_meta import model_meta, model_meta_schema
+from snowflake.ml.model._signatures import snowpark_handler
+from snowflake.snowpark import dataframe, session
+from snowflake.snowpark._internal import utils as snowpark_utils
+
+
+class ModelOperator:
+    def __init__(
+        self,
+        session: session.Session,
+        *,
+        database_name: sql_identifier.SqlIdentifier,
+        schema_name: sql_identifier.SqlIdentifier,
+    ) -> None:
+        # Ideally, we should only keep session object inside the client, however, some components other than client
+        # are requiring session object like ModelComposer and SnowparkDataFrameHandler. We currently cannot refractor
+        # them all but we should try to avoid use the _session object here unless no other choice.
+        self._session = session
+        self._stage_client = stage_sql.StageSQLClient(
+            session,
+            database_name=database_name,
+            schema_name=schema_name,
+        )
+        self._model_client = model_sql.ModelSQLClient(
+            session,
+            database_name=database_name,
+            schema_name=schema_name,
+        )
+        self._model_version_client = model_version_sql.ModelVersionSQLClient(
+            session,
+            database_name=database_name,
+            schema_name=schema_name,
+        )
+        self._metadata_ops = metadata_ops.MetadataOperator(
+            session,
+            database_name=database_name,
+            schema_name=schema_name,
+        )
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, ModelOperator):
+            return False
+        return (
+            self._stage_client == __value._stage_client
+            and self._model_client == __value._model_client
+            and self._model_version_client == __value._model_version_client
+        )
+
+    def prepare_model_stage_path(self, *, statement_params: Optional[Dict[str, Any]] = None) -> str:
+        stage_name = sql_identifier.SqlIdentifier(
+            snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
+        )
+        self._stage_client.create_tmp_stage(stage_name=stage_name, statement_params=statement_params)
+        return f"@{self._stage_client.fully_qualified_stage_name(stage_name)}/model"
+
+    def create_from_stage(
+        self,
+        composed_model: model_composer.ModelComposer,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        stage_path = str(composed_model.stage_path)
+        if self.validate_existence(
+            model_name=model_name,
+            statement_params=statement_params,
+        ):
+            if self.validate_existence(
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            ):
+                raise ValueError(
+                    f"Model {self._model_version_client.fully_qualified_model_name(model_name)} "
+                    f"version {version_name} already existed."
+                )
+            else:
+                self._model_version_client.add_version_from_stage(
+                    stage_path=stage_path,
+                    model_name=model_name,
+                    version_name=version_name,
+                    statement_params=statement_params,
+                )
+        else:
+            self._model_version_client.create_from_stage(
+                stage_path=stage_path,
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            )
+
+    def list_models_or_versions(
+        self,
+        *,
+        model_name: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> List[sql_identifier.SqlIdentifier]:
+        if model_name:
+            res = self._model_client.show_versions(
+                model_name=model_name,
+                statement_params=statement_params,
+            )
+        else:
+            res = self._model_client.show_models(
+                statement_params=statement_params,
+            )
+        return [sql_identifier.SqlIdentifier(row.name, case_sensitive=True) for row in res]
+
+    def validate_existence(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        if version_name:
+            res = self._model_client.show_versions(
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            )
+        else:
+            res = self._model_client.show_models(
+                model_name=model_name,
+                statement_params=statement_params,
+            )
+        return len(res) == 1
+
+    def get_comment(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        if version_name:
+            res = self._model_client.show_versions(
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            )
+        else:
+            res = self._model_client.show_models(
+                model_name=model_name,
+                statement_params=statement_params,
+            )
+        assert len(res) == 1
+        return cast(str, res[0].comment)
+
+    def set_comment(
+        self,
+        *,
+        comment: str,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        if version_name:
+            self._model_version_client.set_comment(
+                comment=comment,
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            )
+        else:
+            self._model_client.set_comment(
+                comment=comment,
+                model_name=model_name,
+                statement_params=statement_params,
+            )
+
+    def get_model_version_manifest(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> model_manifest_schema.ModelManifestDict:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self._model_version_client.get_file(
+                model_name=model_name,
+                version_name=version_name,
+                file_path=pathlib.PurePosixPath(model_manifest.ModelManifest.MANIFEST_FILE_REL_PATH),
+                target_path=pathlib.Path(tmpdir),
+                statement_params=statement_params,
+            )
+            mm = model_manifest.ModelManifest(pathlib.Path(tmpdir))
+            return mm.load()
+
+    def get_model_version_native_packing_meta(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> model_meta_schema.ModelMetadataDict:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            model_meta_file_path = self._model_version_client.get_file(
+                model_name=model_name,
+                version_name=version_name,
+                file_path=pathlib.PurePosixPath(
+                    model_composer.ModelComposer.MODEL_DIR_REL_PATH, model_meta.MODEL_METADATA_FILE
+                ),
+                target_path=pathlib.Path(tmpdir),
+                statement_params=statement_params,
+            )
+            with open(model_meta_file_path, encoding="utf-8") as f:
+                raw_model_meta = yaml.safe_load(f)
+            return model_meta.ModelMetadata._validate_model_metadata(raw_model_meta)
+
+    def invoke_method(
+        self,
+        *,
+        method_name: sql_identifier.SqlIdentifier,
+        signature: model_signature.ModelSignature,
+        X: Union[type_hints.SupportedDataType, dataframe.DataFrame],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, str]] = None,
+    ) -> Union[type_hints.SupportedDataType, dataframe.DataFrame]:
+        identifier_rule = model_signature.SnowparkIdentifierRule.INFERRED
+
+        # Validate and prepare input
+        if not isinstance(X, dataframe.DataFrame):
+            keep_order = True
+            output_with_input_features = False
+            df = model_signature._convert_and_validate_local_data(X, signature.inputs)
+            s_df = snowpark_handler.SnowparkDataFrameHandler.convert_from_df(self._session, df, keep_order=keep_order)
+        else:
+            keep_order = False
+            output_with_input_features = True
+            identifier_rule = model_signature._validate_snowpark_data(X, signature.inputs)
+            s_df = X
+
+        original_cols = s_df.columns
+
+        # Compose input and output names
+        input_args = []
+        for input_feature in signature.inputs:
+            col_name = identifier_rule.get_sql_identifier_from_feature(input_feature.name)
+
+            input_args.append(col_name)
+
+        returns = []
+        for output_feature in signature.outputs:
+            output_name = identifier_rule.get_sql_identifier_from_feature(output_feature.name)
+            returns.append((output_feature.name, output_feature.as_snowpark_type(), output_name))
+            # Avoid removing output cols when output_with_input_features is False
+            if output_name in original_cols:
+                original_cols.remove(output_name)
+
+        df_res = self._model_version_client.invoke_method(
+            method_name=method_name,
+            input_df=s_df,
+            input_args=input_args,
+            returns=returns,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+
+        if keep_order:
+            df_res = df_res.sort(
+                "_ID",
+                ascending=True,
+            )
+
+        if not output_with_input_features:
+            df_res = df_res.drop(*original_cols)
+
+        # Get final result
+        if not isinstance(X, dataframe.DataFrame):
+            return snowpark_handler.SnowparkDataFrameHandler.convert_to_df(df_res, features=signature.outputs)
+        else:
+            return df_res
+
+    def delete_model_or_version(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        # TODO: Delete version is not supported yet.
+        self._model_client.drop_model(
+            model_name=model_name,
+            statement_params=statement_params,
+        )

snowflake/ml/model/_client/sql/model.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict, List, Optional
+
+from snowflake.ml._internal.utils import identifier, sql_identifier
+from snowflake.snowpark import row, session
+
+
+class ModelSQLClient:
+    def __init__(
+        self,
+        session: session.Session,
+        *,
+        database_name: sql_identifier.SqlIdentifier,
+        schema_name: sql_identifier.SqlIdentifier,
+    ) -> None:
+        self._session = session
+        self._database_name = database_name
+        self._schema_name = schema_name
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, ModelSQLClient):
+            return False
+        return self._database_name == __value._database_name and self._schema_name == __value._schema_name
+
+    def fully_qualified_model_name(self, model_name: sql_identifier.SqlIdentifier) -> str:
+        return identifier.get_schema_level_object_identifier(
+            self._database_name.identifier(), self._schema_name.identifier(), model_name.identifier()
+        )
+
+    def show_models(
+        self,
+        *,
+        model_name: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> List[row.Row]:
+        fully_qualified_schema_name = ".".join([self._database_name.identifier(), self._schema_name.identifier()])
+        like_sql = ""
+        if model_name:
+            like_sql = f" LIKE '{model_name.resolved()}'"
+        res = self._session.sql(f"SHOW MODELS{like_sql} IN SCHEMA {fully_qualified_schema_name}")
+
+        return res.collect(statement_params=statement_params)
+
+    def show_versions(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: Optional[sql_identifier.SqlIdentifier] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> List[row.Row]:
+        like_sql = ""
+        if version_name:
+            like_sql = f" LIKE '{version_name.resolved()}'"
+        res = self._session.sql(f"SHOW VERSIONS{like_sql} IN MODEL {self.fully_qualified_model_name(model_name)}")
+
+        return res.collect(statement_params=statement_params)
+
+    def set_comment(
+        self,
+        *,
+        comment: str,
+        model_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        comment_sql = f"COMMENT ON MODEL {self.fully_qualified_model_name(model_name)} IS $${comment}$$"
+        self._session.sql(comment_sql).collect(statement_params=statement_params)
+
+    def drop_model(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._session.sql(f"DROP MODEL {self.fully_qualified_model_name(model_name)}").collect(
+            statement_params=statement_params
+        )

snowflake/ml/model/_client/sql/model_version.py

@@ -0,0 +1,213 @@
+import json
+import pathlib
+import textwrap
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import ParseResult
+
+from snowflake.ml._internal.utils import identifier, sql_identifier
+from snowflake.snowpark import dataframe, functions as F, session, types as spt
+from snowflake.snowpark._internal import utils as snowpark_utils
+
+
+def _normalize_url_for_sql(url: str) -> str:
+    if url.startswith("'") and url.endswith("'"):
+        url = url[1:-1]
+    url = url.replace("'", "\\'")
+    return f"'{url}'"
+
+
+class ModelVersionSQLClient:
+    def __init__(
+        self,
+        session: session.Session,
+        *,
+        database_name: sql_identifier.SqlIdentifier,
+        schema_name: sql_identifier.SqlIdentifier,
+    ) -> None:
+        self._session = session
+        self._database_name = database_name
+        self._schema_name = schema_name
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, ModelVersionSQLClient):
+            return False
+        return self._database_name == __value._database_name and self._schema_name == __value._schema_name
+
+    def fully_qualified_model_name(self, model_name: sql_identifier.SqlIdentifier) -> str:
+        return identifier.get_schema_level_object_identifier(
+            self._database_name.identifier(), self._schema_name.identifier(), model_name.identifier()
+        )
+
+    def create_from_stage(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        stage_path: str,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._version_name = version_name
+        self._session.sql(
+            f"CREATE MODEL {self.fully_qualified_model_name(model_name)} WITH VERSION {version_name.identifier()}"
+            f" FROM {stage_path}"
+        ).collect(statement_params=statement_params)
+
+    # TODO(SNOW-987381): Merge with above when we have `create or alter module m [with] version v1 ...`
+    def add_version_from_stage(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        stage_path: str,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._version_name = version_name
+        self._session.sql(
+            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} ADD VERSION {version_name.identifier()}"
+            f" FROM {stage_path}"
+        ).collect(statement_params=statement_params)
+
+    def set_default_version(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._session.sql(
+            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} "
+            f"SET DEFAULT_VERSION = {version_name.identifier()}"
+        ).collect(statement_params=statement_params)
+
+    def get_default_version(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        # TODO: Replace SHOW with DESC when available.
+        default_version: str = (
+            self._session.sql(f"SHOW VERSIONS IN MODEL {self.fully_qualified_model_name(model_name)}")
+            .filter('"is_default_version" = TRUE')[['"name"']]
+            .collect(statement_params=statement_params)[0][0]
+        )
+        return default_version
+
+    def get_file(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        file_path: pathlib.PurePosixPath,
+        target_path: pathlib.Path,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> pathlib.Path:
+        stage_location = pathlib.PurePosixPath(
+            self.fully_qualified_model_name(model_name), "versions", version_name.resolved(), file_path
+        ).as_posix()
+        stage_location_url = ParseResult(
+            scheme="snow", netloc="model", path=stage_location, params="", query="", fragment=""
+        ).geturl()
+        local_location = target_path.absolute().as_posix()
+        local_location_url = ParseResult(
+            scheme="file", netloc="", path=local_location, params="", query="", fragment=""
+        ).geturl()
+
+        self._session.sql(
+            f"GET {_normalize_url_for_sql(stage_location_url)} {_normalize_url_for_sql(local_location_url)}"
+        ).collect(statement_params=statement_params)
+        return target_path / file_path.name
+
+    def set_comment(
+        self,
+        *,
+        comment: str,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        comment_sql = (
+            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} "
+            f"MODIFY VERSION {version_name.identifier()} SET COMMENT=$${comment}$$"
+        )
+        self._session.sql(comment_sql).collect(statement_params=statement_params)
+
+    def invoke_method(
+        self,
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        method_name: sql_identifier.SqlIdentifier,
+        input_df: dataframe.DataFrame,
+        input_args: List[sql_identifier.SqlIdentifier],
+        returns: List[Tuple[str, spt.DataType, sql_identifier.SqlIdentifier]],
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> dataframe.DataFrame:
+        tmp_table_name = snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.TABLE)
+        INTERMEDIATE_TABLE_NAME = identifier.get_schema_level_object_identifier(
+            self._database_name.identifier(),
+            self._schema_name.identifier(),
+            tmp_table_name,
+        )
+        input_df.write.save_as_table(  # type: ignore[call-overload]
+            table_name=INTERMEDIATE_TABLE_NAME,
+            mode="errorifexists",
+            table_type="temporary",
+            statement_params=statement_params,
+        )
+
+        INTERMEDIATE_OBJ_NAME = "TMP_RESULT"
+
+        module_version_alias = "MODEL_VERSION_ALIAS"
+        model_version_alias_sql = (
+            f"WITH {module_version_alias} AS "
+            f"MODEL {self.fully_qualified_model_name(model_name)} VERSION {version_name.identifier()}"
+        )
+
+        args_sql_list = []
+        for input_arg_value in input_args:
+            args_sql_list.append(input_arg_value)
+
+        args_sql = ", ".join(args_sql_list)
+
+        sql = textwrap.dedent(
+            f"""{model_version_alias_sql}
+                SELECT *,
+                    {module_version_alias}!{method_name.identifier()}({args_sql}) AS {INTERMEDIATE_OBJ_NAME}
+                FROM {INTERMEDIATE_TABLE_NAME}"""
+        )
+
+        output_df = self._session.sql(sql)
+
+        # Prepare the output
+        output_cols = []
+        output_names = []
+
+        for output_name, output_type, output_col_name in returns:
+            output_cols.append(F.col(INTERMEDIATE_OBJ_NAME)[output_name].astype(output_type))
+            output_names.append(output_col_name)
+
+        output_df = output_df.with_columns(
+            col_names=output_names,
+            values=output_cols,
+        ).drop(INTERMEDIATE_OBJ_NAME)
+
+        if statement_params:
+            output_df._statement_params = statement_params  # type: ignore[assignment]
+
+        return output_df
+
+    def set_metadata(
+        self,
+        metadata_dict: Dict[str, Any],
+        *,
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        json_metadata = json.dumps(metadata_dict)
+        sql = (
+            f"ALTER MODEL {self.fully_qualified_model_name(model_name)} MODIFY VERSION {version_name.identifier()}"
+            f" SET METADATA=$${json_metadata}$$"
+        )
+        self._session.sql(sql).collect(statement_params=statement_params)

snowflake/ml/model/_client/sql/stage.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict, Optional
+
+from snowflake.ml._internal.utils import identifier, sql_identifier
+from snowflake.snowpark import session
+
+
+class StageSQLClient:
+    def __init__(
+        self,
+        session: session.Session,
+        *,
+        database_name: sql_identifier.SqlIdentifier,
+        schema_name: sql_identifier.SqlIdentifier,
+    ) -> None:
+        self._session = session
+        self._database_name = database_name
+        self._schema_name = schema_name
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, StageSQLClient):
+            return False
+        return self._database_name == __value._database_name and self._schema_name == __value._schema_name
+
+    def fully_qualified_stage_name(
+        self,
+        stage_name: sql_identifier.SqlIdentifier,
+    ) -> str:
+        return identifier.get_schema_level_object_identifier(
+            self._database_name.identifier(), self._schema_name.identifier(), stage_name.identifier()
+        )
+
+    def create_tmp_stage(
+        self,
+        *,
+        stage_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._session.sql(f"CREATE TEMPORARY STAGE {self.fully_qualified_stage_name(stage_name)}").collect(
+            statement_params=statement_params
+        )

snowflake/ml/model/_deploy_client/image_builds/server_image_builder.py

@@ -4,7 +4,6 @@ import posixpath
 from string import Template
 
 import importlib_resources
-import yaml
 
 from snowflake import snowpark
 from snowflake.ml._internal import file_utils
@@ -180,7 +179,7 @@ class ServerImageBuilder(base_image_builder.ImageBuilder):
             assert self.artifact_stage_location.startswith("@")
             normed_artifact_stage_path = posixpath.normpath(identifier.remove_prefix(self.artifact_stage_location, "@"))
             (db, schema, stage, path) = identifier.parse_schema_level_object_identifier(normed_artifact_stage_path)
-            content = Template(spec_template).substitute(
+            content = Template(spec_template).safe_substitute(
                 {
                     "base_image": base_image,
                     "container_name": constants.KANIKO_CONTAINER_NAME,
@@ -188,10 +187,10 @@ class ServerImageBuilder(base_image_builder.ImageBuilder):
                     # Remove @ in the beginning, append "/" to denote root directory.
                     "script_path": "/"
                     + posixpath.normpath(identifier.remove_prefix(kaniko_shell_script_stage_location, "@")),
+                    "mounted_token_path": constants.SPCS_MOUNTED_TOKEN_PATH,
                 }
             )
-            content_dict = yaml.safe_load(content)
-            yaml.dump(content_dict, spec_file)
+            spec_file.write(content)
             spec_file.seek(0)
             logger.debug(f"Kaniko job spec file: \n\n {spec_file.read()}")