unstructured-ingest 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

unstructured_ingest/v2/processes/connectors/pinecone.py

@@ -1,6 +1,5 @@
 import json
 from dataclasses import dataclass, field
-from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional
 
 from pydantic import Field, Secret
@@ -159,33 +158,6 @@ class PineconeUploadStager(UploadStager):
             "metadata": metadata,
         }
 
-    def run(
-        self,
-        file_data: FileData,
-        elements_filepath: Path,
-        output_dir: Path,
-        output_filename: str,
-        **kwargs: Any,
-    ) -> Path:
-        with open(elements_filepath) as elements_file:
-            elements_contents = json.load(elements_file)
-
-        conformed_elements = [
-            self.conform_dict(element_dict=element, file_data=file_data)
-            for element in elements_contents
-        ]
-
-        if Path(output_filename).suffix != ".json":
-            output_filename = f"{output_filename}.json"
-        else:
-            output_filename = f"{Path(output_filename).stem}.json"
-        output_path = Path(output_dir) / Path(f"{output_filename}")
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(output_path, "w") as output_file:
-            json.dump(conformed_elements, output_file)
-        return output_path
-
 
 @dataclass
 class PineconeUploader(Uploader):
@@ -278,11 +250,9 @@ class PineconeUploader(Uploader):
                 raise DestinationConnectionError(f"http error: {api_error}") from api_error
             logger.debug(f"results: {results}")
 
-    def run(self, path: Path, file_data: FileData, **kwargs: Any) -> None:
-        with path.open("r") as file:
-            elements_dict = json.load(file)
+    def run_data(self, data: list[dict], file_data: FileData, **kwargs: Any) -> None:
         logger.info(
-            f"writing a total of {len(elements_dict)} elements via"
+            f"writing a total of {len(data)} elements via"
             f" document batches to destination"
             f" index named {self.connection_config.index_name}"
         )
@@ -295,7 +265,7 @@ class PineconeUploader(Uploader):
             self.pod_delete_by_record_id(file_data=file_data)
         else:
             raise ValueError(f"unexpected spec type in index description: {index_description}")
-        self.upsert_batches_async(elements_dict=elements_dict)
+        self.upsert_batches_async(elements_dict=data)
 
 
 pinecone_destination_entry = DestinationRegistryEntry(

unstructured_ingest/v2/processes/connectors/qdrant/qdrant.py

@@ -1,10 +1,9 @@
 import asyncio
 import json
 from abc import ABC, abstractmethod
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, AsyncGenerator, Optional
+from typing import TYPE_CHECKING, Any, AsyncGenerator, Generator, Optional
 
 from pydantic import Field, Secret
 
@@ -24,7 +23,7 @@ from unstructured_ingest.v2.logger import logger
 from unstructured_ingest.v2.utils import get_enhanced_element_id
 
 if TYPE_CHECKING:
-    from qdrant_client import AsyncQdrantClient
+    from qdrant_client import AsyncQdrantClient, QdrantClient
 
 
 class QdrantAccessConfig(AccessConfig, ABC):
@@ -42,8 +41,8 @@ class QdrantConnectionConfig(ConnectionConfig, ABC):
 
     @requires_dependencies(["qdrant_client"], extras="qdrant")
     @asynccontextmanager
-    async def get_client(self) -> AsyncGenerator["AsyncQdrantClient", None]:
-        from qdrant_client.async_qdrant_client import AsyncQdrantClient
+    async def get_async_client(self) -> AsyncGenerator["AsyncQdrantClient", None]:
+        from qdrant_client import AsyncQdrantClient
 
         client_kwargs = self.get_client_kwargs()
         client = AsyncQdrantClient(**client_kwargs)
@@ -52,6 +51,18 @@ class QdrantConnectionConfig(ConnectionConfig, ABC):
         finally:
             await client.close()
 
+    @requires_dependencies(["qdrant_client"], extras="qdrant")
+    @contextmanager
+    def get_client(self) -> Generator["QdrantClient", None, None]:
+        from qdrant_client import QdrantClient
+
+        client_kwargs = self.get_client_kwargs()
+        client = QdrantClient(**client_kwargs)
+        try:
+            yield client
+        finally:
+            client.close()
+
 
 class QdrantUploadStagerConfig(UploadStagerConfig):
     pass
@@ -63,9 +74,9 @@ class QdrantUploadStager(UploadStager, ABC):
         default_factory=lambda: QdrantUploadStagerConfig()
     )
 
-    @staticmethod
-    def conform_dict(data: dict, file_data: FileData) -> dict:
+    def conform_dict(self, element_dict: dict, file_data: FileData) -> dict:
         """Prepares dictionary in the format that Chroma requires"""
+        data = element_dict.copy()
         return {
             "id": get_enhanced_element_id(element_dict=data, file_data=file_data),
             "vector": data.pop("embeddings", {}),
@@ -80,26 +91,6 @@ class QdrantUploadStager(UploadStager, ABC):
             },
         }
 
-    def run(
-        self,
-        elements_filepath: Path,
-        file_data: FileData,
-        output_dir: Path,
-        output_filename: str,
-        **kwargs: Any,
-    ) -> Path:
-        with open(elements_filepath) as elements_file:
-            elements_contents = json.load(elements_file)
-
-        conformed_elements = [
-            self.conform_dict(data=element, file_data=file_data) for element in elements_contents
-        ]
-        output_path = Path(output_dir) / Path(f"{output_filename}.json")
-
-        with open(output_path, "w") as output_file:
-            json.dump(conformed_elements, output_file)
-        return output_path
-
 
 class QdrantUploaderConfig(UploaderConfig):
     collection_name: str = Field(description="Name of the collection.")
@@ -118,27 +109,27 @@ class QdrantUploader(Uploader, ABC):
 
     @DestinationConnectionError.wrap
     def precheck(self) -> None:
-        async def check_connection():
-            async with self.connection_config.get_client() as async_client:
-                await async_client.get_collections()
-
-        asyncio.run(check_connection())
+        with self.connection_config.get_client() as client:
+            collections_response = client.get_collections()
+            collection_names = [c.name for c in collections_response.collections]
+            if self.upload_config.collection_name not in collection_names:
+                raise DestinationConnectionError(
+                    "collection '{}' not found: {}".format(
+                        self.upload_config.collection_name, ", ".join(collection_names)
+                    )
+                )
 
     def is_async(self):
         return True
 
-    async def run_async(
+    async def run_data_async(
         self,
-        path: Path,
+        data: list[dict],
         file_data: FileData,
         **kwargs: Any,
     ) -> None:
-        with path.open("r") as file:
-            elements: list[dict] = json.load(file)
-
-        logger.debug("Loaded %i elements from %s", len(elements), path)
 
-        batches = list(batch_generator(elements, batch_size=self.upload_config.batch_size))
+        batches = list(batch_generator(data, batch_size=self.upload_config.batch_size))
         logger.debug(
             "Elements split into %i batches of size %i.",
             len(batches),
@@ -156,7 +147,7 @@ class QdrantUploader(Uploader, ABC):
                 len(points),
                 self.upload_config.collection_name,
             )
-            async with self.connection_config.get_client() as async_client:
+            async with self.connection_config.get_async_client() as async_client:
                 await async_client.upsert(
                     self.upload_config.collection_name, points=points, wait=True
                 )

unstructured_ingest/v2/processes/connectors/sql/postgres.py

@@ -5,7 +5,6 @@ from typing import TYPE_CHECKING, Generator, Optional
 from pydantic import Field, Secret
 
 from unstructured_ingest.utils.dep_check import requires_dependencies
-from unstructured_ingest.v2.interfaces import FileData
 from unstructured_ingest.v2.logger import logger
 from unstructured_ingest.v2.processes.connector_registry import (
     DestinationRegistryEntry,
@@ -13,6 +12,7 @@ from unstructured_ingest.v2.processes.connector_registry import (
 )
 from unstructured_ingest.v2.processes.connectors.sql.sql import (
     SQLAccessConfig,
+    SqlBatchFileData,
     SQLConnectionConfig,
     SQLDownloader,
     SQLDownloaderConfig,
@@ -99,12 +99,12 @@ class PostgresDownloader(SQLDownloader):
     connector_type: str = CONNECTOR_TYPE
 
     @requires_dependencies(["psycopg2"], extras="postgres")
-    def query_db(self, file_data: FileData) -> tuple[list[tuple], list[str]]:
+    def query_db(self, file_data: SqlBatchFileData) -> tuple[list[tuple], list[str]]:
         from psycopg2 import sql
 
-        table_name = file_data.additional_metadata["table_name"]
-        id_column = file_data.additional_metadata["id_column"]
-        ids = tuple(file_data.additional_metadata["ids"])
+        table_name = file_data.additional_metadata.table_name
+        id_column = file_data.additional_metadata.id_column
+        ids = tuple([item.identifier for item in file_data.batch_items])
 
         with self.connection_config.get_cursor() as cursor:
             fields = (

unstructured_ingest/v2/processes/connectors/sql/singlestore.py

@@ -5,7 +5,6 @@ from typing import TYPE_CHECKING, Any, Generator, Optional
 
 from pydantic import Field, Secret
 
-from unstructured_ingest.v2.interfaces import FileData
 from unstructured_ingest.v2.logger import logger
 from unstructured_ingest.v2.processes.connector_registry import (
     DestinationRegistryEntry,
@@ -14,6 +13,7 @@ from unstructured_ingest.v2.processes.connector_registry import (
 from unstructured_ingest.v2.processes.connectors.sql.sql import (
     _DATE_COLUMNS,
     SQLAccessConfig,
+    SqlBatchFileData,
     SQLConnectionConfig,
     SQLDownloader,
     SQLDownloaderConfig,
@@ -93,10 +93,10 @@ class SingleStoreDownloader(SQLDownloader):
     connector_type: str = CONNECTOR_TYPE
     values_delimiter: str = "%s"
 
-    def query_db(self, file_data: FileData) -> tuple[list[tuple], list[str]]:
-        table_name = file_data.additional_metadata["table_name"]
-        id_column = file_data.additional_metadata["id_column"]
-        ids = tuple(file_data.additional_metadata["ids"])
+    def query_db(self, file_data: SqlBatchFileData) -> tuple[list[tuple], list[str]]:
+        table_name = file_data.additional_metadata.table_name
+        id_column = file_data.additional_metadata.id_column
+        ids = tuple([item.identifier for item in file_data.batch_items])
         with self.connection_config.get_connection() as sqlite_connection:
             cursor = sqlite_connection.cursor()
             fields = ",".join(self.download_config.fields) if self.download_config.fields else "*"

unstructured_ingest/v2/processes/connectors/sql/snowflake.py

@@ -9,7 +9,6 @@ from pydantic import Field, Secret
 
 from unstructured_ingest.utils.data_prep import split_dataframe
 from unstructured_ingest.utils.dep_check import requires_dependencies
-from unstructured_ingest.v2.interfaces.file_data import FileData
 from unstructured_ingest.v2.logger import logger
 from unstructured_ingest.v2.processes.connector_registry import (
     DestinationRegistryEntry,
@@ -17,6 +16,7 @@ from unstructured_ingest.v2.processes.connector_registry import (
 )
 from unstructured_ingest.v2.processes.connectors.sql.sql import (
     SQLAccessConfig,
+    SqlBatchFileData,
     SQLConnectionConfig,
     SQLDownloader,
     SQLDownloaderConfig,
@@ -118,10 +118,10 @@ class SnowflakeDownloader(SQLDownloader):
 
     # The actual snowflake module package name is: snowflake-connector-python
     @requires_dependencies(["snowflake"], extras="snowflake")
-    def query_db(self, file_data: FileData) -> tuple[list[tuple], list[str]]:
-        table_name = file_data.additional_metadata["table_name"]
-        id_column = file_data.additional_metadata["id_column"]
-        ids = file_data.additional_metadata["ids"]
+    def query_db(self, file_data: SqlBatchFileData) -> tuple[list[tuple], list[str]]:
+        table_name = file_data.additional_metadata.table_name
+        id_column = file_data.additional_metadata.id_column
+        ids = [item.identifier for item in file_data.batch_items]
 
         with self.connection_config.get_cursor() as cursor:
             query = "SELECT {fields} FROM {table_name} WHERE {id_column} IN ({values})".format(

unstructured_ingest/v2/processes/connectors/sql/sql.py

@@ -1,9 +1,8 @@
 import hashlib
 import json
-import sys
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field
 from datetime import date, datetime
 from pathlib import Path
 from time import time
@@ -12,13 +11,15 @@ from typing import Any, Generator, Union
 import numpy as np
 import pandas as pd
 from dateutil import parser
-from pydantic import Field, Secret
+from pydantic import BaseModel, Field, Secret
 
 from unstructured_ingest.error import DestinationConnectionError, SourceConnectionError
-from unstructured_ingest.utils.data_prep import split_dataframe
+from unstructured_ingest.utils.data_prep import get_data_df, split_dataframe
 from unstructured_ingest.v2.constants import RECORD_ID_LABEL
 from unstructured_ingest.v2.interfaces import (
     AccessConfig,
+    BatchFileData,
+    BatchItem,
     ConnectionConfig,
     Downloader,
     DownloaderConfig,
@@ -81,6 +82,15 @@ _COLUMNS = (
 _DATE_COLUMNS = ("date_created", "date_modified", "date_processed", "last_modified")
 
 
+class SqlAdditionalMetadata(BaseModel):
+    table_name: str
+    id_column: str
+
+
+class SqlBatchFileData(BatchFileData):
+    additional_metadata: SqlAdditionalMetadata
+
+
 def parse_date_string(date_value: Union[str, int]) -> date:
     try:
         timestamp = float(date_value) / 1000 if isinstance(date_value, int) else float(date_value)
@@ -124,7 +134,7 @@ class SQLIndexer(Indexer, ABC):
                 f"SELECT {self.index_config.id_column} FROM {self.index_config.table_name}"
             )
             results = cursor.fetchall()
-            ids = [result[0] for result in results]
+            ids = sorted([result[0] for result in results])
             return ids
 
     def precheck(self) -> None:
@@ -135,7 +145,7 @@ class SQLIndexer(Indexer, ABC):
             logger.error(f"failed to validate connection: {e}", exc_info=True)
             raise SourceConnectionError(f"failed to validate connection: {e}")
 
-    def run(self, **kwargs: Any) -> Generator[FileData, None, None]:
+    def run(self, **kwargs: Any) -> Generator[SqlBatchFileData, None, None]:
         ids = self._get_doc_ids()
         id_batches: list[frozenset[str]] = [
             frozenset(
@@ -151,19 +161,15 @@ class SQLIndexer(Indexer, ABC):
         ]
         for batch in id_batches:
             # Make sure the hash is always a positive number to create identified
-            identified = str(hash(batch) + sys.maxsize + 1)
-            yield FileData(
-                identifier=identified,
+            yield SqlBatchFileData(
                 connector_type=self.connector_type,
                 metadata=FileDataSourceMetadata(
                     date_processed=str(time()),
                 ),
-                doc_type="batch",
-                additional_metadata={
-                    "ids": list(batch),
-                    "table_name": self.index_config.table_name,
-                    "id_column": self.index_config.id_column,
-                },
+                additional_metadata=SqlAdditionalMetadata(
+                    table_name=self.index_config.table_name, id_column=self.index_config.id_column
+                ),
+                batch_items=[BatchItem(identifier=str(b)) for b in batch],
             )
 
 
@@ -176,7 +182,7 @@ class SQLDownloader(Downloader, ABC):
     download_config: SQLDownloaderConfig
 
     @abstractmethod
-    def query_db(self, file_data: FileData) -> tuple[list[tuple], list[str]]:
+    def query_db(self, file_data: SqlBatchFileData) -> tuple[list[tuple], list[str]]:
         pass
 
     def sql_to_df(self, rows: list[tuple], columns: list[str]) -> list[pd.DataFrame]:
@@ -185,7 +191,7 @@ class SQLDownloader(Downloader, ABC):
         dfs = [pd.DataFrame([row.values], columns=df.columns) for index, row in df.iterrows()]
         return dfs
 
-    def get_data(self, file_data: FileData) -> list[pd.DataFrame]:
+    def get_data(self, file_data: SqlBatchFileData) -> list[pd.DataFrame]:
         rows, columns = self.query_db(file_data=file_data)
         return self.sql_to_df(rows=rows, columns=columns)
 
@@ -199,10 +205,10 @@ class SQLDownloader(Downloader, ABC):
         return f
 
     def generate_download_response(
-        self, result: pd.DataFrame, file_data: FileData
+        self, result: pd.DataFrame, file_data: SqlBatchFileData
     ) -> DownloadResponse:
-        id_column = file_data.additional_metadata["id_column"]
-        table_name = file_data.additional_metadata["table_name"]
+        id_column = file_data.additional_metadata.id_column
+        table_name = file_data.additional_metadata.table_name
         record_id = result.iloc[0][id_column]
         filename_id = self.get_identifier(table_name=table_name, record_id=record_id)
         filename = f"{filename_id}.csv"
@@ -212,20 +218,19 @@ class SQLDownloader(Downloader, ABC):
         )
         download_path.parent.mkdir(parents=True, exist_ok=True)
         result.to_csv(download_path, index=False)
-        copied_file_data = replace(file_data)
-        copied_file_data.identifier = filename_id
-        copied_file_data.doc_type = "file"
-        copied_file_data.additional_metadata.pop("ids", None)
+        cast_file_data = FileData.cast(file_data=file_data)
+        cast_file_data.identifier = filename_id
         return super().generate_download_response(
-            file_data=copied_file_data, download_path=download_path
+            file_data=cast_file_data, download_path=download_path
         )
 
     def run(self, file_data: FileData, **kwargs: Any) -> download_responses:
-        data_dfs = self.get_data(file_data=file_data)
+        sql_filedata = SqlBatchFileData.cast(file_data=file_data)
+        data_dfs = self.get_data(file_data=sql_filedata)
         download_responses = []
         for df in data_dfs:
             download_responses.append(
-                self.generate_download_response(result=df, file_data=file_data)
+                self.generate_download_response(result=df, file_data=sql_filedata)
             )
         return download_responses
 
@@ -238,27 +243,24 @@ class SQLUploadStagerConfig(UploadStagerConfig):
 class SQLUploadStager(UploadStager):
     upload_stager_config: SQLUploadStagerConfig = field(default_factory=SQLUploadStagerConfig)
 
-    @staticmethod
-    def conform_dict(data: dict, file_data: FileData) -> pd.DataFrame:
-        working_data = data.copy()
-        output = []
-        for element in working_data:
-            metadata: dict[str, Any] = element.pop("metadata", {})
-            data_source = metadata.pop("data_source", {})
-            coordinates = metadata.pop("coordinates", {})
+    def conform_dict(self, element_dict: dict, file_data: FileData) -> dict:
+        data = element_dict.copy()
+        metadata: dict[str, Any] = data.pop("metadata", {})
+        data_source = metadata.pop("data_source", {})
+        coordinates = metadata.pop("coordinates", {})
 
-            element.update(metadata)
-            element.update(data_source)
-            element.update(coordinates)
+        data.update(metadata)
+        data.update(data_source)
+        data.update(coordinates)
 
-            element["id"] = get_enhanced_element_id(element_dict=element, file_data=file_data)
+        data["id"] = get_enhanced_element_id(element_dict=data, file_data=file_data)
 
-            # remove extraneous, not supported columns
-            element = {k: v for k, v in element.items() if k in _COLUMNS}
-            element[RECORD_ID_LABEL] = file_data.identifier
-            output.append(element)
+        # remove extraneous, not supported columns
+        element = {k: v for k, v in data.items() if k in _COLUMNS}
+        element[RECORD_ID_LABEL] = file_data.identifier
+        return element
 
-        df = pd.DataFrame.from_dict(output)
+    def conform_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
         for column in filter(lambda x: x in df.columns, _DATE_COLUMNS):
             df[column] = df[column].apply(parse_date_string)
         for column in filter(
@@ -283,19 +285,19 @@ class SQLUploadStager(UploadStager):
         output_filename: str,
         **kwargs: Any,
     ) -> Path:
-        with open(elements_filepath) as elements_file:
-            elements_contents: list[dict] = json.load(elements_file)
+        elements_contents = self.get_data(elements_filepath=elements_filepath)
 
-        df = self.conform_dict(data=elements_contents, file_data=file_data)
-        if Path(output_filename).suffix != ".json":
-            output_filename = f"{output_filename}.json"
-        else:
-            output_filename = f"{Path(output_filename).stem}.json"
-        output_path = Path(output_dir) / Path(f"{output_filename}")
-        output_path.parent.mkdir(parents=True, exist_ok=True)
+        df = pd.DataFrame(
+            data=[
+                self.conform_dict(element_dict=element_dict, file_data=file_data)
+                for element_dict in elements_contents
+            ]
+        )
+        df = self.conform_dataframe(df=df)
 
-        with output_path.open("w") as output_file:
-            df.to_json(output_file, orient="records", lines=True)
+        output_path = self.get_output_path(output_filename=output_filename, output_dir=output_dir)
+
+        self.write_output(output_path=output_path, data=df.to_dict(orient="records"))
         return output_path
 
 
@@ -361,8 +363,15 @@ class SQLUploader(Uploader):
         for column in missing_columns:
             df[column] = pd.Series()
 
-    def upload_contents(self, path: Path) -> None:
-        df = pd.read_json(path, orient="records", lines=True)
+    def upload_dataframe(self, df: pd.DataFrame, file_data: FileData) -> None:
+        if self.can_delete():
+            self.delete_by_record_id(file_data=file_data)
+        else:
+            logger.warning(
+                f"table doesn't contain expected "
+                f"record id column "
+                f"{self.upload_config.record_id_key}, skipping delete"
+            )
         df.replace({np.nan: None}, inplace=True)
         self._fit_to_schema(df=df, columns=self.get_table_columns())
 
@@ -411,13 +420,10 @@ class SQLUploader(Uploader):
             rowcount = cursor.rowcount
             logger.info(f"deleted {rowcount} rows from table {self.upload_config.table_name}")
 
+    def run_data(self, data: list[dict], file_data: FileData, **kwargs: Any) -> None:
+        df = pd.DataFrame(data)
+        self.upload_dataframe(df=df, file_data=file_data)
+
     def run(self, path: Path, file_data: FileData, **kwargs: Any) -> None:
-        if self.can_delete():
-            self.delete_by_record_id(file_data=file_data)
-        else:
-            logger.warning(
-                f"table doesn't contain expected "
-                f"record id column "
-                f"{self.upload_config.record_id_key}, skipping delete"
-            )
-        self.upload_contents(path=path)
+        df = get_data_df(path=path)
+        self.upload_dataframe(df=df, file_data=file_data)

unstructured_ingest/v2/processes/connectors/sql/sqlite.py

@@ -6,7 +6,6 @@ from typing import TYPE_CHECKING, Any, Generator
 
 from pydantic import Field, Secret, model_validator
 
-from unstructured_ingest.v2.interfaces import FileData
 from unstructured_ingest.v2.logger import logger
 from unstructured_ingest.v2.processes.connector_registry import (
     DestinationRegistryEntry,
@@ -15,6 +14,7 @@ from unstructured_ingest.v2.processes.connector_registry import (
 from unstructured_ingest.v2.processes.connectors.sql.sql import (
     _DATE_COLUMNS,
     SQLAccessConfig,
+    SqlBatchFileData,
     SQLConnectionConfig,
     SQLDownloader,
     SQLDownloaderConfig,
@@ -97,10 +97,10 @@ class SQLiteDownloader(SQLDownloader):
     connector_type: str = CONNECTOR_TYPE
     values_delimiter: str = "?"
 
-    def query_db(self, file_data: FileData) -> tuple[list[tuple], list[str]]:
-        table_name = file_data.additional_metadata["table_name"]
-        id_column = file_data.additional_metadata["id_column"]
-        ids = file_data.additional_metadata["ids"]
+    def query_db(self, file_data: SqlBatchFileData) -> tuple[list[tuple], list[str]]:
+        table_name = file_data.additional_metadata.table_name
+        id_column = file_data.additional_metadata.id_column
+        ids = [item.identifier for item in file_data.batch_items]
         with self.connection_config.get_connection() as sqlite_connection:
             cursor = sqlite_connection.cursor()
             fields = ",".join(self.download_config.fields) if self.download_config.fields else "*"