fix: Linting errors.

Author: DanCardin

README.md

@@ -64,7 +64,7 @@ example: Example = load_settings(Example, nested_delimiter='_')
 ### Clarity
 
 - `pydantic-settings` makes it really, really difficult to intuit what the
-  concrete environment varibale that's going to be loaded for a given field is
+  concrete environment variable that's going to be loaded for a given field is
   **actually** going to be. Based on my own experience, and from perusing their
   issue tracker, it seems like this is not an uncommon experience.
 
@@ -127,7 +127,7 @@ example: Example = load_settings(Example, nested_delimiter='_')
 
   Practically, `pydantic` has the most robust system for parsing/validating a
   json-like structure into the models, so it's probably to be the most flexible
-  anyways. But for many simple cases, particuarly those without nesting, or that
+  anyways. But for many simple cases, particularly those without nesting, or that
   only deal in simple types (like int, float, str, etc); then dataclasses/attrs
   can certainly provide a similar experience.
 

src/dataclass_settings/class_inspect.py

@@ -65,9 +65,9 @@ def map_value(self, value: str | dict[str, Any]):
 @dataclasses.dataclass
 class DataclassField(Field):
     @classmethod
-    def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
         fields = []
-        for f in typ.__dataclass_fields__.values():  # type: ignore
+        for f in value.__dataclass_fields__.values():  # type: ignore
             annotation = get_type(type_hints[f.name])
 
             annotation, args = get_annotation_args(annotation)
@@ -85,10 +85,10 @@ def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
 @dataclasses.dataclass
 class AttrsField(Field):
     @classmethod
-    def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
         fields = []
 
-        for f in typ.__attrs_attrs__:  # type: ignore
+        for f in value.__attrs_attrs__:  # type: ignore
             annotation = get_type(type_hints[f.name])
             annotation, args = get_annotation_args(annotation)
 
@@ -105,11 +105,11 @@ def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
 @dataclasses.dataclass
 class MsgspecField(Field):
     @classmethod
-    def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
         import msgspec
 
         fields = []
-        for f in msgspec.structs.fields(typ):
+        for f in msgspec.structs.fields(value):
             annotation = get_type(type_hints[f.name])
             annotation, args = get_annotation_args(annotation)
 
@@ -137,9 +137,9 @@ def convert(**value):
 @dataclasses.dataclass
 class PydanticV1Field(Field):
     @classmethod
-    def collect(cls, typ, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value, type_hints: dict[str, Type]) -> list[Self]:
         fields = []
-        for name, f in typ.__fields__.items():
+        for name, f in value.__fields__.items():
             annotation = get_type(type_hints[name])
             annotation, args = get_annotation_args(annotation)
 
@@ -158,9 +158,9 @@ def collect(cls, typ, type_hints: dict[str, Type]) -> list[Self]:
 @dataclasses.dataclass
 class PydanticV2Field(Field):
     @classmethod
-    def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
         fields = []
-        for name, f in typ.model_fields.items():  # type: ignore
+        for name, f in value.model_fields.items():  # type: ignore
             annotation = get_type(type_hints[name])
             mapper = annotation if detect(annotation) else None
 
@@ -177,10 +177,10 @@ def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
 @dataclasses.dataclass
 class PydanticV2DataclassField(Field):
     @classmethod
-    def collect(cls, typ: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
         fields = []
 
-        for name, f in typ.__pydantic_fields__.items():  # type: ignore
+        for name, f in value.__pydantic_fields__.items():  # type: ignore
             annotation = get_type(type_hints[name])
             mapper = annotation if detect(annotation) else None
 
@@ -248,10 +248,10 @@ def from_cls(cls, obj: type) -> ClassTypes | None:
         return None
 
 
-def get_type(typ):
-    if typing_inspect.is_optional_type(typ):
-        return get_args(typ)[0]
-    return typ
+def get_type(value):
+    if typing_inspect.is_optional_type(value):
+        return get_args(value)[0]
+    return value
 
 
 def get_annotation_args(annotation) -> Tuple[Type, Tuple[Any, ...]]:

tests/loaders/test_toml.py

@@ -71,7 +71,7 @@ class AttrRequired:
         str,
         Toml(
             Path(__file__).parent.parent.parent / "pyproject.toml",
-            "project.license",
+            "project.license.file",
         ),
     ]
     ignoreme: str = "asdf"
@@ -87,7 +87,7 @@ class DataclassRequired:
         str,
         Toml(
             Path(__file__).parent.parent.parent / "pyproject.toml",
-            "project.license",
+            "project.license.file",
         ),
     ]
     ignoreme: str = "asdf"
@@ -102,7 +102,7 @@ class MsgspecRequired(Struct):
         str,
         Toml(
             Path(__file__).parent.parent.parent / "pyproject.toml",
-            "project.license",
+            "project.license.file",
         ),
     ]
     ignoreme: str = "asdf"
@@ -120,7 +120,7 @@ class PydanticRequired(BaseModel):
         str,
         Toml(
             Path(__file__).parent.parent.parent / "pyproject.toml",
-            "project.license",
+            "project.license.file",
         ),
     ]
     ignoreme: str = "asdf"
@@ -139,7 +139,7 @@ class PDataclassRequired:
         str,
         Toml(
             Path(__file__).parent.parent.parent / "pyproject.toml",
-            "project.license",
+            "project.license.file",
         ),
     ]
     ignoreme: str = "asdf"
@@ -159,34 +159,34 @@ class PDataclassRequired:
 def test_has_required_required(config_class):
     config = load_settings(config_class)
     assert config == config_class(
-        foo="dataclass-settings", ignoreme="asdf", license="Apache-2.0"
+        foo="dataclass-settings", ignoreme="asdf", license="LICENSE"
     )
 
 
 @attr_dataclass
-class AttrMissingOptionelInferred:
+class AttrMissingOptionalInferred:
     tool: Annotated[int, Toml(Path(__file__).parent.parent.parent / "pyproject.toml")]
     ignoreme: str = "asdf"
 
 
 @dataclass
-class DataclassMissingOptionelInferred:
+class DataclassMissingOptionalInferred:
     tool: Annotated[int, Toml(Path(__file__).parent.parent.parent / "pyproject.toml")]
     ignoreme: str = "asdf"
 
 
-class MsgspecMissingOptionelInferred(Struct):
+class MsgspecMissingOptionalInferred(Struct):
     tool: Annotated[int, Toml(Path(__file__).parent.parent.parent / "pyproject.toml")]
     ignoreme: str = "asdf"
 
 
-class PydanticMissingOptionelInferred(BaseModel):
+class PydanticMissingOptionalInferred(BaseModel):
     tool: Annotated[int, Toml(Path(__file__).parent.parent.parent / "pyproject.toml")]
     ignoreme: str = "asdf"
 
 
 @pydantic_dataclass
-class PDataclassMissingOptionelInferred:
+class PDataclassMissingOptionalInferred:
     tool: Annotated[int, Toml(Path(__file__).parent.parent.parent / "pyproject.toml")]
     ignoreme: str = "asdf"
 
@@ -195,11 +195,11 @@ class PDataclassMissingOptionelInferred:
 @pytest.mark.parametrize(
     "config_class",
     [
-        AttrMissingOptionelInferred,
-        DataclassMissingOptionelInferred,
-        MsgspecMissingOptionelInferred,
-        PydanticMissingOptionelInferred,
-        PDataclassMissingOptionelInferred,
+        AttrMissingOptionalInferred,
+        DataclassMissingOptionalInferred,
+        MsgspecMissingOptionalInferred,
+        PydanticMissingOptionalInferred,
+        PDataclassMissingOptionalInferred,
     ],
 )
 def test_missing_optional_inferred_name(config_class):