Add 'pydantic_v1' and 'pydantic_v2' submodules, these serve as safe namespaces for the relevant objects/metadata available for each pydantic version

Author: phillipdupuis

pydantic2ts/cli/script.py

@@ -23,24 +23,8 @@
 )
 from uuid import uuid4
 
-try:
-    from pydantic import BaseModel as BaseModelV2
-    from pydantic import create_model as create_model_v2
-    from pydantic.v1 import BaseModel as BaseModelV1
-    from pydantic.v1 import create_model as create_model_v1
-except ImportError:
-    BaseModelV2 = None
-    create_model_v2 = None
-    from pydantic import BaseModel as BaseModelV1
-    from pydantic import create_model as create_model_v1
-
-try:
-    from pydantic.v1.generics import GenericModel as GenericModelV1
-except ImportError:
-    try:
-        from pydantic.generics import GenericModel as GenericModelV1
-    except ImportError:
-        GenericModelV1 = None
+import pydantic2ts.pydantic_v1 as v1
+import pydantic2ts.pydantic_v2 as v2
 
 if TYPE_CHECKING:
     from pydantic.config import ConfigDict
@@ -63,12 +47,10 @@ def _import_module(path: str) -> ModuleType:
         if os.path.exists(path):
             name = uuid4().hex
             spec = spec_from_file_location(name, path, submodule_search_locations=[])
-            if spec is None:
-                raise ImportError(f"spec_from_file_location failed for {path}")
+            assert spec is not None, f"spec_from_file_location failed for {path}"
             module = module_from_spec(spec)
             sys.modules[name] = module
-            if spec.loader is None:
-                raise ImportError(f"loader is None for {path}")
+            assert spec.loader is not None, f"loader is None for {path}"
             spec.loader.exec_module(module)
             return module
         else:
@@ -87,40 +69,45 @@ def _is_submodule(obj: Any, module_name: str) -> bool:
     return inspect.ismodule(obj) and getattr(obj, "__name__", "").startswith(f"{module_name}.")
 
 
-def _is_pydantic_v1_model(obj: Any) -> bool:
+def _is_v1_model(obj: Any) -> bool:
     """
-    Return true if the object is a 'concrete' pydantic V1 model.
+    Return true if an object is a 'concrete' pydantic V1 model.
     """
     if not inspect.isclass(obj):
         return False
-    elif obj is BaseModelV1 or obj is GenericModelV1:
+    elif obj is v1.BaseModel:
         return False
-    elif GenericModelV1 and issubclass(obj, GenericModelV1):
-        return getattr(obj, "__concrete__", False)
-    return issubclass(obj, BaseModelV1)
+    elif v1.GenericModel and issubclass(obj, v1.GenericModel):
+        return bool(obj.__concrete__)
+    else:
+        return issubclass(obj, v1.BaseModel)
 
 
-def _is_pydantic_v2_model(obj: Any) -> bool:
+def _is_v2_model(obj: Any) -> bool:
     """
     Return true if an object is a 'concrete' pydantic V2 model.
     """
-    if not inspect.isclass(obj):
+    if not v2.enabled:
         return False
-    elif obj is BaseModelV2 or BaseModelV2 is None:
+    elif not inspect.isclass(obj):
         return False
-    return issubclass(obj, BaseModelV2) and not getattr(
-        obj, "__pydantic_generic_metadata__", {}
-    ).get("parameters")
+    elif obj is v2.BaseModel:
+        return False
+    elif not issubclass(obj, v2.BaseModel):
+        return False
+    generic_metadata = getattr(obj, "__pydantic_generic_metadata__", {})
+    generic_parameters = generic_metadata.get("parameters")
+    return not generic_parameters
 
 
 def _is_pydantic_model(obj: Any) -> bool:
     """
-    Return true if an object is a valid model for either V1 or V2 of pydantic.
+    Return true if an object is a concrete model for either V1 or V2 of pydantic.
     """
-    return _is_pydantic_v1_model(obj) or _is_pydantic_v2_model(obj)
+    return _is_v1_model(obj) or _is_v2_model(obj)
 
 
-def _has_null_variant(schema: Dict[str, Any]) -> bool:
+def _is_nullable(schema: Dict[str, Any]) -> bool:
     """
     Return true if a JSON schema has 'null' as one of its types.
     """
@@ -129,7 +116,7 @@ def _has_null_variant(schema: Dict[str, Any]) -> bool:
     if isinstance(schema.get("type"), list) and "null" in schema["type"]:
         return True
     if isinstance(schema.get("anyOf"), list):
-        return any(_has_null_variant(s) for s in schema["anyOf"])
+        return any(_is_nullable(s) for s in schema["anyOf"])
     return False
 
 
@@ -139,15 +126,15 @@ def _get_model_config(model: Type[Any]) -> "Union[ConfigDict, Type[BaseConfig]]"
     In version 1 of pydantic, this is a class. In version 2, it's a dictionary.
     """
     if hasattr(model, "Config") and inspect.isclass(model.Config):
-        return model.Config  # type: ignore
+        return model.Config
     return model.model_config
 
 
 def _get_model_json_schema(model: Type[Any]) -> Dict[str, Any]:
     """
     Generate the JSON schema for a pydantic model.
     """
-    if _is_pydantic_v1_model(model):
+    if _is_v1_model(model):
         return json.loads(model.schema_json())
     return model.model_json_schema(mode="serialization")
 
@@ -188,7 +175,7 @@ def _clean_json_schema(schema: Dict[str, Any], model: Any = None) -> None:
     for prop in properties.values():
         prop.pop("title", None)
 
-    if _is_pydantic_v1_model(model):
+    if _is_v1_model(model):
         fields: List["ModelField"] = list(model.__fields__.values())
         for field in fields:
             try:
@@ -198,7 +185,7 @@ def _clean_json_schema(schema: Dict[str, Any], model: Any = None) -> None:
                 prop = properties.get(name)
                 if prop is None:
                     continue
-                if _has_null_variant(prop):
+                if _is_nullable(prop):
                     continue
                 properties[name] = {"anyOf": [prop, {"type": "null"}]}
             except Exception:
@@ -254,8 +241,6 @@ def _schema_generation_overrides(
     Temporarily override the 'extra' setting for a model,
     changing it to 'forbid' unless it was EXPLICITLY set to 'allow'.
     This prevents '[k: string]: any' from automatically being added to every interface.
-
-    TODO: check if overriding 'schema_extra' is necessary, or if there's a better way.
     """
     revert: Dict[str, Any] = {}
     config = _get_model_config(model)
@@ -264,14 +249,10 @@ def _schema_generation_overrides(
             if config.get("extra") != "allow":
                 revert["extra"] = config.get("extra")
                 config["extra"] = "forbid"
-            revert["json_schema_extra"] = config.get("json_schema_extra")
-            config["json_schema_extra"] = staticmethod(_clean_json_schema)
         else:
             if config.extra != "allow":
                 revert["extra"] = config.extra
                 config.extra = "forbid"  # type: ignore
-            revert["schema_extra"] = config.schema_extra
-            config.schema_extra = staticmethod(_clean_json_schema)  # type: ignore
         yield
     finally:
         for key, value in revert.items():
@@ -297,8 +278,8 @@ def _generate_json_schema(models: List[type]) -> str:
             models_by_name[name] = model
             models_as_fields[name] = (model, ...)
 
-        use_v1_tools = any(issubclass(m, BaseModelV1) for m in models)
-        create_model = create_model_v1 if use_v1_tools else create_model_v2  # type: ignore
+        use_v1_tools = any(issubclass(m, v1.BaseModel) for m in models)
+        create_model = v1.create_model if use_v1_tools else v2.create_model  # type: ignore
         master_model = create_model("_Master_", **models_as_fields)  # type: ignore
         master_schema = _get_model_json_schema(master_model)  # type: ignore
 
@@ -320,11 +301,14 @@ def generate_typescript_defs(
     """
     Convert the pydantic models in a python module into typescript interfaces.
 
-    :param module: python module containing pydantic model definitions, ex: my_project.api.schemas
+    :param module: python module containing pydantic model definitions.
+                   example: my_project.api.schemas
     :param output: file that the typescript definitions will be written to
-    :param exclude: optional, a tuple of names for pydantic models which should be omitted from the typescript output.
-    :param json2ts_cmd: optional, the command that will execute json2ts. Provide this if the executable is not
-                        discoverable or if it's locally installed (ex: 'yarn json2ts').
+    :param exclude: optional, a tuple of names for pydantic models which
+                    should be omitted from the typescript output.
+    :param json2ts_cmd: optional, the command that will execute json2ts.
+                        Provide this if the executable is not discoverable
+                        or if it's locally installed (ex: 'yarn json2ts').
     """
     if " " not in json2ts_cmd and not shutil.which(json2ts_cmd):
         raise Exception(

pydantic2ts/pydantic_v1.py

@@ -0,0 +1,16 @@
+try:
+    from pydantic.v1 import BaseModel, create_model
+    from pydantic.v1.generics import GenericModel
+
+    enabled = True
+except ImportError:
+    from pydantic import BaseModel, create_model
+
+    enabled = True
+
+    try:
+        from pydantic.generics import GenericModel
+    except ImportError:
+        GenericModel = None
+
+__all__ = ("BaseModel", "GenericModel", "create_model", "enabled")

pydantic2ts/pydantic_v2.py

@@ -0,0 +1,14 @@
+try:
+    from pydantic.version import VERSION
+
+    assert VERSION.startswith("2")
+
+    from pydantic import BaseModel, create_model
+
+    enabled = True
+except (ImportError, AssertionError, AttributeError):
+    BaseModel = None
+    create_model = None
+    enabled = False
+
+__all__ = ("BaseModel", "create_model", "enabled")

tests/test_script.py

@@ -2,49 +2,43 @@
 import subprocess
 from itertools import product
 from pathlib import Path
+from typing import Optional, Tuple
 
 import pytest
 
 from pydantic2ts import generate_typescript_defs
 from pydantic2ts.cli.script import parse_cli_args
+from pydantic2ts.pydantic_v2 import enabled as v2_enabled
 
-try:
-    from pydantic import BaseModel
-    from pydantic.v1 import BaseModel as BaseModelV1
-
-    assert BaseModel is not BaseModelV1
-    _PYDANTIC_VERSIONS = ("v1", "v2")
-except (ImportError, AssertionError):
-    _PYDANTIC_VERSIONS = ("v1",)
-
+_PYDANTIC_VERSIONS = ("v1", "v2") if v2_enabled else ("v1",)
 _RESULTS_DIRECTORY = Path(
     os.path.join(os.path.dirname(os.path.realpath(__file__)), "expected_results")
 )
 
 
-def _get_input_module(test_name: str, pydantic_version: str) -> Path:
-    return _RESULTS_DIRECTORY / test_name / pydantic_version / "input.py"
+def _get_input_module(test_name: str, pydantic_version: str) -> str:
+    return str(_RESULTS_DIRECTORY / test_name / pydantic_version / "input.py")
 
 
 def _get_expected_output(test_name: str, pydantic_version: str) -> str:
     return (_RESULTS_DIRECTORY / test_name / pydantic_version / "output.ts").read_text()
 
 
 def _run_test(
-    tmpdir,
-    test_name,
-    pydantic_version,
+    tmp_path: Path,
+    test_name: str,
+    pydantic_version: str,
     *,
-    module_path=None,
-    call_from_python=False,
-    exclude=(),
+    module_path: Optional[str] = None,
+    call_from_python: bool = False,
+    exclude: Tuple[str, ...] = (),
 ):
     """
     Execute pydantic2ts logic for converting pydantic models into tyepscript definitions.
     Compare the output with the expected output, verifying it is identical.
     """
     module_path = module_path or _get_input_module(test_name, pydantic_version)
-    output_path = tmpdir.join(f"cli_{test_name}_{pydantic_version}.ts").strpath
+    output_path = str(tmp_path / f"{test_name}_{pydantic_version}.ts")
 
     if call_from_python:
         generate_typescript_defs(module_path, output_path, exclude)
@@ -61,33 +55,33 @@ def _run_test(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_single_module(tmpdir, pydantic_version, call_from_python):
-    _run_test(tmpdir, "single_module", pydantic_version, call_from_python=call_from_python)
+def test_single_module(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+    _run_test(tmp_path, "single_module", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_submodules(tmpdir, pydantic_version, call_from_python):
-    _run_test(tmpdir, "submodules", pydantic_version, call_from_python=call_from_python)
+def test_submodules(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+    _run_test(tmp_path, "submodules", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_generics(tmpdir, pydantic_version, call_from_python):
-    _run_test(tmpdir, "generics", pydantic_version, call_from_python=call_from_python)
+def test_generics(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+    _run_test(tmp_path, "generics", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_excluding_models(tmpdir, pydantic_version, call_from_python):
+def test_excluding_models(tmp_path: Path, pydantic_version: str, call_from_python: bool):
     _run_test(
-        tmpdir,
+        tmp_path,
         "excluding_models",
         pydantic_version,
         call_from_python=call_from_python,
@@ -97,39 +91,37 @@ def test_excluding_models(tmpdir, pydantic_version, call_from_python):
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
-    product(_PYDANTIC_VERSIONS, [False, True]),
+    product([v for v in _PYDANTIC_VERSIONS if v != "v1"], [False, True]),
 )
-def test_computed_fields(tmpdir, pydantic_version, call_from_python):
-    if pydantic_version == "v1":
-        pytest.skip("Computed fields are a pydantic v2 feature")
-    _run_test(tmpdir, "computed_fields", pydantic_version, call_from_python=call_from_python)
+def test_computed_fields(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+    _run_test(tmp_path, "computed_fields", pydantic_version, call_from_python=call_from_python)
 
 
 @pytest.mark.parametrize(
     "pydantic_version, call_from_python",
     product(_PYDANTIC_VERSIONS, [False, True]),
 )
-def test_extra_fields(tmpdir, pydantic_version, call_from_python):
-    _run_test(tmpdir, "extra_fields", pydantic_version, call_from_python=call_from_python)
+def test_extra_fields(tmp_path: Path, pydantic_version: str, call_from_python: bool):
+    _run_test(tmp_path, "extra_fields", pydantic_version, call_from_python=call_from_python)
 
 
-def test_relative_filepath(tmpdir):
+def test_relative_filepath(tmp_path: Path):
     test_name = "single_module"
     pydantic_version = _PYDANTIC_VERSIONS[0]
     relative_path = (
         Path(".") / "tests" / "expected_results" / test_name / pydantic_version / "input.py"
     )
     _run_test(
-        tmpdir,
+        tmp_path,
         test_name,
         pydantic_version,
-        module_path=relative_path,
+        module_path=str(relative_path),
     )
 
 
-def test_error_if_json2ts_not_installed(tmpdir):
+def test_error_if_json2ts_not_installed(tmp_path: Path):
     module_path = _get_input_module("single_module", _PYDANTIC_VERSIONS[0])
-    output_path = tmpdir.join("json2ts_test_output.ts").strpath
+    output_path = str(tmp_path / "json2ts_test_output.ts")
 
     # If the json2ts command has no spaces and the executable cannot be found,
     # that means the user either hasn't installed json-schema-to-typescript or they made a typo.
@@ -159,9 +151,9 @@ def test_error_if_json2ts_not_installed(tmpdir):
     assert str(exc2.value).startswith(f'"{invalid_local_cmd}" failed with exit code ')
 
 
-def test_error_if_invalid_module_path(tmpdir):
+def test_error_if_invalid_module_path(tmp_path: Path):
     with pytest.raises(ModuleNotFoundError):
-        generate_typescript_defs("fake_module", tmpdir.join("fake_module_output.ts").strpath)
+        generate_typescript_defs("fake_module", str(tmp_path / "fake_module_output.ts"))
 
 
 def test_parse_cli_args():