Fix single-file treat-dot-as-module (#2603)

* Fix: Implement handling for treating dots as module in single file

* Fix: Add tests for to_hashable function and postprocessing of module results

* Fix: Add test for postprocessing of single element without dot in module results

* Fix: Update condition for max_passes to improve code clarity

Author: koxudaxi

src/datamodel_code_generator/parser/base.py

@@ -98,7 +98,7 @@ def get_special_path(keyword: str, path: list[str]) -> list[str]:
 })
 
 
-def to_hashable(item: Any) -> HashableComparable:
+def to_hashable(item: Any) -> HashableComparable:  # noqa: PLR0911
     """Convert an item to a hashable and comparable representation.
 
     Returns a value that is both hashable and supports comparison operators.
@@ -111,7 +111,11 @@ def to_hashable(item: Any) -> HashableComparable:
             tuple,
         ),
     ):
-        return tuple(sorted(to_hashable(i) for i in item))
+        try:
+            return tuple(sorted((to_hashable(i) for i in item), key=lambda v: (str(type(v)), v)))
+        except TypeError:
+            # Fallback when mixed, non-comparable types are present; preserve original order
+            return tuple(to_hashable(i) for i in item)
     if isinstance(item, dict):
         return tuple(
             sorted(
@@ -669,7 +673,7 @@ def _get_text_from_url(self, url: str) -> str:
 
         return self.remote_text_cache.get_or_put(
             url,
-            default_factory=lambda url_: get_body(  # noqa: ARG005
+            default_factory=lambda _url: get_body(
                 url, self.http_headers, self.http_ignore_tls, self.http_query_parameters
             ),
         )
@@ -974,9 +978,9 @@ def check_paths(
                                 alias=alias,
                             )
                         )
-                    has_imported_literal = any(import_ == IMPORT_LITERAL for import_ in imports)
-                    if has_imported_literal:  # pragma: no cover
-                        imports.append(IMPORT_LITERAL)
+            has_imported_literal = any(import_ == IMPORT_LITERAL for import_ in imports)
+            if has_imported_literal:  # pragma: no cover
+                imports.append(IMPORT_LITERAL)
 
     @classmethod
     def _create_set_from_list(cls, data_type: DataType) -> DataType | None:
@@ -1406,6 +1410,7 @@ def __sort_models(
             model_class_name_refs[model] = (class_name, refs)
 
         changed: bool = True
+        max_passes = len(models) * len(models) if models else 0
         while changed:
             changed = False
             resolved = imported.copy()
@@ -1417,6 +1422,10 @@ def __sort_models(
                     continue
                 models[i], models[i + 1] = models[i + 1], model
                 changed = True
+            if max_passes:  # pragma: no branch
+                max_passes -= 1
+                if max_passes <= 0:  # pragma: no cover
+                    break
 
     def __change_field_name(
         self,
@@ -1490,7 +1499,8 @@ def process(input_tuple: tuple[str, ...]) -> tuple[str, ...]:
                 else:
                     r.append(item)
 
-            r = [*r[:-2], f"{r[-2]}.{r[-1]}"]
+            if len(r) >= 2:  # noqa: PLR2004
+                r = [*r[:-2], f"{r[-2]}.{r[-1]}"]
             return tuple(r)
 
         results = {process(k): v for k, v in results.items()}

tests/data/expected/main/jsonschema/treat_dot_as_module_single/__init__.py

@@ -0,0 +1,3 @@
+# generated by datamodel-codegen:
+#   filename:  treat_dot_as_module_single
+#   timestamp: 2019-07-26T00:00:00+00:00

tests/data/expected/main/jsonschema/treat_dot_as_module_single/model/__init__.py

@@ -0,0 +1,3 @@
+# generated by datamodel-codegen:
+#   filename:  treat_dot_as_module_single
+#   timestamp: 2019-07-26T00:00:00+00:00

tests/data/expected/main/jsonschema/treat_dot_as_module_single/model/schema.py

@@ -0,0 +1,14 @@
+# generated by datamodel-codegen:
+#   filename:  model.schema.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class User(BaseModel):
+    name: str
+    age: Optional[int] = None

tests/data/jsonschema/treat_dot_as_module_single/model.schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "User",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "age": {
+      "type": "integer"
+    }
+  },
+  "required": ["name"]
+}

tests/main/jsonschema/test_main_jsonschema.py

@@ -1808,6 +1808,16 @@ def test_treat_dot_as_module(as_module: bool, output_dir: Path) -> None:
     )
 
 
+def test_treat_dot_as_module_single_file(output_dir: Path) -> None:
+    """Test treat-dot-as-module with single file having short path."""
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "treat_dot_as_module_single",
+        output_path=output_dir,
+        expected_directory=EXPECTED_JSON_SCHEMA_PATH / "treat_dot_as_module_single",
+        extra_args=["--treat-dot-as-module"],
+    )
+
+
 def test_main_jsonschema_duplicate_name(output_dir: Path) -> None:
     """Test duplicate name handling."""
     run_main_and_assert(

tests/parser/test_base.py

@@ -17,6 +17,7 @@
     exact_import,
     relative,
     sort_data_models,
+    to_hashable,
 )
 from datamodel_code_generator.reference import Reference, snake_to_upper_camel
 from datamodel_code_generator.types import DataType
@@ -512,3 +513,75 @@ def test_use_non_positive_negative_number_constrained_types(flag: bool) -> None:
     instance = C(source="", use_non_positive_negative_number_constrained_types=flag)
 
     assert instance.data_type_manager.use_non_positive_negative_number_constrained_types == flag
+
+
+def test_to_hashable_simple_values() -> None:
+    """Test to_hashable with simple values."""
+    assert to_hashable("string") == "string"
+    assert to_hashable(123) == 123
+    assert to_hashable(None) == ""  # noqa: PLC1901
+
+
+def test_to_hashable_list_and_tuple() -> None:
+    """Test to_hashable with list and tuple."""
+    result = to_hashable([3, 1, 2])
+    assert isinstance(result, tuple)
+    assert result == (1, 2, 3)  # sorted
+
+    result = to_hashable((3, 1, 2))
+    assert isinstance(result, tuple)
+    assert result == (1, 2, 3)  # sorted
+
+
+def test_to_hashable_dict() -> None:
+    """Test to_hashable with dict."""
+    result = to_hashable({"b": 2, "a": 1})
+    assert isinstance(result, tuple)
+    # sorted by key
+    assert result == (("a", 1), ("b", 2))
+
+
+def test_to_hashable_mixed_types_fallback() -> None:
+    """Test to_hashable with mixed types that cannot be compared."""
+    mixed_list = [complex(1, 2), complex(3, 4)]
+    result = to_hashable(mixed_list)
+    assert isinstance(result, tuple)
+    # Should preserve order since sorting fails
+    assert result == (complex(1, 2), complex(3, 4))
+
+
+def test_to_hashable_nested_structures() -> None:
+    """Test to_hashable with nested structures."""
+    nested = {"outer": [{"inner": 1}]}
+    result = to_hashable(nested)
+    assert isinstance(result, tuple)
+
+
+def test_postprocess_result_modules_single_element_tuple() -> None:
+    """Test postprocessing with single element tuple (len < 2)."""
+    input_data = {
+        ("__init__.py",): "init_content",
+    }
+    result = Parser._Parser__postprocess_result_modules(input_data)
+    # Single element tuple should remain unchanged
+    assert ("__init__.py",) in result
+
+
+def test_postprocess_result_modules_single_file_no_dot() -> None:
+    """Test postprocessing with single file without dot in name."""
+    input_data = {
+        ("module.py",): "content",
+        ("__init__.py",): "init_content",
+    }
+    result = Parser._Parser__postprocess_result_modules(input_data)
+    assert ("module.py",) in result
+
+
+def test_postprocess_result_modules_single_element_no_dot() -> None:
+    """Test postprocessing with single element without dot (len(r) < 2 branch)."""
+    input_data = {
+        ("__init__.py",): "init_content",
+        ("file",): "content",  # Single element without dot, so len(r) = 1
+    }
+    result = Parser._Parser__postprocess_result_modules(input_data)
+    assert ("file",) in result