enabled ufuncs for external classes

changes/898.feat.rst

@@ -0,0 +1,21 @@
+Enabled implicit conversion of unknown objects
+
+Now users can automatically convert unknown objects
+and use them directly in `sisl` methods that are
+implemented for various methods.
+
+E.g.
+
+.. code::
+
+   import ase
+   import sisl
+
+   gr = sisl.geom.graphene()
+   sisl.rotate(gr, ...)
+
+   gr = ase.Atoms(...)
+   sisl.rotate(gr, ...)
+
+will both work. The latter will return a sisl
+geometry.

src/sisl/_core/tests/test_geometry.py

@@ -8,6 +8,7 @@
 import numpy as np
 import pytest
 
+import sisl as si
 import sisl.geom as sisl_geom
 from sisl import (
     Atom,
@@ -1561,6 +1562,16 @@
 
     # Test ASE (but only fail if present)
 
+    def test_geometry_dispatch(self):
+        pytest.importorskip("ase", reason="ase not available")
+        gr = sisl_geom.graphene()
+        to_ase = gr.to.ase()
+
+        ase_rotate = si.rotate(to_ase, 30, [0, 0, 1])
+        geom_rotate = si.rotate(gr, 30, [0, 0, 1])
+
+        assert geom_rotate.equal(ase_rotate, R=False)
+
     def test_geometry_ase_new_to(self):
         pytest.importorskip("ase", reason="ase not available")
         gr = sisl_geom.graphene()

src/sisl/_ufuncs.py

@@ -6,7 +6,7 @@
 import inspect
 from functools import singledispatch
 from textwrap import dedent
-from typing import Optional
+from typing import Any, Optional
 
 from sisl._lib._docscrape import FunctionDoc
 from sisl.messages import SislError, warn
@@ -142,9 +142,46 @@ def deco(method: FuncType):
             # create a new method that will be stored
             # as a place-holder for the dispatch methods.
 
-            def method_registry(obj, *args, **kwargs):
+            # The default method needs access to it-self.
+            # In this way we can figure out if there are
+            # some mechanism by which we can recover
+            # a meaningful action.
+            # I.e. this small hack will allow one to do this:
+            #  @register_sisl_dispatch(Geometry)
+            #  def func(geometry: Geometry, ...)
+            #
+            #  from ase import Atoms
+            #  func(Atoms(...), ...)
+            #
+            # The reason is that func won't find any registered
+            # classes under Atoms, and so it will run through
+            # the registered classes, trying out `cls.new` for each
+            # of them. And then re-call the function it self.
+
+            def method_registry(obj: Any, *args, **kwargs):
+                nonlocal name, method_registry
+
+                # Obviously, the method has been called without finding the
+                # correct dispatch method.
+                for cls, cls_func in method_registry.registry.items():
+
+                    # Try and get the conversion method
+                    # Currently we'll only use `new` for consistency
+                    # I don't know if this will work for other
+                    # keys as well...
+                    new = getattr(cls, "new", None)
+
+                    if new is not None:
+                        try:
+                            # Try and convert to a sisl-compatible object
+                            obj = cls.new(obj)
+                            return cls_func(obj, *args, **kwargs)
+                        except KeyError:
+                            pass
+
                 raise SislError(
-                    f"Calling '{name}' with a non-registered type, {type(obj)} has not been registered."
+                    f"Calling '{name}' with a non-registered type, {type(obj)} has not "
+                    "been registered, and cannot be converted to a sisl type."
                 )
 
             doc = dedent(