nvidia-nat 1.4.0a20251105__py3-none-any.whl → 1.4.0a20251107__py3-none-any.whl

nat/eval/dataset_handler/dataset_filter.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import fnmatch
+
 import pandas as pd
 
 from nat.data_models.dataset_handler import EvalFilterConfig
@@ -24,6 +26,7 @@ class DatasetFilter:
         - If a allowlist is provided, only keep rows matching the filter values.
         - If a denylist is provided, remove rows matching the filter values.
         - If the filter column does not exist in the DataFrame, the filtering is skipped for that column.
+        - Supports Unix shell-style wildcards (``*``, ``?``, ``[seq]``, ``[!seq]``) for string matching.
 
     This is a utility class that is dataset agnostic and can be used to filter any DataFrame based on the provided
     filter configuration.
@@ -33,6 +36,33 @@ class DatasetFilter:
 
         self.filter_config = filter_config
 
+    @staticmethod
+    def _match_wildcard_patterns(series: pd.Series, patterns: list[str | int | float]) -> pd.Series:
+        """
+        Match series values against wildcard patterns and exact values.
+
+        Args:
+            series (pd.Series): pandas Series to match against
+            patterns (list[str | int | float]): List of patterns/values
+
+        Returns:
+            pd.Series: Boolean Series indicating matches
+        """
+        # Convert series to string for pattern matching
+        str_series = series.astype(str)
+
+        # Initialize boolean mask
+        matches = pd.Series([False] * len(series), index=series.index)
+
+        # Check each pattern using fnmatch with list comprehension to avoid lambda capture
+        for pattern in patterns:
+            pattern_str = str(pattern)
+            pattern_matches = pd.Series([fnmatch.fnmatch(val, pattern_str) for val in str_series],
+                                        index=str_series.index)
+            matches |= pattern_matches
+
+        return matches
+
     def apply_filters(self, df) -> pd.DataFrame:
 
         filtered_df = df.copy()
@@ -41,12 +71,14 @@ class DatasetFilter:
         if self.filter_config.allowlist:
             for column, values in self.filter_config.allowlist.field.items():
                 if column in filtered_df.columns:
-                    filtered_df = filtered_df[filtered_df[column].isin(values)]
+                    matches = self._match_wildcard_patterns(filtered_df[column], values)
+                    filtered_df = filtered_df[matches]
 
         # Apply denylist (remove specified rows)
         if self.filter_config.denylist:
             for column, values in self.filter_config.denylist.field.items():
                 if column in filtered_df.columns:
-                    filtered_df = filtered_df[~filtered_df[column].isin(values)]
+                    matches = self._match_wildcard_patterns(filtered_df[column], values)
+                    filtered_df = filtered_df[~matches]
 
         return filtered_df

nat/llm/aws_bedrock_llm.py

@@ -25,18 +25,10 @@ from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
 from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
-class AWSBedrockModelConfig(LLMBaseConfig,
-                            RetryMixin,
-                            OptimizableMixin,
-                            TemperatureMixin,
-                            TopPMixin,
-                            ThinkingMixin,
-                            name="aws_bedrock"):
+class AWSBedrockModelConfig(LLMBaseConfig, RetryMixin, OptimizableMixin, ThinkingMixin, name="aws_bedrock"):
     """An AWS Bedrock llm provider to be used with an LLM client."""
 
     model_config = ConfigDict(protected_namespaces=(), extra="allow")
@@ -61,6 +53,16 @@ class AWSBedrockModelConfig(LLMBaseConfig,
         default=None, description="Bedrock endpoint to use. Needed if you don't want to default to us-east-1 endpoint.")
     credentials_profile_name: str | None = Field(
         default=None, description="The name of the profile in the ~/.aws/credentials or ~/.aws/config files.")
+    temperature: float | None = OptimizableField(default=None,
+                                                 ge=0.0,
+                                                 le=1.0,
+                                                 description="Sampling temperature in [0, 1].",
+                                                 space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=AWSBedrockModelConfig)

nat/llm/azure_openai_llm.py

@@ -22,17 +22,15 @@ from nat.builder.llm import LLMProviderInfo
 from nat.cli.register_workflow import register_llm_provider
 from nat.data_models.common import OptionalSecretStr
 from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.optimizable import OptimizableField
+from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
 class AzureOpenAIModelConfig(
         LLMBaseConfig,
         RetryMixin,
-        TemperatureMixin,
-        TopPMixin,
         ThinkingMixin,
         name="azure_openai",
 ):
@@ -50,6 +48,16 @@ class AzureOpenAIModelConfig(
                                   serialization_alias="azure_deployment",
                                   description="The Azure OpenAI hosted model/deployment name.")
     seed: int | None = Field(default=None, description="Random seed to set for generation.")
+    temperature: float | None = OptimizableField(default=None,
+                                                 ge=0.0,
+                                                 le=1.0,
+                                                 description="Sampling temperature in [0, 1].",
+                                                 space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=AzureOpenAIModelConfig)

nat/llm/litellm_llm.py

@@ -26,18 +26,15 @@ from nat.data_models.common import OptionalSecretStr
 from nat.data_models.llm import LLMBaseConfig
 from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
+from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
 class LiteLlmModelConfig(
         LLMBaseConfig,
         OptimizableMixin,
         RetryMixin,
-        TemperatureMixin,
-        TopPMixin,
         ThinkingMixin,
         name="litellm",
 ):
@@ -54,6 +51,16 @@ class LiteLlmModelConfig(
                                        serialization_alias="model",
                                        description="The LiteLlm hosted model name.")
     seed: int | None = Field(default=None, description="Random seed to set for generation.")
+    temperature: float | None = OptimizableField(default=None,
+                                                 ge=0.0,
+                                                 le=1.0,
+                                                 description="Sampling temperature in [0, 1].",
+                                                 space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=LiteLlmModelConfig)

nat/llm/nim_llm.py

@@ -27,18 +27,10 @@ from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
 from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
-class NIMModelConfig(LLMBaseConfig,
-                     RetryMixin,
-                     OptimizableMixin,
-                     TemperatureMixin,
-                     TopPMixin,
-                     ThinkingMixin,
-                     name="nim"):
+class NIMModelConfig(LLMBaseConfig, RetryMixin, OptimizableMixin, ThinkingMixin, name="nim"):
     """An NVIDIA Inference Microservice (NIM) llm provider to be used with an LLM client."""
 
     model_config = ConfigDict(protected_namespaces=(), extra="allow")
@@ -51,6 +43,16 @@ class NIMModelConfig(LLMBaseConfig,
     max_tokens: PositiveInt = OptimizableField(default=300,
                                                description="Maximum number of tokens to generate.",
                                                space=SearchSpace(high=2176, low=128, step=512))
+    temperature: float | None = OptimizableField(default=None,
+                                                 ge=0.0,
+                                                 le=1.0,
+                                                 description="Sampling temperature in [0, 1].",
+                                                 space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=NIMModelConfig)

nat/llm/openai_llm.py

@@ -24,19 +24,12 @@ from nat.data_models.common import OptionalSecretStr
 from nat.data_models.llm import LLMBaseConfig
 from nat.data_models.optimizable import OptimizableField
 from nat.data_models.optimizable import OptimizableMixin
+from nat.data_models.optimizable import SearchSpace
 from nat.data_models.retry_mixin import RetryMixin
-from nat.data_models.temperature_mixin import TemperatureMixin
 from nat.data_models.thinking_mixin import ThinkingMixin
-from nat.data_models.top_p_mixin import TopPMixin
 
 
-class OpenAIModelConfig(LLMBaseConfig,
-                        RetryMixin,
-                        OptimizableMixin,
-                        TemperatureMixin,
-                        TopPMixin,
-                        ThinkingMixin,
-                        name="openai"):
+class OpenAIModelConfig(LLMBaseConfig, RetryMixin, OptimizableMixin, ThinkingMixin, name="openai"):
     """An OpenAI LLM provider to be used with an LLM client."""
 
     model_config = ConfigDict(protected_namespaces=(), extra="allow")
@@ -48,6 +41,16 @@ class OpenAIModelConfig(LLMBaseConfig,
                                        description="The OpenAI hosted model name.")
     seed: int | None = Field(default=None, description="Random seed to set for generation.")
     max_retries: int = Field(default=10, description="The max number of retries for the request.")
+    temperature: float | None = OptimizableField(default=None,
+                                                 ge=0.0,
+                                                 le=1.0,
+                                                 description="Sampling temperature in [0, 1].",
+                                                 space=SearchSpace(high=0.9, low=0.1, step=0.2))
+    top_p: float | None = OptimizableField(default=None,
+                                           ge=0.0,
+                                           le=1.0,
+                                           description="Top-p for distribution sampling.",
+                                           space=SearchSpace(high=1.0, low=0.5, step=0.1))
 
 
 @register_llm_provider(config_type=OpenAIModelConfig)

nat/tool/code_execution/code_sandbox.py

@@ -92,7 +92,9 @@ class Sandbox(abc.ABC):
             raise ValueError(f"Language {language} not supported")
 
         generated_code = generated_code.strip().strip("`")
-        code_to_execute = textwrap.dedent("""
+        # Use json.dumps to properly escape the generated_code instead of repr()
+        escaped_code = json.dumps(generated_code)
+        code_to_execute = textwrap.dedent(f"""
             import traceback
             import json
             import os
@@ -101,11 +103,6 @@ class Sandbox(abc.ABC):
             import io
             warnings.filterwarnings('ignore')
             os.environ['OPENBLAS_NUM_THREADS'] = '16'
-        """).strip()
-
-        # Use json.dumps to properly escape the generated_code instead of repr()
-        escaped_code = json.dumps(generated_code)
-        code_to_execute += textwrap.dedent(f"""
 
             generated_code = {escaped_code}
 

nat/tool/code_execution/local_sandbox/Dockerfile.sandbox

@@ -12,43 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Use the base image with Python 3.10 and Flask
-FROM tiangolo/uwsgi-nginx-flask:python3.10
-
-# Install dependencies required for Lean 4 and other tools
-RUN apt-get update && \
-    apt-get install -y curl git && \
-    curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh -s -- -y && \
-    /root/.elan/bin/elan toolchain install leanprover/lean4:v4.12.0 && \
-    /root/.elan/bin/elan default leanprover/lean4:v4.12.0 && \
-    /root/.elan/bin/elan self update
-
-# Set environment variables to include Lean and elan/lake in the PATH
-ENV PATH="/root/.elan/bin:$PATH"
-
-# Create Lean project directory and initialize a new Lean project with Mathlib4
-RUN mkdir -p /lean4 && cd /lean4 && \
-    /root/.elan/bin/lake new my_project && \
-    cd my_project && \
-    echo 'leanprover/lean4:v4.12.0' > lean-toolchain && \
-    echo 'require mathlib from git "https://github.com/leanprover-community/mathlib4" @ "v4.12.0"' >> lakefile.lean
-
-# Download and cache Mathlib4 to avoid recompiling, then build the project
-RUN cd /lean4/my_project && \
-    /root/.elan/bin/lake exe cache get && \
-    /root/.elan/bin/lake build
-
-# Set environment variables to include Lean project path
-ENV LEAN_PATH="/lean4/my_project"
-ENV PATH="/lean4/my_project:$PATH"
+# UWSGI_CHEAPER sets the number of initial uWSGI worker processes
+# UWSGI_PROCESSES sets the maximum number of uWSGI worker processes
+ARG UWSGI_CHEAPER=5
+ARG UWSGI_PROCESSES=10
+
+# Use the base image with Python 3.13
+FROM python:3.13-slim-bookworm
+
+
+RUN apt update && \
+    apt upgrade && \
+    apt install -y --no-install-recommends libexpat1 && \
+    apt clean && \
+    rm -rf /var/lib/apt/lists/*
 
 # Set up application code and install Python dependencies
 COPY sandbox.requirements.txt /app/requirements.txt
 RUN pip install --no-cache-dir -r /app/requirements.txt
 COPY local_sandbox_server.py /app/main.py
-
-# Set the working directory to /app
-WORKDIR /app
+RUN mkdir /workspace
 
 # Set Flask app environment variables and ports
 ARG UWSGI_CHEAPER
@@ -58,3 +41,7 @@ ARG UWSGI_PROCESSES
 ENV UWSGI_PROCESSES=$UWSGI_PROCESSES
 
 ENV LISTEN_PORT=6000
+EXPOSE 6000
+
+WORKDIR /app
+CMD uwsgi --http 0.0.0.0:${LISTEN_PORT} --master -p ${UWSGI_PROCESSES} --force-cwd /workspace -w main:app

nat/tool/code_execution/local_sandbox/local_sandbox_server.py

@@ -194,5 +194,10 @@ def execute():
     return do_execute(request)
 
 
+@app.route("/", methods=["GET"])
+def status() -> tuple[dict[str, str], int]:
+    return ({"status": "ok"}, 200)
+
+
 if __name__ == '__main__':
     app.run(port=6000)

nat/tool/code_execution/local_sandbox/sandbox.requirements.txt

@@ -1,6 +1,8 @@
+Flask==3.1
 numpy
 pandas
 scipy
 ipython
 plotly
 pydantic
+pyuwsgi==2.0.*

nat/tool/code_execution/local_sandbox/start_local_sandbox.sh

@@ -19,7 +19,11 @@
 
 DOCKER_COMMAND=${DOCKER_COMMAND:-"docker"}
 SANDBOX_NAME=${1:-'local-sandbox'}
-NUM_THREADS=10
+
+# UWSGI_CHEAPER sets the number of initial uWSGI worker processes
+# UWSGI_PROCESSES sets the maximum number of uWSGI worker processes
+UWSGI_CHEAPER=${UWSGI_CHEAPER:-5}
+UWSGI_PROCESSES=${UWSGI_PROCESSES:-10}
 
 # Get the output_data directory path for mounting
 # Priority: command line argument > environment variable > default path (current directory)
@@ -37,14 +41,16 @@ fi
 # Check if the Docker image already exists
 if ! ${DOCKER_COMMAND} images ${SANDBOX_NAME} | grep -q "${SANDBOX_NAME}"; then
     echo "Docker image not found locally. Building ${SANDBOX_NAME}..."
-    ${DOCKER_COMMAND} build --tag=${SANDBOX_NAME} --build-arg="UWSGI_PROCESSES=$((${NUM_THREADS} * 10))" --build-arg="UWSGI_CHEAPER=${NUM_THREADS}" -f Dockerfile.sandbox .
+    ${DOCKER_COMMAND} build --tag=${SANDBOX_NAME} \
+        --build-arg="UWSGI_PROCESSES=${UWSGI_PROCESSES}" \
+        --build-arg="UWSGI_CHEAPER=${UWSGI_CHEAPER}" \
+        -f Dockerfile.sandbox .
 else
     echo "Using existing Docker image: ${SANDBOX_NAME}"
 fi
 
 # Mount the output_data directory directly so files created in container appear in the local directory
-${DOCKER_COMMAND} run --rm --name=local-sandbox \
+${DOCKER_COMMAND} run --rm -ti --name=local-sandbox \
   --network=host \
   -v "${OUTPUT_DATA_PATH}:/workspace" \
-  -w /workspace \
   ${SANDBOX_NAME}

nat/utils/__init__.py

@@ -29,7 +29,8 @@ async def run_workflow(*,
                        config: "Config | None" = None,
                        config_file: "StrPath | None" = None,
                        prompt: str,
-                       to_type: type[_T] = str) -> _T:
+                       to_type: type[_T] = str,
+                       session_kwargs: dict[str, typing.Any] | None = None) -> _T:
     """
     Wrapper to run a workflow given either a config or a config file path and a prompt, returning the result in the
     type specified by the `to_type`.
@@ -66,7 +67,10 @@ async def run_workflow(*,
 
         config = load_config(config_file)
 
+    session_kwargs = session_kwargs or {}
+
     async with WorkflowBuilder.from_config(config=config) as workflow_builder:
-        workflow = SessionManager(await workflow_builder.build())
-        async with workflow.run(prompt) as runner:
-            return await runner.result(to_type=to_type)
+        session_manager = SessionManager(await workflow_builder.build())
+        async with session_manager.session(**session_kwargs) as session:
+            async with session.run(prompt) as runner:
+                return await runner.result(to_type=to_type)

{nvidia_nat-1.4.0a20251105.dist-info → nvidia_nat-1.4.0a20251107.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.4.0a20251105
+Version: 1.4.0a20251107
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation

{nvidia_nat-1.4.0a20251105.dist-info → nvidia_nat-1.4.0a20251107.dist-info}/RECORD

@@ -148,9 +148,7 @@ nat/data_models/step_adaptor.py,sha256=1qn56wB_nIYBM5IjN4ftsltCAkqaJd3Sqe5v0TRR4
 nat/data_models/streaming.py,sha256=sSqJqLqb70qyw69_4R9QC2RMbRw7UjTLPdo3FYBUGxE,1159
 nat/data_models/swe_bench_model.py,sha256=uZs-hLFuT1B5CiPFwFg1PHinDW8PHne8TBzu7tHFv_k,1718
 nat/data_models/telemetry_exporter.py,sha256=P7kqxIQnFVuvo_UFpH9QSB8fACy_0U2Uzkw_IfWXagE,998
-nat/data_models/temperature_mixin.py,sha256=LlpfWrWtDrPJfSKfNx5E0P3p5SNGZli7ACRRpmO0QqA,1628
 nat/data_models/thinking_mixin.py,sha256=VRDUJZ8XP_Vv0gW2FRZUf8O9-kVgNEdZCEZ8oEmHyMk,3335
-nat/data_models/top_p_mixin.py,sha256=mu0DLnCAiwNzpSFR8FOW4kQBUpodSrvUR4MsLrNtbgA,1599
 nat/data_models/ttc_strategy.py,sha256=tAkKWcyEBmBOOYtHMtQTgeCbHxFTk5SEkmFunNVnfyE,1114
 nat/embedder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/embedder/azure_openai_embedder.py,sha256=yMHOA6lWZl15Pvd9Gpp_rHy5q2qmBiRjbFesFBGuC_U,2441
@@ -167,7 +165,7 @@ nat/eval/runtime_event_subscriber.py,sha256=9MVgZLKvpnThHINaPbszPYDWnJ61sntS09YZ
 nat/eval/usage_stats.py,sha256=r8Zr3bIy2qXU1BgVKXr_4mr7bG0hte3BPNQLSgZvg8M,1376
 nat/eval/dataset_handler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/eval/dataset_handler/dataset_downloader.py,sha256=ZaNohbRSvoHPWIj0C_FqyJnhQKoTBk_uZF7ijjfk6vE,4641
-nat/eval/dataset_handler/dataset_filter.py,sha256=HrK0m3SQnPX6zOcKwJwYMrD9O-f6aOw8Vo3j9RKszqE,2115
+nat/eval/dataset_handler/dataset_filter.py,sha256=8ul9j8XvMJG28k2NoiTzGhN6l8pq58Y1T22uuW_m1rk,3397
 nat/eval/dataset_handler/dataset_handler.py,sha256=my28rKvQiiRN_h2TJz6fdKeMOjP3LC3_e2aJNnPPYhE,18159
 nat/eval/evaluator/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
 nat/eval/evaluator/base_evaluator.py,sha256=5WaVGhCGzkynCJyQdxRv7CtqLoUpr6B4O8tilP_gb3g,3232
@@ -271,11 +269,11 @@ nat/front_ends/mcp/tool_converter.py,sha256=IOHb8UoW_TVvRoiML2yi6nlbx13KgcmUsuYO
 nat/front_ends/simple_base/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/front_ends/simple_base/simple_front_end_plugin_base.py,sha256=py_yA9XAw-yHfK5cQJLM8ElnubEEM2ac8M0bvz-ScWs,1801
 nat/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nat/llm/aws_bedrock_llm.py,sha256=Qo6-7MUrh4qGzUQMsEPTyKEBp5D7DwU6e8LHoHwzQIs,3252
-nat/llm/azure_openai_llm.py,sha256=IJ_o6W_NtR2rzaCowznyJUA8-5F4CG0scy3Nw2egoPs,2709
-nat/llm/litellm_llm.py,sha256=060odQkgTR087LmFrgnpy_yP0nvUoHI25DahS5VUbgA,3003
-nat/llm/nim_llm.py,sha256=2v5QC16Fk-Nczx2p9OP7hfPM7CsylbAEZlkJrkvLgKI,2789
-nat/llm/openai_llm.py,sha256=vg4K05IUamsRz9SVs1GUJrabr38cs8JNa_jd52048cw,2637
+nat/llm/aws_bedrock_llm.py,sha256=PooVYBdM_wesYD-uoZRblHoWt247O3_9Y-cGBSHDK0s,3653
+nat/llm/azure_openai_llm.py,sha256=3Z90Jmq4kYwAIzlHGyT8aXNjL8UEGqnNxzk5Xf9HWsI,3371
+nat/llm/litellm_llm.py,sha256=_EBDUfGSIZXs-O1adQ3MPI7qMtwHJpDPd7awJNA3c6A,3608
+nat/llm/nim_llm.py,sha256=FWOvoU_QcuRdZID63xEGw_mii9OtAUMQ6lvvlvNy2FY,3232
+nat/llm/openai_llm.py,sha256=MpQ0AIMjoxJeU7-JRLigAL6gtigUaSB77s-ZAD3uUzo,3114
 nat/llm/register.py,sha256=7xDYdK4w4opAwIjzDM5x7moJXT3QeEGaGGc_nDfY0i4,1090
 nat/llm/utils/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
 nat/llm/utils/env_config_value.py,sha256=kBVsv0pEokIAfDQx5omR7_FevFv_5fTPswcbnvhVT2c,3548
@@ -427,21 +425,20 @@ nat/tool/retriever.py,sha256=FP5JL1vCQNrqaKz4F1up-osjxEPhxPFOyaScrgByc34,3877
 nat/tool/server_tools.py,sha256=rQLipwRv8lAyU-gohky2JoVDxWQTUTSttNWjhu7lcHU,3194
 nat/tool/code_execution/README.md,sha256=sl3YX4As95HX61XqTXOGnUcHBV1lla-OeuTnLI4qgng,4019
 nat/tool/code_execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nat/tool/code_execution/code_sandbox.py,sha256=AynQfmvT4mtrV5DHV-20HF8mNTDo1NX4Wj2mlpaEIfs,10159
+nat/tool/code_execution/code_sandbox.py,sha256=evu0n9oTc_MrrQuYbo1TP0sjnjLniRgCsOubO5G5WT4,10090
 nat/tool/code_execution/register.py,sha256=zPFzYqaQhH2B3K8iildVYY_7RKgpoRNKdAo00KmBLQI,3322
-nat/tool/code_execution/test_code_execution_sandbox.py,sha256=iyK9awJs6ST8fc_S3lNPye6It0DxSNp1UIrAUKPJ1h4,14776
 nat/tool/code_execution/utils.py,sha256=__W-T1kaphFKYSc2AydQW8lCdvD7zAccarvs7XVFTtI,4194
 nat/tool/code_execution/local_sandbox/.gitignore,sha256=BrV-H5osDtwwIx0eieoexolpnaJvc2DQLV15j95Qtyg,19
-nat/tool/code_execution/local_sandbox/Dockerfile.sandbox,sha256=CYqZ5jbBwk3ge8pg87aLjhzWERauScwya5naYq0vb5o,2316
+nat/tool/code_execution/local_sandbox/Dockerfile.sandbox,sha256=mIbGFhhY-9ARQVK-tGmx-ft68wFIpB_RvM69V37OEAY,1557
 nat/tool/code_execution/local_sandbox/__init__.py,sha256=k25Kqr_PrH4s0YCfzVzC9vaBAiu8yI428C4HX-qUcqA,615
-nat/tool/code_execution/local_sandbox/local_sandbox_server.py,sha256=eOFQV8ZE9-n7YfV4EEr-BFxDXG15jQUhO9oX1P1mgm8,6926
-nat/tool/code_execution/local_sandbox/sandbox.requirements.txt,sha256=R86yJ6mcUhfD9_ZU-rSMdaojR6MU41hcH4pE3vAGmcE,43
-nat/tool/code_execution/local_sandbox/start_local_sandbox.sh,sha256=gnPuzbneKZ61YvzaGIYSUdcyKMLuchYPti3zGLaNCZY,2055
+nat/tool/code_execution/local_sandbox/local_sandbox_server.py,sha256=VGLY2ASmSSYNacGNdMSiedclwTCILNHs6PX45LxQ4Wc,7040
+nat/tool/code_execution/local_sandbox/sandbox.requirements.txt,sha256=DL4dVNC8G-PMvr_x2C5AhwmeOpSKynpy4FNHWtWWtG4,69
+nat/tool/code_execution/local_sandbox/start_local_sandbox.sh,sha256=BejvFn0uqI-BdBh3HqGWu7CngeJObiUFw-vAVQZA5VE,2260
 nat/tool/memory_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/tool/memory_tools/add_memory_tool.py,sha256=N400PPvI37NUCMh5KcuoAL8khK8ecUQyfenahfjzbHQ,3368
 nat/tool/memory_tools/delete_memory_tool.py,sha256=zMllkpC0of9qFPNuG9vkVOoydRblOViCQf0uSbqz0sE,2461
 nat/tool/memory_tools/get_memory_tool.py,sha256=fcW6QE7bMZrpNK62et3sTw_QZ8cV9lXfEuDsm1-05bE,2768
-nat/utils/__init__.py,sha256=WRO5RDryn6mChA2gwDVERclaei7LGPwrEMCUSliZI7k,2653
+nat/utils/__init__.py,sha256=v6KZnvq8gT1VK-P_g5zHgoq9lhD4wvGwqCyb67aBkTo,2859
 nat/utils/callable_utils.py,sha256=EIao6NhHRFEoBqYRC7aWoFqhlr2LeFT0XK-ac0coF9E,2475
 nat/utils/debugging_utils.py,sha256=6M4JhbHDNDnfmSRGmHvT5IgEeWSHBore3VngdE_PMqc,1332
 nat/utils/decorators.py,sha256=AoMip9zmqrZm5wovZQytNvzFfIlS3PQxSYcgYeoLhxA,8240
@@ -475,10 +472,10 @@ nat/utils/reactive/base/observer_base.py,sha256=6BiQfx26EMumotJ3KoVcdmFBYR_fnAss
 nat/utils/reactive/base/subject_base.py,sha256=UQOxlkZTIeeyYmG5qLtDpNf_63Y7p-doEeUA08_R8ME,2521
 nat/utils/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/utils/settings/global_settings.py,sha256=9JaO6pxKT_Pjw6rxJRsRlFCXdVKCl_xUKU2QHZQWWNM,7294
-nvidia_nat-1.4.0a20251105.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
-nvidia_nat-1.4.0a20251105.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-nvidia_nat-1.4.0a20251105.dist-info/METADATA,sha256=et1fcmaVq-vji3uL9r4yjQQm1NQpEwfBZBi-1_fmqV4,10248
-nvidia_nat-1.4.0a20251105.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat-1.4.0a20251105.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
-nvidia_nat-1.4.0a20251105.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
-nvidia_nat-1.4.0a20251105.dist-info/RECORD,,
+nvidia_nat-1.4.0a20251107.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat-1.4.0a20251107.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat-1.4.0a20251107.dist-info/METADATA,sha256=XV37UjKy841cyPFRaYIBrhQdZnmu_XcVyf0jEGhsoH8,10248
+nvidia_nat-1.4.0a20251107.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat-1.4.0a20251107.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
+nvidia_nat-1.4.0a20251107.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
+nvidia_nat-1.4.0a20251107.dist-info/RECORD,,

nat/data_models/temperature_mixin.py

@@ -1,44 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import re
-
-from pydantic import BaseModel
-
-from nat.data_models.gated_field_mixin import GatedFieldMixin
-from nat.data_models.optimizable import OptimizableField
-from nat.data_models.optimizable import SearchSpace
-
-
-class TemperatureMixin(
-        BaseModel,
-        GatedFieldMixin,
-        field_name="temperature",
-        default_if_supported=0.0,
-        keys=("model_name", "model", "azure_deployment"),
-        unsupported=(re.compile(r"gpt-?5", re.IGNORECASE), ),
-):
-    """
-    Mixin class for temperature configuration. Unsupported on models like gpt-5.
-
-    Attributes:
-        temperature: Sampling temperature in [0, 1]. Defaults to 0.0 when supported on the model.
-    """
-    temperature: float | None = OptimizableField(
-        default=None,
-        ge=0.0,
-        le=1.0,
-        description="Sampling temperature in [0, 1]. Defaults to 0.0 when supported on the model.",
-        space=SearchSpace(high=0.9, low=0.1, step=0.2))

nat/data_models/top_p_mixin.py

@@ -1,44 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import re
-
-from pydantic import BaseModel
-
-from nat.data_models.gated_field_mixin import GatedFieldMixin
-from nat.data_models.optimizable import OptimizableField
-from nat.data_models.optimizable import SearchSpace
-
-
-class TopPMixin(
-        BaseModel,
-        GatedFieldMixin,
-        field_name="top_p",
-        default_if_supported=1.0,
-        keys=("model_name", "model", "azure_deployment"),
-        unsupported=(re.compile(r"gpt-?5", re.IGNORECASE), ),
-):
-    """
-    Mixin class for top-p configuration. Unsupported on models like gpt-5.
-
-    Attributes:
-        top_p: Top-p for distribution sampling. Defaults to 1.0 when supported on the model.
-    """
-    top_p: float | None = OptimizableField(
-        default=None,
-        ge=0.0,
-        le=1.0,
-        description="Top-p for distribution sampling. Defaults to 1.0 when supported on the model.",
-        space=SearchSpace(high=1.0, low=0.5, step=0.1))

nat/tool/code_execution/test_code_execution_sandbox.py

@@ -1,414 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Test suite for Code Execution Sandbox using pytest.
-
-This module provides comprehensive testing for the code execution sandbox service,
-replacing the original bash script with a more maintainable Python implementation.
-"""
-
-import os
-from typing import Any
-
-import pytest
-import requests
-from requests.exceptions import ConnectionError
-from requests.exceptions import RequestException
-from requests.exceptions import Timeout
-
-
-class TestCodeExecutionSandbox:
-    """Test suite for the Code Execution Sandbox service."""
-
-    @pytest.fixture(scope="class")
-    def sandbox_config(self):
-        """Configuration for sandbox testing."""
-        return {
-            "url": os.environ.get("SANDBOX_URL", "http://127.0.0.1:6000/execute"),
-            "timeout": int(os.environ.get("SANDBOX_TIMEOUT", "30")),
-            "connection_timeout": 5
-        }
-
-    @pytest.fixture(scope="class", autouse=True)
-    def check_sandbox_running(self, sandbox_config):
-        """Check if sandbox server is running before running tests."""
-        try:
-            _ = requests.get(sandbox_config["url"], timeout=sandbox_config["connection_timeout"])
-            print(f"✓ Sandbox server is running at {sandbox_config['url']}")
-        except (ConnectionError, Timeout, RequestException):
-            pytest.skip(
-                f"Sandbox server is not running at {sandbox_config['url']}. "
-                "Please start it with: cd src/nat/tool/code_execution/local_sandbox && ./start_local_sandbox.sh")
-
-    def execute_code(self, sandbox_config: dict[str, Any], code: str, language: str = "python") -> dict[str, Any]:
-        """
-        Execute code in the sandbox and return the response.
-
-        Args:
-            sandbox_config: Configuration dictionary
-            code: Code to execute
-            language: Programming language (default: python)
-
-        Returns:
-            dictionary containing the response from the sandbox
-        """
-        payload = {"generated_code": code, "timeout": sandbox_config["timeout"], "language": language}
-
-        response = requests.post(
-            sandbox_config["url"],
-            json=payload,
-            timeout=sandbox_config["timeout"] + 5  # Add buffer to request timeout
-        )
-
-        # Ensure we got a response
-        response.raise_for_status()
-        return response.json()
-
-    def test_simple_print(self, sandbox_config):
-        """Test simple print statement execution."""
-        code = "print('Hello, World!')"
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "Hello, World!" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_basic_arithmetic(self, sandbox_config):
-        """Test basic arithmetic operations."""
-        code = """
-result = 2 + 3
-print(f'Result: {result}')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "Result: 5" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_numpy_operations(self, sandbox_config):
-        """Test numpy dependency availability and operations."""
-        code = """
-import numpy as np
-arr = np.array([1, 2, 3, 4, 5])
-print(f'Array: {arr}')
-print(f'Mean: {np.mean(arr)}')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "Array: [1 2 3 4 5]" in result["stdout"]
-        assert "Mean: 3.0" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_pandas_operations(self, sandbox_config):
-        """Test pandas dependency availability and operations."""
-        code = """
-import pandas as pd
-df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
-print(df)
-print(f'Sum of column A: {df["A"].sum()}')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "Sum of column A: 6" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_plotly_import(self, sandbox_config):
-        """Test plotly dependency availability."""
-        code = """
-import plotly.graph_objects as go
-print('Plotly imported successfully')
-fig = go.Figure()
-fig.add_trace(go.Scatter(x=[1, 2, 3], y=[4, 5, 6]))
-print('Plot created successfully')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "Plotly imported successfully" in result["stdout"]
-        assert "Plot created successfully" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_syntax_error_handling(self, sandbox_config):
-        """Test handling of syntax errors."""
-        code = """
-print('Hello World'
-# Missing closing parenthesis
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "error"
-        assert "SyntaxError" in result["stderr"] or "SyntaxError" in result["stdout"]
-
-    def test_runtime_error_handling(self, sandbox_config):
-        """Test handling of runtime errors."""
-        code = """
-x = 1 / 0
-print('This should not print')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "error"
-        assert "ZeroDivisionError" in result["stderr"] or "ZeroDivisionError" in result["stdout"]
-
-    def test_import_error_handling(self, sandbox_config):
-        """Test handling of import errors."""
-        code = """
-import nonexistent_module
-print('This should not print')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "error"
-        assert "ModuleNotFoundError" in result["stderr"] or "ImportError" in result["stderr"]
-
-    def test_mixed_output(self, sandbox_config):
-        """Test code that produces both stdout and stderr output."""
-        code = """
-import sys
-print('This goes to stdout')
-print('This goes to stderr', file=sys.stderr)
-print('Back to stdout')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "This goes to stdout" in result["stdout"]
-        assert "Back to stdout" in result["stdout"]
-        assert "This goes to stderr" in result["stderr"]
-
-    def test_long_running_code(self, sandbox_config):
-        """Test code that takes some time to execute but completes within timeout."""
-        code = """
-import time
-for i in range(3):
-    print(f'Iteration {i}')
-    time.sleep(0.5)
-print('Completed')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "Iteration 0" in result["stdout"]
-        assert "Iteration 1" in result["stdout"]
-        assert "Iteration 2" in result["stdout"]
-        assert "Completed" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_file_operations(self, sandbox_config):
-        """Test basic file operations in the sandbox."""
-        code = """
-import os
-print(f'Current directory: {os.getcwd()}')
-with open('test_file.txt', 'w') as f:
-    f.write('Hello, World!')
-with open('test_file.txt', 'r') as f:
-    content = f.read()
-print(f'File content: {content}')
-os.remove('test_file.txt')
-print('File operations completed')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "File content: Hello, World!" in result["stdout"]
-        assert "File operations completed" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_file_persistence_create(self, sandbox_config):
-        """Test file persistence - create various file types."""
-        code = """
-import os
-import pandas as pd
-import numpy as np
-print('Current directory:', os.getcwd())
-print('Directory contents:', os.listdir('.'))
-
-# Create a test file
-with open('persistence_test.txt', 'w') as f:
-    f.write('Hello from sandbox persistence test!')
-
-# Create a CSV file
-df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
-df.to_csv('persistence_test.csv', index=False)
-
-# Create a numpy array file
-arr = np.array([1, 2, 3, 4, 5])
-np.save('persistence_test.npy', arr)
-
-print('Files created:')
-for file in os.listdir('.'):
-    if 'persistence_test' in file:
-        print('  -', file)
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "persistence_test.txt" in result["stdout"]
-        assert "persistence_test.csv" in result["stdout"]
-        assert "persistence_test.npy" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_file_persistence_read(self, sandbox_config):
-        """Test file persistence - read back created files."""
-        code = """
-import pandas as pd
-import numpy as np
-
-# Read back the files we created
-print('=== Reading persistence_test.txt ===')
-with open('persistence_test.txt', 'r') as f:
-    content = f.read()
-    print(f'Content: {content}')
-
-print('\\n=== Reading persistence_test.csv ===')
-df = pd.read_csv('persistence_test.csv')
-print(df)
-print(f'DataFrame shape: {df.shape}')
-
-print('\\n=== Reading persistence_test.npy ===')
-arr = np.load('persistence_test.npy')
-print(f'Array: {arr}')
-print(f'Array sum: {np.sum(arr)}')
-
-print('\\n=== File persistence test PASSED! ===')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "Content: Hello from sandbox persistence test!" in result["stdout"]
-        assert "DataFrame shape: (3, 2)" in result["stdout"]
-        assert "Array: [1 2 3 4 5]" in result["stdout"]
-        assert "Array sum: 15" in result["stdout"]
-        assert "File persistence test PASSED!" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_json_operations(self, sandbox_config):
-        """Test JSON file operations for persistence."""
-        code = """
-import json
-import os
-
-# Create a complex JSON file
-data = {
-    'test_name': 'sandbox_persistence',
-    'timestamp': '2024-07-03',
-    'results': {
-        'numpy_test': True,
-        'pandas_test': True,
-        'file_operations': True
-    },
-    'metrics': [1.5, 2.3, 3.7, 4.1],
-    'metadata': {
-        'working_dir': os.getcwd(),
-        'python_version': '3.x'
-    }
-}
-
-# Save JSON file
-with open('persistence_test.json', 'w') as f:
-    json.dump(data, f, indent=2)
-
-# Read it back
-with open('persistence_test.json', 'r') as f:
-    loaded_data = json.load(f)
-
-print('JSON file created and loaded successfully')
-print(f'Test name: {loaded_data["test_name"]}')
-print(f'Results count: {len(loaded_data["results"])}')
-print(f'Metrics: {loaded_data["metrics"]}')
-print('JSON persistence test completed!')
-"""
-        result = self.execute_code(sandbox_config, code)
-
-        assert result["process_status"] == "completed"
-        assert "JSON file created and loaded successfully" in result["stdout"]
-        assert "Test name: sandbox_persistence" in result["stdout"]
-        assert "Results count: 3" in result["stdout"]
-        assert "JSON persistence test completed!" in result["stdout"]
-        assert result["stderr"] == ""
-
-    def test_missing_generated_code_field(self, sandbox_config):
-        """Test request missing the generated_code field."""
-        payload = {"timeout": 10, "language": "python"}
-
-        response = requests.post(sandbox_config["url"], json=payload)
-
-        # Should return an error status code or error in response
-        assert response.status_code != 200 or "error" in response.json()
-
-    def test_missing_timeout_field(self, sandbox_config):
-        """Test request missing the timeout field."""
-        payload = {"generated_code": "print('test')", "language": "python"}
-
-        response = requests.post(sandbox_config["url"], json=payload)
-
-        # Should return error for missing timeout field
-        result = response.json()
-        assert response.status_code == 400 and result["process_status"] == "error"
-
-    def test_invalid_json(self, sandbox_config):
-        """Test request with invalid JSON."""
-        invalid_json = '{"generated_code": "print("test")", "timeout": 10}'
-
-        response = requests.post(sandbox_config["url"], data=invalid_json, headers={"Content-Type": "application/json"})
-
-        # Should return error for invalid JSON
-        assert response.status_code != 200
-
-    def test_non_json_request(self, sandbox_config):
-        """Test request with non-JSON content."""
-        response = requests.post(sandbox_config["url"], data="This is not JSON", headers={"Content-Type": "text/plain"})
-
-        # Should return error for non-JSON content
-        assert response.status_code != 200
-
-    def test_timeout_too_low(self, sandbox_config):
-        """Test request with timeout too low."""
-        code = """
-import time
-time.sleep(2.0)
-"""
-        payload = {"generated_code": code, "timeout": 1, "language": "python"}
-        response = requests.post(sandbox_config["url"], json=payload)
-        assert response.json()["process_status"] == "timeout"
-        assert response.status_code == 200
-
-
-# Pytest configuration and fixtures for command-line options
-def pytest_addoption(parser):
-    """Add custom command-line options for pytest."""
-    parser.addoption("--sandbox-url",
-                     action="store",
-                     default="http://127.0.0.1:6000/execute",
-                     help="Sandbox URL for testing")
-    parser.addoption("--sandbox-timeout",
-                     action="store",
-                     type=int,
-                     default=30,
-                     help="Timeout in seconds for sandbox operations")
-
-
-@pytest.fixture(scope="session", autouse=True)
-def setup_environment(request):
-    """Setup environment variables from command-line options."""
-    os.environ["SANDBOX_URL"] = request.config.getoption("--sandbox-url", "http://127.0.0.1:6000/execute")
-    os.environ["SANDBOX_TIMEOUT"] = str(request.config.getoption("--sandbox-timeout", 30))
-
-
-if __name__ == "__main__":
-    # Allow running as a script
-    pytest.main([__file__, "-v"])