Import modules/objects directly from v1 namespace (#9162)

Co-authored-by: Sydney Runkle <[email protected]>

Author: rx-dwoodward

.github/workflows/ci.yml

@@ -194,18 +194,27 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu, macos, windows]
+        os: [ubuntu-latest, macos-13, macos-latest, windows-latest]
         python-version: ['3.7', '3.8', '3.9', '3.10']
-        include:
-        - os: ubuntu
+        exclude:
+          # Python 3.7, 3.8, and 3.9 are not available on macOS 14
+          - os: macos-13
+            python-version: '3.10'
+          - os: macos-latest
+            python-version: '3.7'
+          - os: macos-latest
+            python-version: '3.8'
+          - os: macos-latest
+            python-version: '3.9'
+
+    runs-on: ${{ matrix.os }}
 
     env:
       PYTHON: ${{ matrix.python-version }}
       OS: ${{ matrix.os }}
       COMPILED: no
       DEPS: yes
 
-    runs-on: ${{ matrix.os }}-latest
     steps:
     - uses: actions/checkout@v3
 
@@ -365,7 +374,7 @@ jobs:
         python-version: '3.8'
 
     - name: install
-      run: pip install -U twine setuptools wheel cibuildwheel
+      run: pip install -U twine setuptools wheel cibuildwheel==2.17.0
 
     - name: build sdist
       if: matrix.os == 'ubuntu' && matrix.python-version == '9'

pydantic/__init__.py

@@ -1,23 +1,23 @@
 # flake8: noqa
-from . import dataclasses
-from .annotated_types import create_model_from_namedtuple, create_model_from_typeddict
-from .class_validators import root_validator, validator
-from .config import BaseConfig, ConfigDict, Extra
-from .decorator import validate_arguments
-from .env_settings import BaseSettings
-from .error_wrappers import ValidationError
-from .errors import *
-from .fields import Field, PrivateAttr, Required
-from .main import *
-from .networks import *
-from .parse import Protocol
-from .tools import *
-from .types import *
-from .version import VERSION, compiled
+from pydantic import dataclasses
+from pydantic.annotated_types import create_model_from_namedtuple, create_model_from_typeddict
+from pydantic.class_validators import root_validator, validator
+from pydantic.config import BaseConfig, ConfigDict, Extra
+from pydantic.decorator import validate_arguments
+from pydantic.env_settings import BaseSettings
+from pydantic.error_wrappers import ValidationError
+from pydantic.errors import *
+from pydantic.fields import Field, PrivateAttr, Required
+from pydantic.main import *
+from pydantic.networks import *
+from pydantic.parse import Protocol
+from pydantic.tools import *
+from pydantic.types import *
+from pydantic.version import VERSION, compiled
 
 __version__ = VERSION
 
-# WARNING __all__ from .errors is not included here, it will be removed as an export here in v2
+# WARNING __all__ from pydantic.errors is not included here, it will be removed as an export here in v2
 # please use "from pydantic.errors import ..." instead
 __all__ = [
     # annotated types utils

pydantic/annotated_types.py

@@ -1,9 +1,9 @@
 import sys
 from typing import TYPE_CHECKING, Any, Dict, FrozenSet, NamedTuple, Type
 
-from .fields import Required
-from .main import BaseModel, create_model
-from .typing import is_typeddict, is_typeddict_special
+from pydantic.fields import Required
+from pydantic.main import BaseModel, create_model
+from pydantic.typing import is_typeddict, is_typeddict_special
 
 if TYPE_CHECKING:
     from typing_extensions import TypedDict

pydantic/class_validators.py

@@ -5,12 +5,12 @@
 from types import FunctionType
 from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Type, Union, overload
 
-from .errors import ConfigError
-from .typing import AnyCallable
-from .utils import ROOT_KEY, in_ipython
+from pydantic.errors import ConfigError
+from pydantic.typing import AnyCallable
+from pydantic.utils import ROOT_KEY, in_ipython
 
 if TYPE_CHECKING:
-    from .typing import AnyClassMethod
+    from pydantic.typing import AnyClassMethod
 
 
 class Validator:
@@ -36,9 +36,9 @@ def __init__(
 if TYPE_CHECKING:
     from inspect import Signature
 
-    from .config import BaseConfig
-    from .fields import ModelField
-    from .types import ModelOrDc
+    from pydantic.config import BaseConfig
+    from pydantic.fields import ModelField
+    from pydantic.types import ModelOrDc
 
     ValidatorCallable = Callable[[Optional[ModelOrDc], Any, Dict[str, Any], ModelField, Type[BaseConfig]], Any]
     ValidatorsList = List[ValidatorCallable]

pydantic/color.py

@@ -12,11 +12,11 @@
 from colorsys import hls_to_rgb, rgb_to_hls
 from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union, cast
 
-from .errors import ColorError
-from .utils import Representation, almost_equal_floats
+from pydantic.errors import ColorError
+from pydantic.utils import Representation, almost_equal_floats
 
 if TYPE_CHECKING:
-    from .typing import CallableGenerator, ReprArgs
+    from pydantic.typing import CallableGenerator, ReprArgs
 
 ColorTuple = Union[Tuple[int, int, int], Tuple[int, int, int, float]]
 ColorType = Union[ColorTuple, str]

pydantic/config.py

@@ -4,15 +4,15 @@
 
 from typing_extensions import Literal, Protocol
 
-from .typing import AnyArgTCallable, AnyCallable
-from .utils import GetterDict
-from .version import compiled
+from pydantic.typing import AnyArgTCallable, AnyCallable
+from pydantic.utils import GetterDict
+from pydantic.version import compiled
 
 if TYPE_CHECKING:
     from typing import overload
 
-    from .fields import ModelField
-    from .main import BaseModel
+    from pydantic.fields import ModelField
+    from pydantic.main import BaseModel
 
     ConfigType = Type['BaseConfig']
 

pydantic/dataclasses.py

@@ -47,17 +47,17 @@ class M:
 
 from typing_extensions import dataclass_transform
 
-from .class_validators import gather_all_validators
-from .config import BaseConfig, ConfigDict, Extra, get_config
-from .error_wrappers import ValidationError
-from .errors import DataclassTypeError
-from .fields import Field, FieldInfo, Required, Undefined
-from .main import create_model, validate_model
-from .utils import ClassAttribute
+from pydantic.class_validators import gather_all_validators
+from pydantic.config import BaseConfig, ConfigDict, Extra, get_config
+from pydantic.error_wrappers import ValidationError
+from pydantic.errors import DataclassTypeError
+from pydantic.fields import Field, FieldInfo, Required, Undefined
+from pydantic.main import create_model, validate_model
+from pydantic.utils import ClassAttribute
 
 if TYPE_CHECKING:
-    from .main import BaseModel
-    from .typing import CallableGenerator, NoArgAnyCallable
+    from pydantic.main import BaseModel
+    from pydantic.typing import CallableGenerator, NoArgAnyCallable
 
     DataclassT = TypeVar('DataclassT', bound='Dataclass')
 

pydantic/datetime_parse.py

@@ -18,7 +18,7 @@
 from datetime import date, datetime, time, timedelta, timezone
 from typing import Dict, Optional, Type, Union
 
-from . import errors
+from pydantic import errors
 
 date_expr = r'(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})'
 time_expr = (

pydantic/decorator.py

@@ -1,17 +1,17 @@
 from functools import wraps
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload
 
-from . import validator
-from .config import Extra
-from .errors import ConfigError
-from .main import BaseModel, create_model
-from .typing import get_all_type_hints
-from .utils import to_camel
+from pydantic import validator
+from pydantic.config import Extra
+from pydantic.errors import ConfigError
+from pydantic.main import BaseModel, create_model
+from pydantic.typing import get_all_type_hints
+from pydantic.utils import to_camel
 
 __all__ = ('validate_arguments',)
 
 if TYPE_CHECKING:
-    from .typing import AnyCallable
+    from pydantic.typing import AnyCallable
 
     AnyCallableT = TypeVar('AnyCallableT', bound=AnyCallable)
     ConfigType = Union[None, Type[Any], Dict[str, Any]]

pydantic/env_settings.py

@@ -3,12 +3,12 @@
 from pathlib import Path
 from typing import AbstractSet, Any, Callable, ClassVar, Dict, List, Mapping, Optional, Tuple, Type, Union
 
-from .config import BaseConfig, Extra
-from .fields import ModelField
-from .main import BaseModel
-from .types import JsonWrapper
-from .typing import StrPath, display_as_type, get_origin, is_union
-from .utils import deep_update, lenient_issubclass, path_type, sequence_like
+from pydantic.config import BaseConfig, Extra
+from pydantic.fields import ModelField
+from pydantic.main import BaseModel
+from pydantic.types import JsonWrapper
+from pydantic.typing import StrPath, display_as_type, get_origin, is_union
+from pydantic.utils import deep_update, lenient_issubclass, path_type, sequence_like
 
 env_file_sentinel = str(object())
 

pydantic/error_wrappers.py

@@ -1,15 +1,15 @@
 import json
 from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Sequence, Tuple, Type, Union
 
-from .json import pydantic_encoder
-from .utils import Representation
+from pydantic.json import pydantic_encoder
+from pydantic.utils import Representation
 
 if TYPE_CHECKING:
     from typing_extensions import TypedDict
 
-    from .config import BaseConfig
-    from .types import ModelOrDc
-    from .typing import ReprArgs
+    from pydantic.config import BaseConfig
+    from pydantic.types import ModelOrDc
+    from pydantic.typing import ReprArgs
 
     Loc = Tuple[Union[int, str], ...]
 

pydantic/errors.py

@@ -2,12 +2,12 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Sequence, Set, Tuple, Type, Union
 
-from .typing import display_as_type
+from pydantic.typing import display_as_type
 
 if TYPE_CHECKING:
-    from .typing import DictStrAny
+    from pydantic.typing import DictStrAny
 
-# explicitly state exports to avoid "from .errors import *" also importing Decimal, Path etc.
+# explicitly state exports to avoid "from pydantic.errors import *" also importing Decimal, Path etc.
 __all__ = (
     'PydanticTypeError',
     'PydanticValueError',

pydantic/fields.py

@@ -28,12 +28,12 @@
 
 from typing_extensions import Annotated, Final
 
-from . import errors as errors_
-from .class_validators import Validator, make_generic_validator, prep_validators
-from .error_wrappers import ErrorWrapper
-from .errors import ConfigError, InvalidDiscriminator, MissingDiscriminator, NoneIsNotAllowedError
-from .types import Json, JsonWrapper
-from .typing import (
+from pydantic import errors as errors_
+from pydantic.class_validators import Validator, make_generic_validator, prep_validators
+from pydantic.error_wrappers import ErrorWrapper
+from pydantic.errors import ConfigError, InvalidDiscriminator, MissingDiscriminator, NoneIsNotAllowedError
+from pydantic.types import Json, JsonWrapper
+from pydantic.typing import (
     NoArgAnyCallable,
     convert_generics,
     display_as_type,
@@ -48,7 +48,7 @@
     is_union,
     new_type_supertype,
 )
-from .utils import (
+from pydantic.utils import (
     PyObjectStr,
     Representation,
     ValueItems,
@@ -59,7 +59,7 @@
     sequence_like,
     smart_deepcopy,
 )
-from .validators import constant_validator, dict_validator, find_validators, validate_json
+from pydantic.validators import constant_validator, dict_validator, find_validators, validate_json
 
 Required: Any = Ellipsis
 
@@ -83,11 +83,11 @@ def __deepcopy__(self: T, _: Any) -> T:
 Undefined = UndefinedType()
 
 if TYPE_CHECKING:
-    from .class_validators import ValidatorsList
-    from .config import BaseConfig
-    from .error_wrappers import ErrorList
-    from .types import ModelOrDc
-    from .typing import AbstractSetIntStr, MappingIntStrAny, ReprArgs
+    from pydantic.class_validators import ValidatorsList
+    from pydantic.config import BaseConfig
+    from pydantic.error_wrappers import ErrorList
+    from pydantic.types import ModelOrDc
+    from pydantic.typing import AbstractSetIntStr, MappingIntStrAny, ReprArgs
 
     ValidateReturn = Tuple[Optional[Any], Optional[ErrorList]]
     LocStr = Union[Tuple[Union[int, str], ...], str]
@@ -490,7 +490,7 @@ def infer(
         class_validators: Optional[Dict[str, Validator]],
         config: Type['BaseConfig'],
     ) -> 'ModelField':
-        from .schema import get_annotation_from_field_info
+        from pydantic.schema import get_annotation_from_field_info
 
         field_info, value = cls._get_field_info(name, annotation, value, config)
         required: 'BoolUndefined' = Undefined
@@ -1160,7 +1160,7 @@ def is_complex(self) -> bool:
         """
         Whether the field is "complex" eg. env variables should be parsed as JSON.
         """
-        from .main import BaseModel
+        from pydantic.main import BaseModel
 
         return (
             self.shape != SHAPE_SINGLETON

pydantic/generics.py

@@ -22,12 +22,12 @@
 
 from typing_extensions import Annotated, Literal as ExtLiteral
 
-from .class_validators import gather_all_validators
-from .fields import DeferredType
-from .main import BaseModel, create_model
-from .types import JsonWrapper
-from .typing import display_as_type, get_all_type_hints, get_args, get_origin, typing_base
-from .utils import all_identical, lenient_issubclass
+from pydantic.class_validators import gather_all_validators
+from pydantic.fields import DeferredType
+from pydantic.main import BaseModel, create_model
+from pydantic.types import JsonWrapper
+from pydantic.typing import display_as_type, get_all_type_hints, get_args, get_origin, typing_base
+from pydantic.utils import all_identical, lenient_issubclass
 
 if sys.version_info >= (3, 10):
     from typing import _UnionGenericAlias

pydantic/json.py

@@ -9,9 +9,9 @@
 from typing import Any, Callable, Dict, Type, Union
 from uuid import UUID
 
-from .color import Color
-from .networks import NameEmail
-from .types import SecretBytes, SecretStr
+from pydantic.color import Color
+from pydantic.networks import NameEmail
+from pydantic.types import SecretBytes, SecretStr
 
 __all__ = 'pydantic_encoder', 'custom_pydantic_encoder', 'timedelta_isoformat'
 
@@ -72,7 +72,7 @@ def decimal_encoder(dec_value: Decimal) -> Union[int, float]:
 def pydantic_encoder(obj: Any) -> Any:
     from dataclasses import asdict, is_dataclass
 
-    from .main import BaseModel
+    from pydantic.main import BaseModel
 
     if isinstance(obj, BaseModel):
         return obj.dict()