lfx-nightly 0.2.0.dev26__py3-none-any.whl → 0.2.1.dev7__py3-none-any.whl

lfx/components/files_and_knowledge/retrieval.py

@@ -15,9 +15,13 @@ from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 from lfx.services.deps import get_settings_service, session_scope
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
 
 _KNOWLEDGE_BASES_ROOT_PATH: Path | None = None
 
+# Error message to raise if we're in Astra cloud environment and the component is not supported.
+astra_error_msg = "Knowledge retrieval is not supported in Astra cloud environment."
+
 
 def _get_knowledge_bases_root_path() -> Path:
     """Lazy load the knowledge bases root path from settings."""
@@ -95,6 +99,8 @@ class KnowledgeRetrievalComponent(Component):
     ]
 
     async def update_build_config(self, build_config, field_value, field_name=None):  # noqa: ARG002
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(astra_error_msg)
         if field_name == "knowledge_base":
             # Update the knowledge base options dynamically
             build_config["knowledge_base"]["options"] = await get_knowledge_bases(
@@ -110,6 +116,8 @@ class KnowledgeRetrievalComponent(Component):
 
     def _get_kb_metadata(self, kb_path: Path) -> dict:
         """Load and process knowledge base metadata."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(astra_error_msg)
         metadata: dict[str, Any] = {}
         metadata_file = kb_path / "embedding_metadata.json"
         if not metadata_file.exists():
@@ -184,6 +192,8 @@ class KnowledgeRetrievalComponent(Component):
         Returns:
             A DataFrame containing the data rows from the knowledge base.
         """
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(astra_error_msg)
         # Get the current user
         async with session_scope() as db:
             if not self.user_id:

lfx/components/files_and_knowledge/save_file.py

@@ -1,6 +1,7 @@
 import json
 from collections.abc import AsyncIterator, Iterator
 from pathlib import Path
+from typing import Any
 
 import orjson
 import pandas as pd
@@ -13,6 +14,15 @@ from lfx.io import BoolInput, DropdownInput, HandleInput, SecretStrInput, StrInp
 from lfx.schema import Data, DataFrame, Message
 from lfx.services.deps import get_settings_service, get_storage_service, session_scope
 from lfx.template.field.base import Output
+from lfx.utils.validate_cloud import is_astra_cloud_environment
+
+
+def _get_storage_location_options():
+    """Get storage location options, filtering out Local if in Astra cloud environment."""
+    all_options = [{"name": "AWS", "icon": "Amazon"}, {"name": "Google Drive", "icon": "google"}]
+    if is_astra_cloud_environment():
+        return all_options
+    return [{"name": "Local", "icon": "hard-drive"}, *all_options]
 
 
 class SaveToFileComponent(Component):
@@ -49,11 +59,7 @@ class SaveToFileComponent(Component):
             display_name="Storage Location",
             placeholder="Select Location",
             info="Choose where to save the file.",
-            options=[
-                {"name": "Local", "icon": "hard-drive"},
-                {"name": "AWS", "icon": "Amazon"},
-                {"name": "Google Drive", "icon": "google"},
-            ],
+            options=_get_storage_location_options(),
             real_time_refresh=True,
             limit=1,
         ),
@@ -77,7 +83,10 @@ class SaveToFileComponent(Component):
         BoolInput(
             name="append_mode",
             display_name="Append",
-            info="Append to file if it exists (only for plain text formats). Disabled for binary formats like Excel.",
+            info=(
+                "Append to file if it exists (only for Local storage with plain text formats). "
+                "Not supported for cloud storage (AWS/Google Drive)."
+            ),
             value=False,
             show=False,
         ),
@@ -113,6 +122,7 @@ class SaveToFileComponent(Component):
             info="AWS Access key ID.",
             show=False,
             advanced=True,
+            required=True,
         ),
         SecretStrInput(
             name="aws_secret_access_key",
@@ -120,6 +130,7 @@ class SaveToFileComponent(Component):
             info="AWS Secret Key.",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="bucket_name",
@@ -127,6 +138,7 @@ class SaveToFileComponent(Component):
             info="Enter the name of the S3 bucket.",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="aws_region",
@@ -149,6 +161,7 @@ class SaveToFileComponent(Component):
             info="Your Google Cloud Platform service account JSON key as a secret string (complete JSON content).",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="folder_id",
@@ -157,6 +170,7 @@ class SaveToFileComponent(Component):
                 "The Google Drive folder ID where the file will be uploaded. "
                 "The folder must be shared with the service account email."
             ),
+            required=True,
             show=False,
             advanced=True,
         ),
@@ -166,6 +180,12 @@ class SaveToFileComponent(Component):
 
     def update_build_config(self, build_config, field_value, field_name=None):
         """Update build configuration to show/hide fields based on storage location selection."""
+        # Update options dynamically based on cloud environment
+        # This ensures options are refreshed when build_config is updated
+        if "storage_location" in build_config:
+            updated_options = _get_storage_location_options()
+            build_config["storage_location"]["options"] = updated_options
+
         if field_name != "storage_location":
             return build_config
 
@@ -196,11 +216,13 @@ class SaveToFileComponent(Component):
         if len(selected) == 1:
             location = selected[0]
 
-            # Show file_name and append_mode when any storage location is selected
+            # Show file_name when any storage location is selected
             if "file_name" in build_config:
                 build_config["file_name"]["show"] = True
+
+            # Show append_mode only for Local storage (not supported for cloud storage)
             if "append_mode" in build_config:
-                build_config["append_mode"]["show"] = True
+                build_config["append_mode"]["show"] = location == "Local"
 
             if location == "Local":
                 if "local_format" in build_config:
@@ -218,12 +240,14 @@ class SaveToFileComponent(Component):
                 for f_name in aws_fields:
                     if f_name in build_config:
                         build_config[f_name]["show"] = True
+                        build_config[f_name]["advanced"] = False
 
             elif location == "Google Drive":
                 gdrive_fields = ["gdrive_format", "service_account_key", "folder_id"]
                 for f_name in gdrive_fields:
                     if f_name in build_config:
                         build_config[f_name]["show"] = True
+                        build_config[f_name]["advanced"] = False
 
         return build_config
 
@@ -243,6 +267,11 @@ class SaveToFileComponent(Component):
             msg = "Storage location must be selected."
             raise ValueError(msg)
 
+        # Check if Local storage is disabled in cloud environment
+        if storage_location == "Local" and is_astra_cloud_environment():
+            msg = "Local storage is not available in cloud environment. Please use AWS or Google Drive."
+            raise ValueError(msg)
+
         # Route to appropriate save method based on storage location
         if storage_location == "Local":
             return await self._save_to_local()
@@ -534,32 +563,67 @@ class SaveToFileComponent(Component):
 
     async def _save_to_aws(self) -> Message:
         """Save file to AWS S3 using S3 functionality."""
+        import os
+
+        import boto3
+
+        from lfx.base.data.cloud_storage_utils import create_s3_client, validate_aws_credentials
+
+        # Get AWS credentials from component inputs or fall back to environment variables
+        aws_access_key_id = getattr(self, "aws_access_key_id", None)
+        if aws_access_key_id and hasattr(aws_access_key_id, "get_secret_value"):
+            aws_access_key_id = aws_access_key_id.get_secret_value()
+        if not aws_access_key_id:
+            aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID")
+
+        aws_secret_access_key = getattr(self, "aws_secret_access_key", None)
+        if aws_secret_access_key and hasattr(aws_secret_access_key, "get_secret_value"):
+            aws_secret_access_key = aws_secret_access_key.get_secret_value()
+        if not aws_secret_access_key:
+            aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+
+        bucket_name = getattr(self, "bucket_name", None)
+        if not bucket_name:
+            # Try to get from storage service settings
+            settings = get_settings_service().settings
+            bucket_name = settings.object_storage_bucket_name
+
         # Validate AWS credentials
-        if not getattr(self, "aws_access_key_id", None):
-            msg = "AWS Access Key ID is required for S3 storage"
+        if not aws_access_key_id:
+            msg = (
+                "AWS Access Key ID is required for S3 storage. Provide it as a component input "
+                "or set AWS_ACCESS_KEY_ID environment variable."
+            )
             raise ValueError(msg)
-        if not getattr(self, "aws_secret_access_key", None):
-            msg = "AWS Secret Key is required for S3 storage"
+        if not aws_secret_access_key:
+            msg = (
+                "AWS Secret Key is required for S3 storage. Provide it as a component input "
+                "or set AWS_SECRET_ACCESS_KEY environment variable."
+            )
             raise ValueError(msg)
-        if not getattr(self, "bucket_name", None):
-            msg = "S3 Bucket Name is required for S3 storage"
+        if not bucket_name:
+            msg = (
+                "S3 Bucket Name is required for S3 storage. Provide it as a component input "
+                "or set LANGFLOW_OBJECT_STORAGE_BUCKET_NAME environment variable."
+            )
             raise ValueError(msg)
 
-        # Use S3 upload functionality
-        try:
-            import boto3
-        except ImportError as e:
-            msg = "boto3 is not installed. Please install it using `uv pip install boto3`."
-            raise ImportError(msg) from e
+        # Validate AWS credentials
+        validate_aws_credentials(self)
 
         # Create S3 client
-        client_config = {
-            "aws_access_key_id": self.aws_access_key_id,
-            "aws_secret_access_key": self.aws_secret_access_key,
+        s3_client = create_s3_client(self)
+        client_config: dict[str, Any] = {
+            "aws_access_key_id": str(aws_access_key_id),
+            "aws_secret_access_key": str(aws_secret_access_key),
         }
 
-        if hasattr(self, "aws_region") and self.aws_region:
-            client_config["region_name"] = self.aws_region
+        # Get region from component input, environment variable, or settings
+        aws_region = getattr(self, "aws_region", None)
+        if not aws_region:
+            aws_region = os.getenv("AWS_DEFAULT_REGION") or os.getenv("AWS_REGION")
+        if aws_region:
+            client_config["region_name"] = str(aws_region)
 
         s3_client = boto3.client("s3", **client_config)
 
@@ -575,14 +639,16 @@ class SaveToFileComponent(Component):
         # Create temporary file
         import tempfile
 
-        with tempfile.NamedTemporaryFile(mode="w", suffix=f".{file_format}", delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(
+            mode="w", encoding="utf-8", suffix=f".{file_format}", delete=False
+        ) as temp_file:
             temp_file.write(content)
             temp_file_path = temp_file.name
 
         try:
             # Upload to S3
-            s3_client.upload_file(temp_file_path, self.bucket_name, file_path)
-            s3_url = f"s3://{self.bucket_name}/{file_path}"
+            s3_client.upload_file(temp_file_path, bucket_name, file_path)
+            s3_url = f"s3://{bucket_name}/{file_path}"
             return Message(text=f"File successfully uploaded to {s3_url}")
         finally:
             # Clean up temp file
@@ -591,6 +657,12 @@ class SaveToFileComponent(Component):
 
     async def _save_to_google_drive(self) -> Message:
         """Save file to Google Drive using Google Drive functionality."""
+        import tempfile
+
+        from googleapiclient.http import MediaFileUpload
+
+        from lfx.base.data.cloud_storage_utils import create_google_drive_service
+
         # Validate Google Drive credentials
         if not getattr(self, "service_account_key", None):
             msg = "GCP Credentials Secret Key is required for Google Drive storage"
@@ -599,30 +671,10 @@ class SaveToFileComponent(Component):
             msg = "Google Drive Folder ID is required for Google Drive storage"
             raise ValueError(msg)
 
-        # Use Google Drive upload functionality
-        try:
-            import json
-            import tempfile
-
-            from google.oauth2 import service_account
-            from googleapiclient.discovery import build
-            from googleapiclient.http import MediaFileUpload
-        except ImportError as e:
-            msg = "Google API client libraries are not installed. Please install them."
-            raise ImportError(msg) from e
-
-        # Parse credentials
-        try:
-            credentials_dict = json.loads(self.service_account_key)
-        except json.JSONDecodeError as e:
-            msg = f"Invalid JSON in service account key: {e!s}"
-            raise ValueError(msg) from e
-
-        # Create Google Drive service
-        credentials = service_account.Credentials.from_service_account_info(
-            credentials_dict, scopes=["https://www.googleapis.com/auth/drive.file"]
+        # Create Google Drive service with full drive scope (needed for folder operations)
+        drive_service, credentials = create_google_drive_service(
+            self.service_account_key, scopes=["https://www.googleapis.com/auth/drive"], return_credentials=True
         )
-        drive_service = build("drive", "v3", credentials=credentials)
 
         # Extract content and format
         content = self._extract_content_for_upload()
@@ -634,16 +686,34 @@ class SaveToFileComponent(Component):
 
         # Create temporary file
         file_path = f"{self.file_name}.{file_format}"
-        with tempfile.NamedTemporaryFile(mode="w", suffix=f".{file_format}", delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            suffix=f".{file_format}",
+            delete=False,
+        ) as temp_file:
             temp_file.write(content)
             temp_file_path = temp_file.name
 
         try:
             # Upload to Google Drive
+            # Note: We skip explicit folder verification since it requires broader permissions.
+            # If the folder doesn't exist or isn't accessible, the create() call will fail with a clear error.
             file_metadata = {"name": file_path, "parents": [self.folder_id]}
             media = MediaFileUpload(temp_file_path, resumable=True)
 
-            uploaded_file = drive_service.files().create(body=file_metadata, media_body=media, fields="id").execute()
+            try:
+                uploaded_file = (
+                    drive_service.files().create(body=file_metadata, media_body=media, fields="id").execute()
+                )
+            except Exception as e:
+                msg = (
+                    f"Unable to upload file to Google Drive folder '{self.folder_id}'. "
+                    f"Error: {e!s}. "
+                    "Please ensure: 1) The folder ID is correct, 2) The folder exists, "
+                    "3) The service account has been granted access to this folder."
+                )
+                raise ValueError(msg) from e
 
             file_id = uploaded_file.get("id")
             file_url = f"https://drive.google.com/file/d/{file_id}/view"

lfx/components/ibm/watsonx.py

@@ -197,8 +197,14 @@ class WatsonxAIComponent(LCModelComponent):
             "logit_bias": logit_bias,
         }
 
+        # Pass API key as plain string to avoid SecretStr serialization issues
+        # when model is configured with with_config() or used in batch operations
+        api_key_value = self.api_key
+        if isinstance(api_key_value, SecretStr):
+            api_key_value = api_key_value.get_secret_value()
+
         return ChatWatsonx(
-            apikey=SecretStr(self.api_key).get_secret_value(),
+            apikey=api_key_value,
             url=self.base_url,
             project_id=self.project_id,
             model_id=self.model_name,

lfx/components/input_output/chat_output.py

@@ -121,13 +121,19 @@ class ChatOutput(ChatComponent):
             message = self.input_value
             # Update message properties
             message.text = text
+            # Preserve existing session_id from the incoming message if it exists
+            existing_session_id = message.session_id
         else:
             message = Message(text=text)
+            existing_session_id = None
 
         # Set message properties
         message.sender = self.sender
         message.sender_name = self.sender_name
-        message.session_id = self.session_id or self.graph.session_id or ""
+        # Preserve session_id from incoming message, or use component/graph session_id
+        message.session_id = (
+            self.session_id or existing_session_id or (self.graph.session_id if hasattr(self, "graph") else None) or ""
+        )
         message.context_id = self.context_id
         message.flow_id = self.graph.flow_id if hasattr(self, "graph") else None
         message.properties.source = self._build_source(source_id, display_name, source)

lfx/components/langchain_utilities/tool_calling.py

@@ -44,12 +44,20 @@ class ToolCallingAgentComponent(LCToolsAgentComponent):
         return self.chat_history
 
     def create_agent_runnable(self):
-        messages = [
-            ("system", "{system_prompt}"),
-            ("placeholder", "{chat_history}"),
-            ("human", "{input}"),
-            ("placeholder", "{agent_scratchpad}"),
-        ]
+        messages = []
+
+        # Only include system message if system_prompt is provided and not empty
+        if hasattr(self, "system_prompt") and self.system_prompt and self.system_prompt.strip():
+            messages.append(("system", "{system_prompt}"))
+
+        messages.extend(
+            [
+                ("placeholder", "{chat_history}"),
+                ("human", "{input}"),
+                ("placeholder", "{agent_scratchpad}"),
+            ]
+        )
+
         prompt = ChatPromptTemplate.from_messages(messages)
         self.validate_tool_names()
         try:

lfx/components/llm_operations/batch_run.py

@@ -4,8 +4,13 @@ from typing import TYPE_CHECKING, Any, cast
 
 import toml  # type: ignore[import-untyped]
 
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_model_classes,
+    update_model_options_in_build_config,
+)
 from lfx.custom.custom_component.component import Component
-from lfx.io import BoolInput, DataFrameInput, HandleInput, MessageTextInput, MultilineInput, Output
+from lfx.io import BoolInput, DataFrameInput, MessageTextInput, ModelInput, MultilineInput, Output, SecretStrInput
 from lfx.log.logger import logger
 from lfx.schema.dataframe import DataFrame
 
@@ -20,13 +25,20 @@ class BatchRunComponent(Component):
     icon = "List"
 
     inputs = [
-        HandleInput(
+        ModelInput(
             name="model",
             display_name="Language Model",
-            info="Connect the 'Language Model' output from your LLM component here.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MultilineInput(
             name="system_message",
             display_name="Instructions",
@@ -76,6 +88,17 @@ class BatchRunComponent(Component):
         ),
     ]
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def _format_row_as_toml(self, row: dict[str, Any]) -> str:
         """Convert a dictionary (row) into a TOML-formatted string."""
         formatted_dict = {str(col): {"value": str(val)} for col, val in row.items()}
@@ -111,20 +134,43 @@ class BatchRunComponent(Component):
             }
 
     async def run_batch(self) -> DataFrame:
-        """Process each row in df[column_name] with the language model asynchronously.
-
-        Returns:
-            DataFrame: A new DataFrame containing:
-                - All original columns
-                - The model's response column (customizable name)
-                - 'batch_index' column for processing order
-                - 'metadata' (optional)
-
-        Raises:
-            ValueError: If the specified column is not found in the DataFrame
-            TypeError: If the model is not compatible or input types are wrong
-        """
-        model: Runnable = self.model
+        """Process each row in df[column_name] with the language model asynchronously."""
+        # Check if model is already an instance (for testing) or needs to be instantiated
+        if isinstance(self.model, list):
+            # Extract model configuration
+            model_selection = self.model[0]
+            model_name = model_selection.get("name")
+            provider = model_selection.get("provider")
+            metadata = model_selection.get("metadata", {})
+
+            # Get model class and parameters from metadata
+            model_class = get_model_classes().get(metadata.get("model_class"))
+            if model_class is None:
+                msg = f"No model class defined for {model_name}"
+                raise ValueError(msg)
+
+            api_key_param = metadata.get("api_key_param", "api_key")
+            model_name_param = metadata.get("model_name_param", "model")
+
+            # Get API key from global variables
+            from lfx.base.models.unified_models import get_api_key_for_provider
+
+            api_key = get_api_key_for_provider(self.user_id, provider, self.api_key)
+
+            if not api_key and provider != "Ollama":
+                msg = f"{provider} API key is required. Please configure it globally."
+                raise ValueError(msg)
+
+            # Instantiate the model
+            kwargs = {
+                model_name_param: model_name,
+                api_key_param: api_key,
+            }
+            model: Runnable = model_class(**kwargs)
+        else:
+            # Model is already an instance (typically in tests)
+            model = self.model
+
         system_msg = self.system_message or ""
         df: DataFrame = self.df
         col_name = self.column_name or ""
@@ -159,13 +205,22 @@ class BatchRunComponent(Component):
             ]
 
             # Configure the model with project info and callbacks
-            model = model.with_config(
-                {
-                    "run_name": self.display_name,
-                    "project_name": self.get_project_name(),
-                    "callbacks": self.get_langchain_callbacks(),
-                }
-            )
+            # Some models (e.g., ChatWatsonx) may have serialization issues with with_config()
+            # due to SecretStr or other non-serializable attributes
+            try:
+                model = model.with_config(
+                    {
+                        "run_name": self.display_name,
+                        "project_name": self.get_project_name(),
+                        "callbacks": self.get_langchain_callbacks(),
+                    }
+                )
+            except (TypeError, ValueError, AttributeError) as e:
+                # Log warning and continue without configuration
+                await logger.awarning(
+                    f"Could not configure model with callbacks and project info: {e!s}. "
+                    "Proceeding with batch processing without configuration."
+                )
             # Process batches and track progress
             responses_with_idx = list(
                 zip(

lfx/components/llm_operations/lambda_filter.py

@@ -4,14 +4,23 @@ import json
 import re
 from typing import TYPE_CHECKING, Any
 
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_llm,
+    update_model_options_in_build_config,
+)
 from lfx.custom.custom_component.component import Component
-from lfx.io import DataInput, HandleInput, IntInput, MultilineInput, Output
+from lfx.io import DataInput, IntInput, ModelInput, MultilineInput, Output, SecretStrInput
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+# # Compute model options once at module level
+# _MODEL_OPTIONS = get_language_model_options()
+# _PROVIDERS = [provider["provider"] for provider in _MODEL_OPTIONS]
+
 
 class LambdaFilterComponent(Component):
     display_name = "Smart Transform"
@@ -29,13 +38,20 @@ class LambdaFilterComponent(Component):
             is_list=True,
             required=True,
         ),
-        HandleInput(
-            name="llm",
+        ModelInput(
+            name="model",
             display_name="Language Model",
-            info="Connect the 'Language Model' output from your LLM component here.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MultilineInput(
             name="filter_instruction",
             display_name="Instructions",
@@ -75,6 +91,17 @@ class LambdaFilterComponent(Component):
         ),
     ]
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def get_data_structure(self, data):
         """Extract the structure of data, replacing values with their types."""
         if isinstance(data, list):
@@ -129,7 +156,7 @@ class LambdaFilterComponent(Component):
         dump = json.dumps(data)
         self.log(str(data))
 
-        llm = self.llm
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
         instruction = self.filter_instruction
         sample_size = self.sample_size