fix tests

Author: austin3dickey

extensions/positron-python/python_files/posit/positron/tests/test_convert.py

@@ -20,6 +20,7 @@
 from .conftest import DummyComm, PositronShell
 from .test_data_explorer import (
     COMPARE_OPS,
+    SIMPLE_DATA,
     SIMPLE_PANDAS_DF,
     DataExplorerFixture,
     _between_filter,
@@ -42,8 +43,13 @@
 except ImportError:
     has_sqlalchemy = False
 
+try:
+    import pyarrow
 
-SIMPLE_POLARS_DF = pl.DataFrame(SIMPLE_PANDAS_DF.drop(columns=["f"]))
+    SIMPLE_POLARS_DF = pl.DataFrame(SIMPLE_PANDAS_DF.drop(columns=["f"]))
+except ImportError:
+    pyarrow = None
+    SIMPLE_POLARS_DF = pl.DataFrame({k: v for k, v in SIMPLE_DATA.items() if k != "f"})
 
 
 # ruff: noqa: E712
@@ -655,7 +661,7 @@ def test_convert_polars_filter_compare(dxf: DataExplorerConvertFixture):
 def test_convert_polars_filter_datetimetz(dxf: DataExplorerConvertFixture):
     test_df = pl.DataFrame(
         {
-            "date": pd.date_range("2000-01-01", periods=5, tz="US/Eastern"),
+            "date": pd.date_range("2000-01-01", periods=5, tz="US/Eastern").to_list(),
         }
     )
     tz = pytz.timezone("US/Eastern")
@@ -692,6 +698,7 @@ def test_convert_polars_sort_and_filter(dxf: DataExplorerConvertFixture):
     )
 
 
+@pytest.mark.skipif(pyarrow is None, reason="pyarrow is not installed")
 def test_convert_polars_sort_to_pandas(dxf: DataExplorerConvertFixture):
     # Test that we can convert a sort operation to pandas
     test_df = SIMPLE_POLARS_DF

extensions/positron-python/python_files/posit/positron/tests/test_data_explorer.py

@@ -14,7 +14,6 @@
 from io import StringIO
 from typing import Any, Dict, List, Optional, Type, cast
 
-import ibis
 import numpy as np
 import pandas as pd
 import polars as pl
@@ -59,6 +58,11 @@
 from .test_variables import BIG_ARRAY_LENGTH, _assign_variables
 from .utils import dummy_rpc_request, json_rpc_notification, json_rpc_request
 
+try:
+    import ibis
+except ImportError:
+    ibis = None
+
 TARGET_NAME = "positron.dataExplorer"
 
 
@@ -122,7 +126,7 @@ def __repr__(self):
     "a": [1, 2, 3, 4, 5],
     "b": [True, False, True, None, True],
     "c": ["foo", "bar", None, "bar", "None"],
-    "d": [0, 1.2, -4.5, 6, np.nan],
+    "d": [0.0, 1.2, -4.5, 6, np.nan],
     "e": pd.to_datetime(
         [
             "2024-01-01 00:00:00",
@@ -139,13 +143,16 @@ def __repr__(self):
 
 SIMPLE_PANDAS_DF = pd.DataFrame(SIMPLE_DATA)
 
-SIMPLE_IBIS_DF = ibis.memtable(
-    {
-        "a": [1, 2, 3, 4, 5],
-        "b": [True, False, True, None, True],
-        "c": ["foo", "bar", None, "bar", "None"],
-    }
-)
+if ibis:
+    SIMPLE_IBIS_DF = ibis.memtable(
+        {
+            "a": [1, 2, 3, 4, 5],
+            "b": [True, False, True, None, True],
+            "c": ["foo", "bar", None, "bar", "None"],
+        }
+    )
+else:
+    SIMPLE_IBIS_DF = None
 
 
 def test_service_properties(de_service: DataExplorerService):
@@ -4211,6 +4218,7 @@ def test_polars_profile_summary_stats(dxf: DataExplorerFixture):
         assert_summary_stats_equal(stats["type_display"], stats, ex_result)
 
 
+@pytest.mark.skipif(ibis is None, reason="ibis is not available")
 def test_ibis_supported_features(dxf: DataExplorerFixture):
     dxf.register_table("example", SIMPLE_IBIS_DF)
     features = dxf.get_state("example")["supported_features"]

extensions/positron-python/python_files/posit/positron/tests/test_inspectors.py

@@ -9,14 +9,11 @@
 import types
 from typing import Any, Callable, Iterable, Optional, Tuple
 
-import geopandas
 import numpy as np
 import pandas as pd
 import polars as pl
 import pytest
-import torch
 from fastcore.foundation import L
-from shapely.geometry import Polygon
 
 from positron import inspectors
 from positron.inspectors import _get_simplified_qualname, get_inspector
@@ -37,6 +34,23 @@
 )
 from .utils import get_type_as_str
 
+try:
+    import geopandas
+    from shapely.geometry import Polygon
+except ImportError:
+    geopandas = None
+    Polygon = None
+
+try:
+    import torch
+except ImportError:
+    torch = None
+
+try:
+    import ibis
+except ImportError:
+    ibis = None
+
 
 def verify_inspector(
     *,
@@ -627,6 +641,7 @@ def mutate(x):
     )
 
 
+@pytest.mark.skipif(geopandas is None, reason="geopandas is not available")
 def test_inspect_geopandas_dataframe() -> None:
     p1 = Polygon([(0, 0), (1, 0), (1, 1)])
     p2 = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])
@@ -708,19 +723,15 @@ def mutate(x):
     )
 
 
-@pytest.mark.parametrize(
-    "value",
-    [
-        geopandas.GeoSeries(
-            [
-                Polygon([(0, 0), (1, 0), (1, 1)]),
-                Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]),
-                Polygon([(2, 0), (3, 0), (3, 1), (2, 1)]),
-            ]
-        ),
-    ],
-)
-def test_inspect_geopandas_series(value: geopandas.GeoSeries) -> None:
+@pytest.mark.skipif(geopandas is None, reason="geopandas is not available")
+def test_inspect_geopandas_series() -> None:
+    value = geopandas.GeoSeries(
+        [
+            Polygon([(0, 0), (1, 0), (1, 1)]),
+            Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]),
+            Polygon([(2, 0), (3, 0), (3, 1), (2, 1)]),
+        ]
+    )
     (rows,) = value.shape
 
     def mutate(x):
@@ -875,9 +886,8 @@ def test_get_child(value: Any, key: Any, expected: Any) -> None:
 
 
 @pytest.mark.skipif(sys.version_info < (3, 10), reason="requires Python 3.10 or higher")
+@pytest.mark.skipif(ibis is None, reason="ibis not available")
 def test_inspect_ibis_exprs() -> None:
-    import ibis
-
     # Make sure we don't return an executed repr
     ibis.options.interactive = True
 
@@ -921,16 +931,21 @@ def test_inspect_ibis_exprs() -> None:
 @pytest.mark.parametrize(
     ("value", "expected"),
     [
-        (np.array([[1, 2, 3], [4, 5, 6]], dtype="int64"), 48),
-        (torch.Tensor([[1, 2, 3], [4, 5, 6]]), 24),
-        (pd.Series([1, 2, 3, 4]), 32),
-        (pl.Series([1, 2, 3, 4]), 32),
-        (pd.DataFrame({"a": [1, 2], "b": ["3", "4"]}), 4),
-        (pl.DataFrame({"a": [1, 2], "b": ["3", "4"]}), 4),
-        (pd.Index([0, 1]), 16),
+        (lambda: np.array([[1, 2, 3], [4, 5, 6]], dtype="int64"), 48),
+        pytest.param(
+            lambda: torch.Tensor([[1, 2, 3], [4, 5, 6]]),
+            24,
+            marks=pytest.mark.skipif(torch is None, reason="torch not available"),
+        ),
+        (lambda: pd.Series([1, 2, 3, 4]), 32),
+        (lambda: pl.Series([1, 2, 3, 4]), 32),
+        (lambda: pd.DataFrame({"a": [1, 2], "b": ["3", "4"]}), 4),
+        (lambda: pl.DataFrame({"a": [1, 2], "b": ["3", "4"]}), 4),
+        (lambda: pd.Index([0, 1]), 16),
     ],
 )
-def test_arrays_maps_get_size(value: Any, expected: int) -> None:
+def test_arrays_maps_get_size(value: Callable, expected: int) -> None:
+    value = value()
     if value is None:
         return
     inspector = get_inspector(value)
@@ -944,43 +959,53 @@ class VeryLongClassNameThatShouldDefinitelyBeTruncatedBecauseItIsWayTooLong:
 @pytest.mark.parametrize(
     "value",
     [
-        pytest.param("The quick brown fox jumps over the lazy dog", id="string"),
-        pytest.param(sys.maxsize * 100, id="int"),
-        pytest.param(sys.float_info.max, id="float"),
-        pytest.param(complex(sys.float_info.min, sys.float_info.max), id="complex"),
+        pytest.param(lambda: "The quick brown fox jumps over the lazy dog", id="string"),
+        pytest.param(lambda: sys.maxsize * 100, id="int"),
+        pytest.param(lambda: sys.float_info.max, id="float"),
+        pytest.param(lambda: complex(sys.float_info.min, sys.float_info.max), id="complex"),
         pytest.param(
-            VeryLongClassNameThatShouldDefinitelyBeTruncatedBecauseItIsWayTooLong, id="class"
+            lambda: VeryLongClassNameThatShouldDefinitelyBeTruncatedBecauseItIsWayTooLong,
+            id="class",
         ),
-        pytest.param(b"The quick brown fox jumps over the lazy dog", id="bytes"),
-        pytest.param(bytearray(b"The quick brown fox jumps over the lazy dog"), id="bytearray"),
-        pytest.param(set(range(20)), id="set"),
-        pytest.param(frozenset(range(20)), id="frozenset"),
-        pytest.param(list(range(20)), id="list"),
-        pytest.param(LIST_WITH_CYCLE, id="list_cycle"),
-        pytest.param(range(12345678901), id="range"),
-        pytest.param(L(range(20)), id="fastcore_list"),
-        pytest.param(FASTCORE_LIST_WITH_CYCLE, id="fastcore_list_cycle"),
-        pytest.param({str(i): i for i in range(20)}, id="map"),
-        pytest.param(MAP_WITH_CYCLE, id="map_cycle"),
+        pytest.param(lambda: b"The quick brown fox jumps over the lazy dog", id="bytes"),
         pytest.param(
-            datetime.datetime(2021, 1, 1, 1, 23, 45, tzinfo=datetime.timezone.utc),
+            lambda: bytearray(b"The quick brown fox jumps over the lazy dog"), id="bytearray"
+        ),
+        pytest.param(lambda: set(range(20)), id="set"),
+        pytest.param(lambda: frozenset(range(20)), id="frozenset"),
+        pytest.param(lambda: list(range(20)), id="list"),
+        pytest.param(lambda: LIST_WITH_CYCLE, id="list_cycle"),
+        pytest.param(lambda: range(12345678901), id="range"),
+        pytest.param(lambda: L(range(20)), id="fastcore_list"),
+        pytest.param(lambda: FASTCORE_LIST_WITH_CYCLE, id="fastcore_list_cycle"),
+        pytest.param(lambda: {str(i): i for i in range(20)}, id="map"),
+        pytest.param(lambda: MAP_WITH_CYCLE, id="map_cycle"),
+        pytest.param(
+            lambda: datetime.datetime(2021, 1, 1, 1, 23, 45, tzinfo=datetime.timezone.utc),
             id="timestamp_datetime",
         ),
-        pytest.param(pd.Timestamp("2021-01-01 01:23:45"), id="timestamp_pandas"),
-        pytest.param(pd.Index(list(range(20))), id="pandas_index"),
-        pytest.param(pd.Series(list(range(20))), id="pandas_series"),
+        pytest.param(lambda: pd.Timestamp("2021-01-01 01:23:45"), id="timestamp_pandas"),
+        pytest.param(lambda: pd.Index(list(range(20))), id="pandas_index"),
+        pytest.param(lambda: pd.Series(list(range(20))), id="pandas_series"),
+        pytest.param(
+            lambda: pd.DataFrame({"a": list(range(20)), "b": list(range(20))}),
+            id="pandas_dataframe",
+        ),
+        pytest.param(lambda: pl.Series(list(range(20))), id="polars_series"),
         pytest.param(
-            pd.DataFrame({"a": list(range(20)), "b": list(range(20))}), id="pandas_dataframe"
+            lambda: pl.DataFrame({"a": list(range(20)), "b": list(range(20))}),
+            id="polars_dataframe",
         ),
-        pytest.param(pl.Series(list(range(20))), id="polars_series"),
+        pytest.param(lambda: np.ones((20, 20)), id="numpy_array"),
         pytest.param(
-            pl.DataFrame({"a": list(range(20)), "b": list(range(20))}), id="polars_dataframe"
+            lambda: torch.ones((20, 20)),
+            id="torch_tensor",
+            marks=pytest.mark.skipif(torch is None, reason="torch not available"),
         ),
-        pytest.param(np.ones((20, 20)), id="numpy_array"),
-        pytest.param(torch.ones((20, 20)), id="torch_tensor"),
     ],
 )
 def test_truncated_display_value(value, snapshot, monkeypatch) -> None:
+    value = value()
     # Patch the maximum string length for faster and more readable tests.
     monkeypatch.setattr(inspectors, "MAX_ITEMS_BY_LEVEL", (20, 10))
     monkeypatch.setattr(inspectors, "MAX_CHARACTERS", 20)

extensions/positron-python/python_files/posit/positron/tests/test_patch/test_haystack.py

@@ -3,12 +3,18 @@
 # Licensed under the Elastic License 2.0. See LICENSE.txt for license information.
 #
 
+import sys
 from typing import Any, Dict
 from unittest.mock import patch
 
+import pytest
+
 from positron.positron_ipkernel import PositronShell
 
 
+@pytest.mark.skipif(
+    sys.version_info >= (3, 14), reason="haystack is not installed at all on 3.14 yet"
+)
 def test_haystack_patch_automatically_applied(shell: PositronShell):
     """
     Test that the haystack is_in_jupyter function is automatically patched to return True.

extensions/positron-python/python_files/posit/positron/tests/test_positron_ipkernel.py

@@ -24,6 +24,11 @@
 from .conftest import PositronShell
 from .utils import assert_register_table_called
 
+try:
+    import lightning
+except ImportError:
+    lightning = None
+
 # The idea for these tests is to mock out communications with Positron
 # via our various comms, and only test IPython interactions. For
 # example, in testing the %view magic, we assert that running a cell
@@ -420,6 +425,7 @@ def test_console_warning_logger(shell: PositronShell, caplog, warning_kwargs):
         assert "this is a warning" in caplog.text
 
 
+@pytest.mark.skipif(lightning is None, reason="lightning is not installed")
 def test_import_lightning_and_torch_dynamo(shell: PositronShell) -> None:
     # See: https://github.com/posit-dev/positron/issues/5879
     shell.run_cell("import lightning").raise_error()

extensions/positron-python/python_files/posit/positron/tests/test_ui.py

@@ -29,7 +29,7 @@
 )
 
 try:
-    import torch  # type: ignore [reportMissingImports] for 3.12
+    import torch
 except ImportError:
     torch = None
 
@@ -104,7 +104,8 @@ def test_set_console_width(ui_comm: DummyComm) -> None:
     assert np.get_printoptions()["linewidth"] == width
     assert pd.get_option("display.width") is None
     assert pl.Config.state()["POLARS_TABLE_WIDTH"] == str(width)
-    assert torch._tensor_str.PRINT_OPTS.linewidth == width  # type: ignore[reportGeneralTypeIssues]  # noqa: SLF001
+    if torch is not None:
+        assert torch._tensor_str.PRINT_OPTS.linewidth == width  # noqa: SLF001
 
 
 def test_open_editor(ui_service: UiService, ui_comm: DummyComm) -> None:

extensions/positron-python/src/client/common/constants.ts

@@ -157,7 +157,7 @@ export const UseProposedApi = Symbol('USE_VSC_PROPOSED_API');
 export const IPYKERNEL_VERSION = '>=6.19.1';
 // We support versions where MINIMUM_PYTHON_VERSION <= version < MAXIMUM_PYTHON_VERSION_EXCLUSIVE.
 export const MINIMUM_PYTHON_VERSION = { major: 3, minor: 9, patch: 0, raw: '3.9.0' } as PythonVersion;
-export const MAXIMUM_PYTHON_VERSION_EXCLUSIVE = { major: 3, minor: 14, patch: 0, raw: '3.14.0' } as PythonVersion;
+export const MAXIMUM_PYTHON_VERSION_EXCLUSIVE = { major: 3, minor: 15, patch: 0, raw: '3.15.0' } as PythonVersion;
 export const INTERPRETERS_INCLUDE_SETTING_KEY = 'interpreters.include';
 export const INTERPRETERS_EXCLUDE_SETTING_KEY = 'interpreters.exclude';
 export const INTERPRETERS_OVERRIDE_SETTING_KEY = 'interpreters.override';

extensions/positron-python/src/client/positron/ipykernel.ts

@@ -49,7 +49,7 @@ export async function getIpykernelBundle(
 
     // Check if ipykernel is bundled for the interpreter version.
     // (defined in scripts/pip-compile-ipykernel.py).
-    if (interpreter.version?.major !== 3 || ![9, 10, 11, 12, 13].includes(interpreter.version?.minor)) {
+    if (interpreter.version?.major !== 3 || ![9, 10, 11, 12, 13, 14].includes(interpreter.version?.minor)) {
         return { disabledReason: `unsupported interpreter version: ${interpreter.version?.raw}` };
     }
 

extensions/positron-python/src/client/pythonEnvironments/creation/provider/uvUtils.ts

@@ -7,7 +7,7 @@ import { CancellationToken, QuickPickItem } from 'vscode';
 import { showQuickPickWithBack } from '../../../common/vscodeApis/windowApis';
 import { CreateEnv } from '../../../common/utils/localize';
 
-const SUPPORTED_UV_PYTHON_VERSIONS = ['3.14', '3.13', '3.12', '3.11', '3.10', '3.9'];
+const SUPPORTED_UV_PYTHON_VERSIONS = ['3.13', '3.12', '3.11', '3.10', '3.9', '3.14'];
 
 export function getUvPythonVersions(): { versions: string[] } {
     return {
@@ -18,7 +18,7 @@ export function getUvPythonVersions(): { versions: string[] } {
 export async function pickPythonVersion(token?: CancellationToken): Promise<string | undefined> {
     const items: QuickPickItem[] = SUPPORTED_UV_PYTHON_VERSIONS.map((v) => ({
         label: 'Python',
-        description: v,
+        description: v === '3.14' ? `${v} (preview)` : v,
     }));
     const selection = await showQuickPickWithBack(
         items,