amati 0.2.1__tar.gz → 0.2.2__tar.gz

{amati-0.2.1 → amati-0.2.2}/.github/workflows/publish.yaml

@@ -43,5 +43,5 @@ jobs:
           context: .
           push: true
           tags:  |
-            ${{ secrets.DOCKERHUB_USERNAME }}/${{ secrets.DOCKERHUB_REPO }}:${{ github.event.release.tag_name }}-alpha.1
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ secrets.DOCKERHUB_REPO }}:${{ github.event.release.tag_name }}.1
             ${{ secrets.DOCKERHUB_USERNAME }}/${{ secrets.DOCKERHUB_REPO }}:alpha

{amati-0.2.1 → amati-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amati
-Version: 0.2.1
+Version: 0.2.2
 Summary: Validates that a .yaml or .json file conforms to the OpenAPI Specifications 3.x.
 Project-URL: Homepage, https://github.com/ben-alexander/amati
 Project-URL: Issues, https://github.com/ben-alexander/amati/issues

{amati-0.2.1 → amati-0.2.2}/amati/amati.py

@@ -16,7 +16,7 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 from amati._error_handler import handle_errors
 from amati._resolve_forward_references import resolve_forward_references
 from amati.file_handler import load_file
-from amati.logging import Log, LogMixin
+from amati.logging import Log, Logger
 
 type JSONPrimitive = str | int | float | bool | None
 type JSONArray = list["JSONValue"]
@@ -113,9 +113,9 @@ def run(
 
     logs: list[Log] = []
 
-    with LogMixin.context():
+    with Logger.context():
         result, errors = dispatch(data)
-        logs.extend(LogMixin.logs)
+        logs.extend(Logger.logs)
 
     if errors or logs:
 
@@ -158,19 +158,38 @@ def run(
     if result and consistency_check:
         return check(data, result)
 
+    return True
 
-def discover(discover_dir: str = ".") -> list[Path]:
+
+def discover(spec: str, discover_dir: str = ".") -> list[Path]:
     """
     Finds OpenAPI Specification files to validate
 
     Args:
+        spec: The path to a specific OpenAPI specification file.
         discover_dir: The directory to search through.
     Returns:
-        A list of paths to validate.
+        A list of specifications to validate.
     """
 
     specs: list[Path] = []
 
+    # If a spec is provided, check if it exists and erorr if not
+    if spec:
+        spec_path = Path(spec)
+
+        if not spec_path.exists():
+            raise FileNotFoundError(f"File {spec} does not exist.")
+
+        if not spec_path.is_file():
+            raise IsADirectoryError(f"{spec} is a directory, not a file.")
+
+        specs.append(spec_path)
+
+        # End early if we're not also trying to find files
+        if not discover_dir:
+            return specs
+
     if Path("openapi.json").exists():
         specs.append(Path("openapi.json"))
 
@@ -258,16 +277,20 @@ if __name__ == "__main__":
     )
 
     args = parser.parse_args()
+    
+    print('Starting amati...')
 
-    if args.spec:
-        specifications: list[Path] = [Path(args.spec)]
-    else:
-        specifications = discover(args.discover)
+    specifications = discover(args.spec, args.discover)
+    print(specifications)
 
     for specification in specifications:
-        if successful_check := run(
+        successful_check = run(
             specification, args.consistency_check, args.local, args.html_report
-        ):
-            print("Consistency check successful for {specification}")
-        else:
-            print("Consistency check failed for {specification}")
+        )
+
+        if args.consistency_check and successful_check:
+            print(f"Consistency check successful for {specification}")
+        elif args.consistency_check:
+            print(f"Consistency check failed for {specification}")
+            
+    print('completed.')

{amati-0.2.1 → amati-0.2.2}/amati/logging.py

@@ -18,7 +18,7 @@ class Log(TypedDict):
     url: NotRequired[str]
 
 
-class LogMixin:
+class Logger:
     """
     A mixin class that provides logging functionality.
 

{amati-0.2.1 → amati-0.2.2}/amati/model_validators.py

@@ -10,7 +10,7 @@ from pydantic._internal._decorators import (
     PydanticDescriptorProxy,
 )
 
-from amati.logging import LogMixin
+from amati.logging import Logger
 from amati.validators.generic import GenericObject
 
 
@@ -107,7 +107,7 @@ def at_least_one_of(
         The validator that ensures at least one public field is non-empty.
 
     Example:
-        >>> LogMixin.logs = []
+        >>> Logger.logs = []
         >>>
         >>> class User(GenericObject):
         ...     name: str = ""
@@ -116,8 +116,8 @@ def at_least_one_of(
         ...     _reference_uri = "https://example.com"
         ...
         >>> user = User()
-        >>> assert len(LogMixin.logs) == 1
-        >>> LogMixin.logs = []
+        >>> assert len(Logger.logs) == 1
+        >>> Logger.logs = []
 
         >>> class User(GenericObject):
         ...     name: str = ""
@@ -128,11 +128,11 @@ def at_least_one_of(
         ...
         >>>
         >>> user = User(name="John")  # Works fine
-        >>> assert not LogMixin.logs
+        >>> assert not Logger.logs
         >>> user = User()
-        >>> assert len(LogMixin.logs) == 1
+        >>> assert len(Logger.logs) == 1
         >>> user = User(age=30)
-        >>> assert len(LogMixin.logs) == 2
+        >>> assert len(Logger.logs) == 2
 
 
     Note:
@@ -157,7 +157,7 @@ def at_least_one_of(
         public_fields = ", ".join(f"{name}" for name in candidates.keys())
 
         msg = f"{public_fields} do not have values, expected at least one."
-        LogMixin.log(
+        Logger.log(
             {
                 "msg": msg,
                 "type": "value_error",
@@ -191,7 +191,7 @@ def only_one_of(
         The validator that ensures at one public field is non-empty.
 
     Example:
-        >>> LogMixin.logs = []
+        >>> Logger.logs = []
         >>>
         >>> class User(GenericObject):
         ...     email: str = ""
@@ -201,10 +201,10 @@ def only_one_of(
         ...
         >>> user = User(email="test@example.com")  # Works fine
         >>> user = User(name="123-456-7890")  # Works fine
-        >>> assert not LogMixin.logs
+        >>> assert not Logger.logs
         >>> user = User(email="a@b.com", name="123")
-        >>> assert LogMixin.logs
-        >>> LogMixin.logs = []
+        >>> assert Logger.logs
+        >>> Logger.logs = []
 
         >>> class User(GenericObject):
         ...     name: str = ""
@@ -216,11 +216,11 @@ def only_one_of(
         >>> user = User(name="Bob")  # Works fine
         >>> user = User(email="test@example.com")  # Works fine
         >>> user = User(name="Bob", age=30)  # Works fine
-        >>> assert not LogMixin.logs
+        >>> assert not Logger.logs
         >>> user = User(name="Bob", email="a@b.com")
-        >>> assert len(LogMixin.logs) == 1
+        >>> assert len(Logger.logs) == 1
         >>> user = User(age=30)
-        >>> assert len(LogMixin.logs) == 2
+        >>> assert len(Logger.logs) == 2
 
     Note:
         Only public fields (not starting with '_') are checked. Private fields
@@ -249,7 +249,7 @@ def only_one_of(
                 field_string = "none"
             msg = f"Expected at most one field to have a value, {field_string} did"
 
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": msg,
                     "type": type_ or "value_error",
@@ -282,7 +282,7 @@ def all_of(
         The validator that ensures at most one public field is non-empty.
 
     Example:
-        >>> LogMixin.logs = []
+        >>> Logger.logs = []
         >>>
         >>> class User(GenericObject):
         ...     email: str = ""
@@ -291,11 +291,11 @@ def all_of(
         ...     _reference_uri = "https://example.com"
         ...
         >>> user = User(email="a@b.com", name="123") # Works fine
-        >>> assert not LogMixin.logs
+        >>> assert not Logger.logs
         >>> user = User(email="test@example.com")
-        >>> assert len(LogMixin.logs) == 1
+        >>> assert len(Logger.logs) == 1
         >>> user = User(name="123-456-7890")
-        >>> assert len(LogMixin.logs) == 2
+        >>> assert len(Logger.logs) == 2
 
         >>> class User(GenericObject):
         ...     name: str = ""
@@ -304,17 +304,17 @@ def all_of(
         ...     _all_of = all_of(["name", "email"])
         ...     _reference_uri = "https://example.com"
         ...
-        >>> LogMixin.logs = []
+        >>> Logger.logs = []
         >>> user = User(name="Bob", email="a@b.com") # Works fine
-        >>> assert not LogMixin.logs
+        >>> assert not Logger.logs
         >>> user = User(name="Bob")
-        >>> assert len(LogMixin.logs) == 1
+        >>> assert len(Logger.logs) == 1
         >>> user = User(email="test@example.com")
-        >>> assert len(LogMixin.logs) == 2
+        >>> assert len(Logger.logs) == 2
         >>> user = User(age=30)
-        >>> assert len(LogMixin.logs) == 3
+        >>> assert len(Logger.logs) == 3
         >>> user = User(name="Bob", age=30)
-        >>> assert len(LogMixin.logs) == 4
+        >>> assert len(Logger.logs) == 4
 
     Note:
         Only public fields (not starting with '_') are checked. Private fields
@@ -339,7 +339,7 @@ def all_of(
         if falsy:
             msg = f"Expected at all fields to have a value, {", ".join(falsy)} did not"
 
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": msg,
                     "type": "value_error",
@@ -378,7 +378,7 @@ def if_then(
         ValueError: If a condition and consequence are not present
 
     Example:
-        >>> LogMixin.logs = []
+        >>> Logger.logs = []
         >>>
         >>> class User(GenericObject):
         ...     role: str = ""
@@ -390,11 +390,11 @@ def if_then(
         ...     _reference_uri = "https://example.com"
         ...
         >>> user = User(role="admin", can_edit=True)  # Works fine
-        >>> assert not LogMixin.logs
+        >>> assert not Logger.logs
         >>> user = User(role="admin", can_edit=False)  # Fails validation
-        >>> assert len(LogMixin.logs) == 1
+        >>> assert len(Logger.logs) == 1
         >>> user = User(role="user", can_edit=False)  # Works fine
-        >>> assert len(LogMixin.logs) == 1
+        >>> assert len(Logger.logs) == 1
     """
 
     @model_validator(mode="after")
@@ -431,7 +431,7 @@ def if_then(
             if value == actual:
                 continue
 
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": f"Expected {field} to be {"in " if iterable else ""}"
                     f"{value} found {actual}",

{amati-0.2.1 → amati-0.2.2}/amati/validators/generic.py

@@ -20,7 +20,7 @@ from typing import (
 from pydantic import BaseModel, ConfigDict, PrivateAttr
 from pydantic_core._pydantic_core import PydanticUndefined
 
-from amati.logging import LogMixin
+from amati.logging import Logger
 
 
 class GenericObject(BaseModel):
@@ -47,7 +47,7 @@ class GenericObject(BaseModel):
                 and field not in self.get_field_aliases()
             ):
                 message = f"{field} is not a valid field for {self.__repr_name__()}."
-                LogMixin.log(
+                Logger.log(
                     {
                         "msg": message,
                         "type": "value_error",
@@ -79,7 +79,7 @@ class GenericObject(BaseModel):
 
         for field in excess_fields:
             message = f"{field} is not a valid field for {self.__repr_name__()}."
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": message,
                     "type": "value_error",

{amati-0.2.1 → amati-0.2.2}/amati/validators/oas304.py

@@ -42,7 +42,7 @@ from amati.fields import (
 from amati.fields.commonmark import CommonMark
 from amati.fields.json import JSON
 from amati.fields.oas import OpenAPI, RuntimeExpression
-from amati.logging import LogMixin
+from amati.logging import Logger
 from amati.validators.generic import GenericObject, allow_extra_fields
 
 type JSONPrimitive = str | int | float | bool | None
@@ -179,7 +179,7 @@ class ServerVariableObject(GenericObject):
             return self
 
         if self.default not in self.enum:
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": f"The default value {self.default} is not in the enum list {self.enum}",  # pylint: disable=line-too-long
                     "type": "warning",
@@ -647,7 +647,7 @@ class XMLObject(GenericObject):
         """
         if value.type == URIType.RELATIVE:
             message = "XML namespace {value} cannot be a relative URI"
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": message,
                     "type": "value_error",
@@ -726,7 +726,7 @@ class SchemaObject(GenericObject):
             # This will validate the structure conforms to JSON Schema
             validator_cls(meta_schema).validate(schema_dict)  # type: ignore
         except JSONVSchemeValidationError as e:
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": f"Invalid JSON Schema: {e.message}",
                     "type": "value_error",

{amati-0.2.1 → amati-0.2.2}/amati/validators/oas311.py

@@ -37,7 +37,7 @@ from amati.fields.commonmark import CommonMark
 from amati.fields.json import JSON
 from amati.fields.oas import OpenAPI
 from amati.fields.spdx_licences import VALID_LICENCES
-from amati.logging import LogMixin
+from amati.logging import Logger
 from amati.validators.generic import GenericObject, allow_extra_fields
 from amati.validators.oas304 import (
     CallbackObject,
@@ -105,7 +105,7 @@ class LicenceObject(GenericObject):
             try:
                 SPDXURL(self.url)
             except AmatiValueError:
-                LogMixin.log(
+                Logger.log(
                     {
                         "msg": f"{str(self.url)} is not a valid SPDX URL",
                         "type": "warning",
@@ -122,7 +122,7 @@ class LicenceObject(GenericObject):
             and self.identifier
             and str(self.url) not in VALID_LICENCES[self.identifier]
         ):
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": f"{self.url} is not associated with the identifier {self.identifier}",  # pylint: disable=line-too-long
                     "type": "warning",
@@ -214,7 +214,7 @@ class ServerVariableObject(GenericObject):
             return self
 
         if self.default not in self.enum:
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": f"The default value {self.default} is not in the enum list {self.enum}",  # pylint: disable=line-too-long
                     "type": "value_error",
@@ -396,7 +396,7 @@ class SchemaObject(GenericObject):
             # This will validate the structure conforms to JSON Schema
             validator_cls(meta_schema).validate(schema_dict)  # type: ignore
         except JSONVSchemeValidationError as e:
-            LogMixin.log(
+            Logger.log(
                 {
                     "msg": f"Invalid JSON Schema: {e.message}",
                     "type": "value_error",

{amati-0.2.1 → amati-0.2.2}/bin/checks.sh

@@ -6,5 +6,5 @@ pytest --cov-report term-missing --cov=amati tests
 pytest --doctest-modules amati/
 docker build -t amati -f Dockerfile . 
 cd tests/
-docker run --detach -v "$(pwd):/data" amati -d /data
+docker run --detach -v "$(pwd):/data" amati -d /data -cc
 cd ../

{amati-0.2.1 → amati-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "amati"
-version = "0.2.1"
+version = "0.2.2"
 description = "Validates that a .yaml or .json file conforms to the OpenAPI Specifications 3.x."
 readme = "README.md"
 authors = [

{amati-0.2.1 → amati-0.2.2}/tests/model_validators/test_all_of.py

@@ -10,7 +10,7 @@ from hypothesis import strategies as st
 from pydantic import BaseModel
 
 from amati import model_validators as mv
-from amati.logging import LogMixin
+from amati.logging import Logger
 from tests.helpers import text_excluding_empty_string
 
 MIN = int(float_info.min)
@@ -38,9 +38,9 @@ class AllWithRestrictions(BaseModel):
 
 
 def test_empty_object():
-    with LogMixin.context():
+    with Logger.context():
         EmptyObject()
-        assert not LogMixin.logs
+        assert not Logger.logs
 
 
 # Using a min_value forces integers to be not-None
@@ -56,71 +56,71 @@ def test_all_of_no_restrictions(name: str, age: int, music: list[int]):
     model = AllNoRestrictions(name=name, age=age, music=music)
     assert model.name and model.age == age and model.music
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=None, age=age, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=name, age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=name, age=age, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=None, age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=name, age=None, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=None, age=age, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
     # Tests with falsy values
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name="", age=age, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=name, age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=name, age=age, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name="", age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=name, age=None, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name="", age=age, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
     # Test when no fields are provided
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=None, age=None, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name="", age=None, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=None, age=None, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name="", age=None, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
 
 # Using a min_value forces integers to be not-None
@@ -137,66 +137,66 @@ def test_all_of_with_restrictions(name: str, age: int, music: list[int]):
     model = AllWithRestrictions(name=name, age=age, music=music)
     assert model.name and model.age == age and model.music
 
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name=None, age=age, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name=name, age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
     model = AllWithRestrictions(name=name, age=age, music=None)
     assert model.name and model.age == age
 
-    with LogMixin.context():
+    with Logger.context():
         model = AllWithRestrictions(name=None, age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name=name, age=None, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name=None, age=age, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
     # Tests with falsy values
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name="", age=age, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name=name, age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
     model = AllWithRestrictions(name=name, age=age, music=[])
     assert model.name and model.age == age
 
-    with LogMixin.context():
+    with Logger.context():
         model = AllWithRestrictions(name="", age=None, music=music)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name=name, age=None, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllWithRestrictions(name="", age=age, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
     # Test when no fields are provided
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=None, age=None, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name="", age=None, music=None)
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name=None, age=None, music=[])
-        assert LogMixin.logs
+        assert Logger.logs
 
-    with LogMixin.context():
+    with Logger.context():
         AllNoRestrictions(name="", age=None, music=[])
-        assert LogMixin.logs
+        assert Logger.logs