refactor: Simplify `Implementation.to_native_namespace` #2620

FBruzzesi · 2025-05-26T20:19:43Z

What type of PR is this? (check all applicable)

Related issues

Another piece of Simplify misc #2492

Checklist

Code follows style guide (ruff)
Tests added
Documented the changes

If you have comments or can explain your changes, please do so below

Not sure how likable this is (see discord)

dangotbanned · 2025-05-26T20:33:11Z

Not sure how likable this is

The phrasing of this tickled me 😂

@FBruzzesi what if we solved this and closed a related issue in one go?

Make import_optional_dependency util #1940 (comment)

We'd use what you have as lambda, but define them as import_pandas, import_polars, etc.
And then wrap with a nice error message?

We'd also be able to get typing working (at least for the individual cases)

FBruzzesi · 2025-05-26T20:57:12Z

The phrasing of this tickled me 😂

I personally don't mind but who knows you guys don't have strong opinions on these hacks 😂

@FBruzzesi what if we solved this and closed a related issue in one go?

Make import_optional_dependency util #1940 (comment)

Sure, the polars implementation seems easy to adapt as well. What I am not too keen on is that MIN_VERSIONS is defined based on implementation, so that feels a bit circular, but definitly fixable 😂

We'd also be able to get typing working (at least for the individual cases)

To my knowledge, ModuleType is not a generic, so how would that work? i.e. what should the following simplified version return?

@overload
def import_optional(module_name: Literal["pandas"]) -> ?
    return __import__(module_name)

dangotbanned · 2025-05-26T21:54:21Z

The phrasing of this tickled me 😂

I personally don't mind but who knows you guys don't have strong opinions on these hacks 😂

@FBruzzesi what if we solved this and closed a related issue in one go?

Make import_optional_dependency util #1940 (comment)

Sure, the polars implementation seems easy to adapt as well. What I am not too keen on is that MIN_VERSIONS is defined based on implementation, so that feels a bit circular, but definitly fixable 😂

We'd also be able to get typing working (at least for the individual cases)

To my knowledge, ModuleType is not a generic, so how would that work? i.e. what should the following simplified version return?
@overload
def import_optional(module_name: Literal["pandas"]) -> ?
    return __import__(module_name)

At the end of (#1940 (comment)) ...

So you leave each import_* function return un-annotated, and let the Module(...) part get inferred 😎

Then you can have a mapping like:

# or replace `Implementation` with the literal you resolve in `Implementation.value`
_IMPORT_FUNCTIONS: Mapping[Implementation, Callable[..., ModuleType]] = {
    Implementation.PANDAS: import_pandas,
    Implementation.POLARS: import_polars,
    ...: ...,
}

#2620 (comment)

We'd also be able to get typing working (at least for the individual cases)

So in isolation we get the typing (import_polars()), but not when we do the redirect through a mapping (sadly 😢)

…o-native-namespace

See - #2620 (comment) - #1940

narwhals/dependencies.py

Sibling to `no_imports_test`

All usage had these: > error: Call to untyped function "import_pyarrow" in typed context [no-untyped-call]

Turns out `find_spec` raises if the parent is missing

https://github.com/narwhals-dev/narwhals/actions/runs/15346258379/job/43183041793?pr=2620

https://results.pre-commit.ci/run/github/760058710/1748960804.iLKqUy8zStajYHSWCO0d3Q

…b.com/narwhals-dev/narwhals into refactor/simplify-to-native-namespace

dangotbanned · 2025-06-06T14:46:16Z

The only way I've found to fix this was by removing the sys.modules monkeypatching.
But I don't really like that as it means find_spec isn't being tested against the case where the module hasn't been imported yet 🤔

https://github.com/narwhals-dev/narwhals/actions/runs/15491689078/job/43618476234?pr=2620

narwhals/utils.py

FBruzzesi · 2025-06-06T15:45:19Z

@MarcoGorelli @dangotbanned I tried to implement the idea I had mentioned in discord in 96540c3, yet apparently everything breaks apart with ibis, so I am happy to revert unless you guys have some other ideas.

The reason to use from importlib.metadata import version was mostly because sqlframe does not have __version__ that we can access (that's what polars does).
However,

import_module("ibis") -> ok
import_module("ibis-framework") -> errors
version("ibis") -> errors
version("ibis-framework") -> ok

dangotbanned · 2025-06-07T10:43:54Z

@FBruzzesi here's a platter of thoughts 😄

This PR

`importlib`

There's a very new PEP 794 – Import Name Metadata that seems relevant to the issue you had here

version("ibis") -> errors

import_module("ibis-framework") -> errors

ibis-framework is the name of the distribution, whereas ibis is the name of the package.
They're usually the same, but sadly not in this case 😞

https://github.com/python/cpython/blob/24069fbca861a5904ee7718469919e84828f22e7/Lib/importlib/metadata/__init__.py#L980-L987
https://github.com/python/cpython/blob/24069fbca861a5904ee7718469919e84828f22e7/Lib/importlib/__init__.py#L71-L88

`version`

The reason to use from importlib.metadata import version was mostly because sqlframe does not have __version__ that we can access (that's what polars does).

So this detail is already handled in here, you might notice it starts with a call to to_native_namespace

Implementation._backend_version

narwhals/narwhals/utils.py

Lines 617 to 635 in deaaf76

    
           def _backend_version(self) -> tuple[int, ...]: 
        
               native = self.to_native_namespace() 
        
               into_version: Any 
        
               if self not in { 
        
                   Implementation.PYSPARK, 
        
                   Implementation.PYSPARK_CONNECT, 
        
                   Implementation.DASK, 
        
                   Implementation.SQLFRAME, 
        
               }: 
        
                   into_version = native 
        
               elif self in {Implementation.PYSPARK, Implementation.PYSPARK_CONNECT}: 
        
                   into_version = get_pyspark()  # pragma: no cover 
        
               elif self is Implementation.DASK: 
        
                   into_version = get_dask() 
        
               else: 
        
                   import sqlframe._version 
        
                   into_version = sqlframe._version 
        
               return parse_version(into_version)

Minimum versions (generally)

I totally forgot to follow up on (https://discord.com/channels/1235257048170762310/1276640597284884490/1379470754051002389)

I'll continue this over on that other issue so you've got something to come back to

We have two other methods for enforcing version constraints:

utils.validate_backend_version
- For the absolute minimum
@requires.backend_version
- For method-specific support

If there is another use-case these don't cover, I think it would make the most sense to improve those tools.
This PR would be adding a third way of handling package versions - leading to 3 different error messages for the same issue 😔

FBruzzesi · 2025-06-07T12:07:16Z

Thanks @dangotbanned, I am aware of all the code parts you mentioned.

I think import_optional_dependency is a much more generic function, for a much more generic use case - at this point we should restrict to be able to import and validate the backends we support, at least for now to address to_native_namespace.

utils.validate_backend_version

Yes, but it requires and implementation & the version already

So this detail is already handled in here, you might notice it starts with a call to to_native_namespace

We can abstract the body of this

I guess we can proceed with one of the two following options:

Revert to backend specific import functions, but add version validation
Restrict import_optional_dependency to the backends we have, to deal with case by case if needed

in this way we could be able to re-use the above mentioned functions/methods

narwhals/_utils.py

FBruzzesi · 2025-06-07T16:56:18Z

@dangotbanned I am quite happy with the state of this now. Let me know your thoughts whenever you have the time 🤞🏼

tests/dependencies/imports_test.py

dangotbanned

Hey @FBruzzesi sorry this one took a little longer than usual

dangotbanned · 2025-06-10T18:51:09Z

narwhals/_utils.py

+        from importlib.metadata import version

-            into_version = sqlframe._version
-        return parse_version(into_version)
+        distribution_name = _IMPLEMENTATION_TO_DISTRIBUTION_NAME.get(self, self.value)
+        return parse_version(version=version(distribution_name))


We might end up triggering this downstream issue again with importlib.metadata.version:

perf: Avoid module-level importlib.util.find_spec #2391 (comment)

No package metadata was found for typing_extensions on plotly import pyinstaller/pyinstaller-hooks-contrib#902 (comment)

pyinstaller/pyinstaller-hooks-contrib@18caba0

It does have a solution, but I guess we'd need to keep the metadata requirements in sync somehow?

I can revert to use __version__ attribute where applicable, _version for sqlframe, and from importlib.metadata import version only for ibis (I couldn't spot an attribute storing the library version)

As we discussed in the past, __version__ is not a standard, so not guaranteed

As we discussed in the past, __version__ is not a standard, so not guaranteed

Yeah that's a good point, personally I'd want use to be using importlib.metadata.version for that reason.
I wonder if the pyinstaller folks could collect metadata for all dependencies in our pyproject.toml?

It does seem a bit off to me that we'd need to do things in a non-standardized way for what I can only assume is a downstream perf optimization 🤔

The main "issue" is that it would require to import the module in the first place, which is somewhat a looping with to_native_namespace 🤔

An idea would be to move the following block into _backend_version:

if self is Implementation.UNKNOWN: msg = "Cannot return native namespace from UNKNOWN Implementation" raise AssertionError(msg) from importlib import import_module module_name = _IMPLEMENTATION_TO_MODULE_NAME.get(self, self.value) module = import_module(module_name)

and cache the module once loaded to be reused in to_native_namespace

@dangotbanned is from importlib import import_module ok to use?

and cache the module once loaded to be reused in to_native_namespace

I'm definitely in favor of adding some caching into the mix somewhere (#1657 (reply in thread)), we're checking backend_version waaaaaaay too many times for something that doesn't change.
But I think we can look at that in another issue.

and from importlib.metadata import version only for ibis (I couldn't spot an attribute storing the library version)

ibis seems to have always had a __version__?

ibis==1.0.0 https://github.com/ibis-project/ibis/blob/33201ac9cdbdafde0ae0dd99960657bc827f056a/ibis/__init__.py#L138

ibis==6.0.0 https://github.com/ibis-project/ibis/blob/97173935961231bac391943ba56ab499f4f9c2fe/ibis/__init__.py#L4

ibis==10.5.0 https://github.com/ibis-project/ibis/blob/cfa5768b6fb6020f712aadc842c9c35966e2acac/ibis/__init__.py#L5

@dangotbanned is from importlib import import_module ok to use?

Yeah should be - you'll get the same ModuleNotFoundError if it isn't installed

>>> import ibis2 --------------------------------------------------------------------------- ModuleNotFoundError Traceback (most recent call last) Cell In[32], line 1 ----> 1 import ibis2 ModuleNotFoundError: No module named 'ibis2'

from importlib import import_module >>> import_module("ibis2") --------------------------------------------------------------------------- ModuleNotFoundError Traceback (most recent call last) Cell In[31], line 3 1 from importlib import import_module ----> 3 import_module("ibis2") File ~\AppData\Roaming\uv\python\cpython-3.13.2-windows-x86_64-none\Lib\importlib\__init__.py:88, in import_module(name, package) 86 break 87 level += 1 ---> 88 return _bootstrap._gcd_import(name[level:], package, level) File <frozen importlib._bootstrap>:1387, in _gcd_import(name, package, level) File <frozen importlib._bootstrap>:1360, in _find_and_load(name, import_) File <frozen importlib._bootstrap>:1324, in _find_and_load_unlocked(name, import_) ModuleNotFoundError: No module named 'ibis2'

narwhals/_utils.py

dangotbanned · 2025-06-11T11:17:57Z

tests/dependencies/imports_test.py

+@pytest.mark.parametrize(
+    ("impl", "frame_constructor", "frame_type", "kwargs"),
+    [
+        (Implementation.CUDF, "DataFrame", "DataFrame", {}),
+        (Implementation.DASK, "from_dict", "DataFrame", {"npartitions": 1}),
+        (Implementation.MODIN, "DataFrame", "DataFrame", {}),
+        (Implementation.PANDAS, "DataFrame", "DataFrame", {}),
+        (Implementation.POLARS, "DataFrame", "DataFrame", {}),
+        (Implementation.PYARROW, "table", "Table", {}),
+    ],
+)
+def test_round_trip(
+    monkeypatch: pytest.MonkeyPatch,
+    impl: Implementation,
+    frame_constructor: str,
+    frame_type: str,
+    kwargs: dict[str, Any],
+) -> None:
+    module_name = impl.value
+    if not find_spec(module_name):
+        reason = f"{module_name} not installed"
+        pytest.skip(reason=reason)
+
+    if impl.is_pyarrow() or (sys.version_info >= (3, 10) and impl.is_pandas()):
+        # NOTE: Can't do `monkeypatch.delitem` safely for other implementations
+        monkeypatch.delitem(sys.modules, module_name)
+
+    module = impl.to_native_namespace()
+    df = getattr(module, frame_constructor)(data, **kwargs)
+    result = _roundtrip_query(df)
+
+    assert isinstance(result, getattr(module, frame_type))


In the previous tests, I forgot to add the step that I was eyballing in my IDE - but was actually the motivation for them 🤦‍♂️

Previous tests

narwhals/tests/dependencies/imports_test.py

Lines 30 to 73 in 214e15a

def test_import_polars(data: dict[str, Any]) -> None:

# NOTE: Can't do `monkeypatch.delitem` safely

# ImportError: PyO3 modules compiled for CPython 3.8 or older may only be initialized once per interpreter process

pytest.importorskip("polars")

df = dependencies.import_polars().DataFrame(data)

result = _roundtrip_query(df)

import polars as pl

assert isinstance(result, pl.DataFrame)

# NOTE: Don't understand this one

@pytest.mark.xfail(

reason="'dict' object has no attribute '_meta'.\n"

"dask/dataframe/dask_expr/_collection.py:609",

raises=AttributeError,

)

def test_import_dask(data: dict[str, Any]) -> None:

pytest.importorskip("dask")

df = dependencies.import_dask().DataFrame(data)

result = _roundtrip_query(df)

import dask.dataframe as dd

assert isinstance(result, dd.DataFrame)

def test_import_pandas(monkeypatch: pytest.MonkeyPatch, data: dict[str, Any]) -> None:

pytest.importorskip("pandas")

monkeypatch.delitem(sys.modules, "pandas")

df = dependencies.import_pandas().DataFrame(data)

result = _roundtrip_query(df)

import pandas as pd

assert isinstance(result, pd.DataFrame)

def test_import_pyarrow(monkeypatch: pytest.MonkeyPatch, data: dict[str, Any]) -> None:

pytest.importorskip("pyarrow")

monkeypatch.delitem(sys.modules, "pyarrow")

df = dependencies.import_pyarrow().table(data)

result = _roundtrip_query(df)

import pyarrow as pa

assert isinstance(result, pa.Table)

If we used polars as an example, I was trying to make sure the typing survived a roundtrip.

I could see that out on hover, but the test should've been:

def test_import_polars(data: dict[str, Any]) -> None: pytest.importorskip("polars") df = dependencies.import_polars().DataFrame(data) result = _roundtrip_query(df) import polars as pl if TYPE_CHECKING: from typing_extensions import assert_type assert_type(result, pl.DataFrame) assert isinstance(result, pl.DataFrame)

That style is what I wrote in the ...

Namespace tests

narwhals/tests/namespace_test.py

Lines 120 to 132 in e831be1

def test_namespace_from_numpy_polars() -> None:

pytest.importorskip("polars")

pytest.importorskip("numpy")

import numpy as np

import polars as pl

arr: _2DArray = cast("_2DArray", np.array([[5, 2, 0, 1], [1, 4, 7, 8], [1, 2, 3, 9]]))

columns = "a", "b", "c"

frame = Namespace.from_backend("polars").compliant.from_numpy(arr, columns).native

if TYPE_CHECKING:

assert_type(frame, pl.DataFrame)

assert isinstance(frame, pl.DataFrame)

Since the PR doesn't have typing anymore, I'm not sure the test makes much sense as we're effectively just checking:

Does find_spec work?

Can we construct a dataframe via import_module?

Once we have a dataframe, can we use from_native and to_native?

I think the other tests you've added give us the coverage for the new behavior

So you would you be ok with just leave the tests test_to_native_namespace and test_to_native_namespace_unknown?

Yeah as long as they're all we need for coverage

narwhals/_utils.py

FBruzzesi · 2025-06-11T20:46:31Z

What's up with pyarrow nightly 🥲

dangotbanned · 2025-06-11T20:51:18Z

What's up with pyarrow nightly 🥲

Same!

I'm seeing that recently in #2572 as well

dangotbanned · 2025-06-12T15:29:33Z

narwhals/_utils.py

+
+        As a biproduct of loading the native namespace, we also store it as an attribute
+        under the `_native_namespace` name.
+        """
+        if self is Implementation.UNKNOWN:  # pragma: no cover
+            msg = "Cannot return backend version from UNKNOWN Implementation"
+            raise AssertionError(msg)
+
+        from importlib import import_module
+
+        module_name = _IMPLEMENTATION_TO_MODULE_NAME.get(self, self.value)
+        self._native_namespace = import_module(module_name)


I don't think we need to store modules on enums (or any state for that matter)

To be super clear, my comment in (#2620 (comment)) was meant to mean let's defer caching to another issue.

I was just about to merge and was pretty surprised to see this added in a commit titled rollback _backend_verson.

If we need to add caching of module loading, I would much prefer to just lift the _LazyModule stuff from polars - since that has typing support built in (https://github.com/pola-rs/polars/blob/7cb263a6dc4e3a1893b6ad4af963733c83268b60/py-polars/polars/dependencies.py)

This was to avoid repeating the exact same imports to check the backend version and return the module.

I am a bit in a rush but I just made a commit to factor out and cache in a helper function.

FBruzzesi added 2 commits May 26, 2025 22:18

refactor: Simplify Implementation.to_native_namespace

86a0ead

refactor: Simplify Implementation.to_native_namespace

e57264b

FBruzzesi added internal spark-like labels May 26, 2025

help mypy

aeb1bfc

move dict creation on top to avoid instantiating each time

f290e77

dangotbanned added 2 commits May 29, 2025 21:21

Merge remote-tracking branch 'upstream/main' into refactor/simplify-t…

a1416ff

…o-native-namespace

feat: Add import_<backend> functions

d05d799

See - #2620 (comment) - #1940

dangotbanned reviewed May 30, 2025

View reviewed changes

narwhals/dependencies.py Outdated Show resolved Hide resolved

dangotbanned added 9 commits May 30, 2025 12:37

test: Add imports_test

214e15a

Sibling to `no_imports_test`

fix(typing): Resolve mypy [no-untyped-call]

1858177

All usage had these: > error: Call to untyped function "import_pyarrow" in typed context [no-untyped-call]

fix: Include a message 🤦‍♂️

6b08806

fix: Be more cautious on import paths

212f78f

Turns out `find_spec` raises if the parent is missing

ci: Somewhat reduce the cov?

35b1e2b

test: Don't monkeypatch pandas on 3.8

fedf02e

https://github.com/narwhals-dev/narwhals/actions/runs/15346258379/job/43183041793?pr=2620

test: Use dd.from_dict constructor

570b998

cov

072229c

https://github.com/narwhals-dev/narwhals/actions/runs/15346258379/job/43183041793?pr=2620

test: Remove dask monkeypatching

68b9108

dangotbanned marked this pull request as ready for review May 31, 2025 16:26

FBruzzesi and others added 8 commits June 2, 2025 17:28

Merge branch 'main' into refactor/simplify-to-native-namespace

6949a06

Merge branch 'main' into refactor/simplify-to-native-namespace

bc699d6

Merge branch 'main' into refactor/simplify-to-native-namespace

3dc0845

fix(typing): Use a private module 🤯

ab7161f

ci: Document with config

df15bc5

Merge branch 'main' into refactor/simplify-to-native-namespace

3b3fae4

ci: Update import_check

6fa12b4

https://results.pre-commit.ci/run/github/760058710/1748960804.iLKqUy8zStajYHSWCO0d3Q

Merge branch 'refactor/simplify-to-native-namespace' of https://githu…

21cc24e

…b.com/narwhals-dev/narwhals into refactor/simplify-to-native-namespace

Merge branch 'refactor/simplify-to-native-namespace' of https://githu…

bf47870

…b.com/narwhals-dev/narwhals into refactor/simplify-to-native-namespace

Implement and use import_optional_dependency

96540c3

FBruzzesi commented Jun 6, 2025

View reviewed changes

narwhals/utils.py Outdated Show resolved Hide resolved

refactor

08fdb43

FBruzzesi commented Jun 7, 2025

View reviewed changes

narwhals/_utils.py Show resolved Hide resolved

FBruzzesi added 2 commits June 7, 2025 18:50

simplify

703bf2d

rm unnecessary changes

471bd70

FBruzzesi added 2 commits June 7, 2025 19:39

Merge branch 'main' into refactor/simplify-to-native-namespace

b2660ba

tests

311cc31

FBruzzesi commented Jun 8, 2025

View reviewed changes

tests/dependencies/imports_test.py Outdated Show resolved Hide resolved

FBruzzesi added 3 commits June 8, 2025 14:17

refactor round trip test

5a82c9e

del sys.modules where applicable

3b09145

delitem only pandas and pyarrow

16587e8

FBruzzesi requested a review from dangotbanned June 8, 2025 16:42

Merge branch 'main' into refactor/simplify-to-native-namespace

6f075a1

dangotbanned reviewed Jun 11, 2025

View reviewed changes

FBruzzesi and others added 3 commits June 11, 2025 14:24

Merge branch 'main' into refactor/simplify-to-native-namespace

c965f6c

rollback _backend_verson

a847650

Merge branch 'main' into refactor/simplify-to-native-namespace

e73c96c

dangotbanned changed the title ~~refactor: Simplify Implementation.to_native_namspace~~ refactor: Simplify Implementation.to_native_namespace Jun 12, 2025

Merge branch 'main' into refactor/simplify-to-native-namespace

03a5b8b

dangotbanned reviewed Jun 12, 2025

View reviewed changes

factor out via _import_native_namespace

c498366

	def test_import_polars(data: dict[str, Any]) -> None:
	# NOTE: Can't do `monkeypatch.delitem` safely
	# ImportError: PyO3 modules compiled for CPython 3.8 or older may only be initialized once per interpreter process
	pytest.importorskip("polars")
	df = dependencies.import_polars().DataFrame(data)
	result = _roundtrip_query(df)
	import polars as pl

	assert isinstance(result, pl.DataFrame)


	# NOTE: Don't understand this one
	@pytest.mark.xfail(
	reason="'dict' object has no attribute '_meta'.\n"
	"dask/dataframe/dask_expr/_collection.py:609",
	raises=AttributeError,
	)
	def test_import_dask(data: dict[str, Any]) -> None:
	pytest.importorskip("dask")
	df = dependencies.import_dask().DataFrame(data)
	result = _roundtrip_query(df)
	import dask.dataframe as dd

	assert isinstance(result, dd.DataFrame)


	def test_import_pandas(monkeypatch: pytest.MonkeyPatch, data: dict[str, Any]) -> None:
	pytest.importorskip("pandas")
	monkeypatch.delitem(sys.modules, "pandas")
	df = dependencies.import_pandas().DataFrame(data)
	result = _roundtrip_query(df)
	import pandas as pd

	assert isinstance(result, pd.DataFrame)


	def test_import_pyarrow(monkeypatch: pytest.MonkeyPatch, data: dict[str, Any]) -> None:
	pytest.importorskip("pyarrow")
	monkeypatch.delitem(sys.modules, "pyarrow")
	df = dependencies.import_pyarrow().table(data)
	result = _roundtrip_query(df)
	import pyarrow as pa

	assert isinstance(result, pa.Table)

	def test_namespace_from_numpy_polars() -> None:
	pytest.importorskip("polars")
	pytest.importorskip("numpy")
	import numpy as np
	import polars as pl

	arr: _2DArray = cast("_2DArray", np.array([[5, 2, 0, 1], [1, 4, 7, 8], [1, 2, 3, 9]]))
	columns = "a", "b", "c"
	frame = Namespace.from_backend("polars").compliant.from_numpy(arr, columns).native
	if TYPE_CHECKING:
	assert_type(frame, pl.DataFrame)

	assert isinstance(frame, pl.DataFrame)

refactor: Simplify Implementation.to_native_namespace #2620

Are you sure you want to change the base?

refactor: Simplify Implementation.to_native_namespace #2620

Uh oh!

Conversation

FBruzzesi commented May 26, 2025 • edited by dangotbanned Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

What type of PR is this? (check all applicable)

Related issues

Checklist

If you have comments or can explain your changes, please do so below

Uh oh!

dangotbanned commented May 26, 2025

Uh oh!

FBruzzesi commented May 26, 2025

Uh oh!

dangotbanned commented May 26, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

dangotbanned commented Jun 6, 2025

Uh oh!

Uh oh!

FBruzzesi commented Jun 6, 2025

Uh oh!

dangotbanned commented Jun 7, 2025

This PR

importlib

__version__

Minimum versions (generally)

Uh oh!

FBruzzesi commented Jun 7, 2025

Uh oh!

Uh oh!

FBruzzesi commented Jun 7, 2025

Uh oh!

Uh oh!

dangotbanned left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

dangotbanned Jun 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

FBruzzesi commented Jun 11, 2025

Uh oh!

dangotbanned commented Jun 11, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

refactor: Simplify `Implementation.to_native_namespace` #2620

refactor: Simplify `Implementation.to_native_namespace` #2620

FBruzzesi commented May 26, 2025 •

edited by dangotbanned

Loading

dangotbanned commented May 26, 2025 •

edited

Loading

`importlib`

`version`

dangotbanned Jun 11, 2025 •

edited

Loading