better handling of circular references

Author: giograno

src/py_avro_schema/_schemas.py

@@ -1190,7 +1190,7 @@ def handles_type(cls, py_type: Type) -> bool:
             # If we are subclassing a string, used the "named string" approach
             and (inspect.isclass(py_type) and not issubclass(py_type, str))
             # and any other class with typed annotations
-            and bool(get_type_hints(py_type))
+            and has_type_hints(py_type)
         )
 
     def __init__(self, py_type: Type, namespace: Optional[str] = None, options: Option = Option(0)):
@@ -1345,3 +1345,15 @@ def _type_from_annotated(py_type: Type) -> Type:
         return args[0]
     else:
         return py_type
+
+
+def has_type_hints(py_type: Type) -> bool:
+    """
+    Checks if a type has annotations. ``get_type_hints`` might fail if there are forward references.
+    """
+    py_type = _type_from_annotated(py_type)
+    try:
+        return bool(get_type_hints(py_type))
+    except Exception:
+        pass
+    return hasattr(py_type, "__annotations__")

tests/test_plain_class.py

@@ -10,7 +10,7 @@
 # specific language governing permissions and limitations under the License.
 
 import re
-from typing import Annotated, Final
+from typing import Annotated, Final, ForwardRef
 
 import pytest
 
@@ -179,3 +179,28 @@ def __init__(self):
     }
 
     assert_schema(PyType, expected)
+
+
+def test_circular_dependencies():
+    class PyType:
+        backend: ForwardRef("Backend")
+        value: str
+
+    class Backend:
+        py_type: PyType
+
+    expected = {
+        "fields": [
+            {
+                "name": "py_type",
+                "type": {
+                    "fields": [{"name": "backend", "type": "Backend"}, {"name": "value", "type": "string"}],
+                    "name": "PyType",
+                    "type": "record",
+                },
+            }
+        ],
+        "name": "Backend",
+        "type": "record",
+    }
+    assert_schema(Backend, expected)