feat: address review feedback on Python SDK

- Remove copied config-schema.json, load from repo root as single source of truth
- Fix validator dialect: use Draft4Validator to match schema's draft-04 declaration
- Fix timestamp serialization to use 'Z' suffix for UTC, matching Go's RFC 3339
- Fix FileMetadata.mtime to always serialize (matches Go's non-pointer time.Time)
- Migrate from setup.py to pyproject.toml
- Fix import sorting (ruff)

Closes #138

Signed-off-by: pradhyum6144 <pradhyum314@gmail.com>

Author: pradhyum6144

specs-python/modelpack/v1/__init__.py

@@ -14,43 +14,43 @@
 
 """ModelPack Python SDK - CNCF standard for packaging and distributing AI models."""
 
+from modelpack.v1.annotations import (
+    ANNOTATION_FILE_METADATA,
+    ANNOTATION_FILEPATH,
+    ANNOTATION_MEDIA_TYPE_UNTESTED,
+    FileMetadata,
+)
 from modelpack.v1.config import (
+    Modality,
     Model,
     ModelCapabilities,
     ModelConfig,
     ModelDescriptor,
     ModelFS,
-    Modality,
-)
-from modelpack.v1.annotations import (
-    ANNOTATION_FILEPATH,
-    ANNOTATION_FILE_METADATA,
-    ANNOTATION_MEDIA_TYPE_UNTESTED,
-    FileMetadata,
 )
 from modelpack.v1.mediatype import (
     ARTIFACT_TYPE_MODEL_MANIFEST,
-    MEDIA_TYPE_MODEL_CONFIG,
-    MEDIA_TYPE_MODEL_WEIGHT_RAW,
-    MEDIA_TYPE_MODEL_WEIGHT,
-    MEDIA_TYPE_MODEL_WEIGHT_GZIP,
-    MEDIA_TYPE_MODEL_WEIGHT_ZSTD,
-    MEDIA_TYPE_MODEL_WEIGHT_CONFIG_RAW,
-    MEDIA_TYPE_MODEL_WEIGHT_CONFIG,
-    MEDIA_TYPE_MODEL_WEIGHT_CONFIG_GZIP,
-    MEDIA_TYPE_MODEL_WEIGHT_CONFIG_ZSTD,
-    MEDIA_TYPE_MODEL_DOC_RAW,
-    MEDIA_TYPE_MODEL_DOC,
-    MEDIA_TYPE_MODEL_DOC_GZIP,
-    MEDIA_TYPE_MODEL_DOC_ZSTD,
-    MEDIA_TYPE_MODEL_CODE_RAW,
     MEDIA_TYPE_MODEL_CODE,
     MEDIA_TYPE_MODEL_CODE_GZIP,
+    MEDIA_TYPE_MODEL_CODE_RAW,
     MEDIA_TYPE_MODEL_CODE_ZSTD,
-    MEDIA_TYPE_MODEL_DATASET_RAW,
+    MEDIA_TYPE_MODEL_CONFIG,
     MEDIA_TYPE_MODEL_DATASET,
     MEDIA_TYPE_MODEL_DATASET_GZIP,
+    MEDIA_TYPE_MODEL_DATASET_RAW,
     MEDIA_TYPE_MODEL_DATASET_ZSTD,
+    MEDIA_TYPE_MODEL_DOC,
+    MEDIA_TYPE_MODEL_DOC_GZIP,
+    MEDIA_TYPE_MODEL_DOC_RAW,
+    MEDIA_TYPE_MODEL_DOC_ZSTD,
+    MEDIA_TYPE_MODEL_WEIGHT,
+    MEDIA_TYPE_MODEL_WEIGHT_CONFIG,
+    MEDIA_TYPE_MODEL_WEIGHT_CONFIG_GZIP,
+    MEDIA_TYPE_MODEL_WEIGHT_CONFIG_RAW,
+    MEDIA_TYPE_MODEL_WEIGHT_CONFIG_ZSTD,
+    MEDIA_TYPE_MODEL_WEIGHT_GZIP,
+    MEDIA_TYPE_MODEL_WEIGHT_RAW,
+    MEDIA_TYPE_MODEL_WEIGHT_ZSTD,
 )
 from modelpack.v1.validator import validate_config
 

specs-python/modelpack/v1/annotations.py

@@ -16,8 +16,8 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from datetime import datetime
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
 
 # Annotation key for the file path of the layer.
 ANNOTATION_FILEPATH = "org.cncf.model.filepath"
@@ -29,6 +29,14 @@
 ANNOTATION_MEDIA_TYPE_UNTESTED = "org.cncf.model.file.mediatype.untested"
 
 
+def _format_datetime(dt: datetime) -> str:
+    """Format a datetime as RFC 3339 with 'Z' suffix for UTC, matching Go."""
+    s = dt.isoformat()
+    if s.endswith("+00:00"):
+        s = s[:-6] + "Z"
+    return s
+
+
 @dataclass
 class FileMetadata:
     """Represents the metadata of a file.
@@ -41,31 +49,33 @@ class FileMetadata:
     uid: int = 0
     gid: int = 0
     size: int = 0
-    mod_time: datetime | None = None
+    mod_time: datetime = field(
+        default_factory=lambda: datetime(1, 1, 1, tzinfo=timezone.utc)
+    )
     typeflag: int = 0
 
     def to_dict(self) -> dict:
-        """Serialize to a dict matching the JSON field names."""
-        d: dict = {
+        """Serialize to a dict matching the JSON field names.
+
+        All fields are always present, matching Go's FileMetadata
+        which has no omitempty tags.
+        """
+        return {
             "name": self.name,
             "mode": self.mode,
             "uid": self.uid,
             "gid": self.gid,
             "size": self.size,
+            "mtime": _format_datetime(self.mod_time),
             "typeflag": self.typeflag,
         }
-        if self.mod_time is not None:
-            d["mtime"] = self.mod_time.isoformat()
-        return d
 
     @classmethod
     def from_dict(cls, data: dict) -> FileMetadata:
         """Deserialize from a dict with JSON field names."""
         mod_time = None
         if "mtime" in data:
-            mod_time = datetime.fromisoformat(
-                data["mtime"].replace("Z", "+00:00")
-            )
+            mod_time = datetime.fromisoformat(data["mtime"].replace("Z", "+00:00"))
         return cls(
             name=data.get("name", ""),
             mode=data.get("mode", 0),

specs-python/modelpack/v1/config-schema.json

@@ -23,6 +23,14 @@
 from typing import Optional
 
 
+def _format_datetime(dt: datetime) -> str:
+    """Format a datetime as RFC 3339 with 'Z' suffix for UTC, matching Go."""
+    s = dt.isoformat()
+    if s.endswith("+00:00"):
+        s = s[:-6] + "Z"
+    return s
+
+
 class Modality(str, Enum):
     """Defines the input and output types of the model.
 
@@ -60,7 +68,7 @@ def to_dict(self) -> dict:
         if self.output_types is not None:
             d["outputTypes"] = [m.value for m in self.output_types]
         if self.knowledge_cutoff is not None:
-            d["knowledgeCutoff"] = self.knowledge_cutoff.isoformat()
+            d["knowledgeCutoff"] = _format_datetime(self.knowledge_cutoff)
         if self.reasoning is not None:
             d["reasoning"] = self.reasoning
         if self.tool_usage is not None:
@@ -192,7 +200,7 @@ def to_dict(self) -> dict:
         """Serialize to a dict matching the JSON schema field names."""
         d: dict = {}
         if self.created_at is not None:
-            d["createdAt"] = self.created_at.isoformat()
+            d["createdAt"] = _format_datetime(self.created_at)
         if self.authors is not None:
             d["authors"] = self.authors
         if self.family:

specs-python/modelpack/v1/config.py

@@ -14,24 +14,26 @@
 
 """JSON schema validation for ModelPack configs.
 
-Uses the same config-schema.json as the Go validator to ensure
-consistent validation behavior across languages.
+Loads config-schema.json from the repo root (schema/config-schema.json)
+as the single source of truth, matching the Go validator.
 """
 
 from __future__ import annotations
 
-import importlib.resources
 import json
+from pathlib import Path
 
-from jsonschema import Draft202012Validator, FormatChecker
+from jsonschema import Draft4Validator, FormatChecker
 
 
 def _load_schema() -> dict:
-    """Load and return the config JSON schema."""
-    schema_file = importlib.resources.files("modelpack.v1").joinpath(
-        "config-schema.json"
+    """Load and return the config JSON schema from the repo root."""
+    schema_path = (
+        Path(__file__).resolve().parent.parent.parent.parent
+        / "schema"
+        / "config-schema.json"
     )
-    with schema_file.open(encoding="utf-8") as f:
+    with schema_path.open(encoding="utf-8") as f:
         return json.load(f)
 
 
@@ -51,4 +53,4 @@ def validate_config(data: dict | str) -> None:
 
     schema = _load_schema()
     format_checker = FormatChecker()
-    Draft202012Validator(schema, format_checker=format_checker).validate(data)
+    Draft4Validator(schema, format_checker=format_checker).validate(data)