hrxlib 0.1.0__tar.gz

hrxlib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2026 HRX Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hrxlib-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: hrxlib
+Version: 0.1.0
+Summary: HRX SDK for Python — types and helpers for HRX models
+Author-email: HRX Project <rverschuur@audit-io.fr>
+License-Expression: MIT
+Project-URL: Homepage, https://example.com/hrx
+Project-URL: Source, https://example.com/hrx/repo
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: jsonschema<5,>=4
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+Dynamic: license-file
+
+# HRX Python SDK (hrxlib)
+
+Paquet Python fournissant les modeles Pydantic et helpers pour le format HRX.
+
+Installation (locally):
+
+```bash
+pip install build
+cd src/hrx/sdk/python
+python -m build
+pip install dist/hrxlib-0.1.0-py3-none-any.whl
+```
+
+Usage:
+
+```python
+from pathlib import Path
+
+from hrx import HRX
+
+doc = HRX.from_path(Path("candidate.hrx"))
+candidate = doc.candidate
+payload_dict = doc.to_dict()
+payload_json = doc.to_json(indent=2)
+
+# Optional: strict JSON schema validation
+doc.validate_against_schema(Path("../../models/hrx-schema-v1.json"))
+```
+
+Erreurs SDK:
+
+- `HrxFileError`: probleme de lecture/ecriture fichier
+- `HrxParseError`: JSON invalide
+- `HrxValidationError`: payload non conforme aux modeles Pydantic
+- `HrxSchemaError`: payload non conforme au schema JSON
+- `HrxVersionError`: version HRX non supportee
+
+Licence: MIT

hrxlib-0.1.0/README.md

@@ -0,0 +1,38 @@
+# HRX Python SDK (hrxlib)
+
+Paquet Python fournissant les modeles Pydantic et helpers pour le format HRX.
+
+Installation (locally):
+
+```bash
+pip install build
+cd src/hrx/sdk/python
+python -m build
+pip install dist/hrxlib-0.1.0-py3-none-any.whl
+```
+
+Usage:
+
+```python
+from pathlib import Path
+
+from hrx import HRX
+
+doc = HRX.from_path(Path("candidate.hrx"))
+candidate = doc.candidate
+payload_dict = doc.to_dict()
+payload_json = doc.to_json(indent=2)
+
+# Optional: strict JSON schema validation
+doc.validate_against_schema(Path("../../models/hrx-schema-v1.json"))
+```
+
+Erreurs SDK:
+
+- `HrxFileError`: probleme de lecture/ecriture fichier
+- `HrxParseError`: JSON invalide
+- `HrxValidationError`: payload non conforme aux modeles Pydantic
+- `HrxSchemaError`: payload non conforme au schema JSON
+- `HrxVersionError`: version HRX non supportee
+
+Licence: MIT

hrxlib-0.1.0/hrx/__init__.py

@@ -0,0 +1,71 @@
+"""HRX Python SDK public API."""
+
+from .api import HRX
+from .errors import (
+    HrxError,
+    HrxFileError,
+    HrxParseError,
+    HrxSchemaError,
+    HrxValidationError,
+    HrxVersionError,
+)
+from .models import (
+    Award,
+    Bibliography,
+    BibliographyType,
+    Candidate,
+    Civility,
+    Contact,
+    ContactType,
+    ContractType,
+    Credentials,
+    Education,
+    Experience,
+    HrxMetadata,
+    Identity,
+    Level,
+    Location,
+    Mobility,
+    Preferences,
+    Project,
+    Reference,
+    RemoteType,
+    SkillDomain,
+    SkillItem,
+    Skills,
+)
+
+__all__ = [
+    "HRX",
+    "HrxError",
+    "HrxFileError",
+    "HrxParseError",
+    "HrxSchemaError",
+    "HrxValidationError",
+    "HrxVersionError",
+    "Candidate",
+    "HrxMetadata",
+    "Identity",
+    "Contact",
+    "Location",
+    "Skills",
+    "SkillDomain",
+    "SkillItem",
+    "Experience",
+    "Project",
+    "Education",
+    "Credentials",
+    "Award",
+    "Reference",
+    "Bibliography",
+    "Preferences",
+    "Civility",
+    "ContactType",
+    "Mobility",
+    "Level",
+    "ContractType",
+    "RemoteType",
+    "BibliographyType",
+]
+
+__version__ = "0.2.0"

hrxlib-0.1.0/hrx/__init__.pyi

@@ -0,0 +1,39 @@
+"""Stubs du package HRX: réexporte l'API publique du SDK."""
+from .api import HRX    # type: ignore
+from .errors import (
+    HrxError,   # type: ignore
+    HrxFileError,   # type: ignore
+    HrxParseError,   # type: ignore
+    HrxSchemaError,   # type: ignore
+    HrxValidationError,   # type: ignore
+    HrxVersionError,   # type: ignore
+)
+from .models import (
+    Award,   # type: ignore
+    Bibliography,   # type: ignore
+    BibliographyType,   # type: ignore
+    Candidate,   # type: ignore
+    Civility,   # type: ignore
+    Contact,   # type: ignore
+    ContactType,   # type: ignore
+    ContractType,   # type: ignore
+    Credentials,   # type: ignore
+    Education,   # type: ignore
+    Experience,   # type: ignore
+    HrxMetadata,   # type: ignore
+    Identity,   # type: ignore
+    Level,   # type: ignore
+    Location,   # type: ignore
+    Mobility,   # type: ignore
+    Preferences,   # type: ignore
+    Project,   # type: ignore
+    Reference,   # type: ignore
+    RemoteType,   # type: ignore
+    SkillDomain,   # type: ignore
+    SkillItem,   # type: ignore
+    Skills,   # type: ignore
+)
+
+__all__: list[str]
+
+__version__: str

hrxlib-0.1.0/hrx/api.py

@@ -0,0 +1,171 @@
+"""High-level API for reading and writing HRX documents."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+from pydantic import ValidationError
+
+from .errors import HrxFileError, HrxParseError, HrxSchemaError, HrxValidationError, HrxVersionError
+from .models import Candidate
+
+
+class HRX:
+    """Load, validate and serialize an HRX document."""
+
+    def __init__(self, source: Path | str | dict[str, Any] | Candidate) -> None:
+        self.candidate = self._load_candidate(source)
+
+    @classmethod
+    def from_path(cls, path: Path | str) -> "HRX":
+        """
+        Load an HRX document from a file.
+
+        Args:
+            path: Path to the HRX file.
+
+        Returns:
+            HRX document.
+        """
+        if isinstance(path, str):
+            path = Path(path)
+        return cls(path)
+
+    @classmethod
+    def from_json(cls, payload: str) -> "HRX":
+        """
+        Load an HRX document from a JSON string.
+
+        Args:
+            payload: JSON string representing the HRX document.
+
+        Returns:
+            HRX document.
+        """
+        return cls(payload)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> "HRX":
+        """
+        Load an HRX document from a dictionary.
+
+        Args:
+            payload: Dictionary representing the HRX document.
+
+        Returns:
+            HRX document.
+        """
+        return cls(payload)
+
+    @staticmethod
+    def _load_candidate(source: Path | str | dict[str, Any] | Candidate) -> Candidate:
+        if isinstance(source, Candidate):
+            candidate = source
+        elif isinstance(source, Path):
+            candidate = HRX._load_from_path(source)
+        elif isinstance(source, dict):
+            candidate = HRX._load_from_dict(source)
+        else:
+            source_path = Path(source)
+            if source_path.exists():
+                candidate = HRX._load_from_path(source_path)
+            else:
+                candidate = HRX._load_from_json(source)
+
+        version = candidate.hrx.version
+        if version != "1.0":
+            raise HrxVersionError(
+                f"Unsupported HRX version '{version}'. Only version '1.0' is currently supported.",
+            )
+        return candidate
+
+    @staticmethod
+    def _load_from_path(path: Path) -> Candidate:
+        try:
+            payload = path.read_text(encoding="utf-8")
+        except OSError as exc:
+            raise HrxFileError(f"Cannot read HRX file: {path}") from exc
+        return HRX._load_from_json(payload)
+
+    @staticmethod
+    def _load_from_json(payload: str) -> Candidate:
+        try:
+            parsed = json.loads(payload)
+        except json.JSONDecodeError as exc:
+            raise HrxParseError(f"Invalid HRX JSON payload: {exc}") from exc
+        if not isinstance(parsed, dict):
+            raise HrxParseError("HRX payload must be a JSON object.")
+        return HRX._load_from_dict(cast(dict[str, Any], parsed))
+
+    @staticmethod
+    def _load_from_dict(payload: dict[str, Any]) -> Candidate:
+        try:
+            return Candidate.model_validate(payload)
+        except ValidationError as exc:
+            raise HrxValidationError(
+                "HRX payload does not match the expected model.",
+                details=exc.errors()
+            ) from exc
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serialize the HRX document to a dictionary.
+
+        Args:
+            None
+
+        Returns:
+            Dictionary representing the HRX document.
+        """
+        return self.candidate.model_dump(mode="json", by_alias=True, exclude_none=True)
+
+    def to_json(self, *, indent: int = 2) -> str:
+        """
+        Serialize the HRX document to a JSON string.
+
+        Args:
+            indent: Number of spaces for indentation in the JSON string.
+
+        Returns:
+            JSON string representing the HRX document.
+        """
+        return self.candidate.model_dump_json(by_alias=True, exclude_none=True, indent=indent)
+
+    def validate_against_schema(self, schema: dict[str, Any] | str | Path) -> None:
+        """
+        Validate the HRX document against a JSON schema.
+
+        Args:
+            schema: JSON schema to validate against.
+
+        Returns:
+            None
+        """
+        try:
+            from jsonschema import validate as jsonschema_validate  #pylint: disable=import-outside-toplevel
+            from jsonschema.exceptions import ValidationError as JsonSchemaValidationError  #pylint: disable=import-outside-toplevel
+        except ImportError as exc:
+            raise HrxSchemaError(
+                "jsonschema package is required to validate against a JSON schema."
+            ) from exc
+
+        if isinstance(schema, dict):
+            schema_data = schema
+        else:
+            schema_path = Path(schema)
+            try:
+                schema_data = json.loads(schema_path.read_text(encoding="utf-8"))
+            except OSError as exc:
+                raise HrxSchemaError(f"Cannot read schema file: {schema_path}") from exc
+            except json.JSONDecodeError as exc:
+                raise HrxSchemaError(f"Invalid schema JSON: {exc}") from exc
+
+        try:
+            jsonschema_validate(instance=self.to_dict(), schema=schema_data)
+        except JsonSchemaValidationError as exc:
+            raise HrxSchemaError(
+                "HRX payload does not match the provided JSON schema.",
+                details=exc.message
+            ) from exc

hrxlib-0.1.0/hrx/api.pyi

@@ -0,0 +1,17 @@
+from pathlib import Path
+from typing import Any
+
+from .models import Candidate
+
+class HRX:
+    candidate: Candidate
+    def __init__(self, source: Path | str | dict[str, Any] | Candidate) -> None: ...
+    @classmethod
+    def from_path(cls, path: Path | str) -> HRX: ...
+    @classmethod
+    def from_json(cls, payload: str) -> HRX: ...
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> HRX: ...
+    def to_dict(self) -> dict[str, Any]: ...
+    def to_json(self, *, indent: int = 2) -> str: ...
+    def validate_against_schema(self, schema: dict[str, Any] | str | Path) -> None: ...

hrxlib-0.1.0/hrx/errors.py

@@ -0,0 +1,33 @@
+"""Custom exceptions for the HRX Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class HrxError(Exception):
+    """Base exception for all SDK errors."""
+
+    def __init__(self, message: str, *, details: Any | None = None) -> None:
+        super().__init__(message)
+        self.details = details
+
+
+class HrxFileError(HrxError):
+    """Raised when a file cannot be read or written."""
+
+
+class HrxParseError(HrxError):
+    """Raised when HRX payload is not valid JSON."""
+
+
+class HrxValidationError(HrxError):
+    """Raised when payload does not match the Pydantic HRX model."""
+
+
+class HrxSchemaError(HrxError):
+    """Raised when payload does not match a JSON schema."""
+
+
+class HrxVersionError(HrxError):
+    """Raised when document version is not supported."""

hrxlib-0.1.0/hrx/errors.pyi

@@ -0,0 +1,11 @@
+from typing import Any
+
+class HrxError(Exception):
+    details: Any | None
+    def __init__(self, message: str, *, details: Any | None = None) -> None: ...
+
+class HrxFileError(HrxError): ...
+class HrxParseError(HrxError): ...
+class HrxValidationError(HrxError): ...
+class HrxSchemaError(HrxError): ...
+class HrxVersionError(HrxError): ...

hrxlib-0.1.0/hrx/models.py

@@ -0,0 +1,222 @@
+"""Pydantic models aligned with HRX v1 JSON schema."""
+
+from __future__ import annotations
+
+from datetime import date
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field, HttpUrl, StringConstraints
+from typing_extensions import Annotated
+
+YearMonth = Annotated[str, StringConstraints(pattern=r"^\d{4}-\d{2}$")]
+CountryCode = Annotated[str, StringConstraints(pattern=r"^[A-Z]{2}$")]
+LanguageCode = Annotated[str, StringConstraints(pattern=r"^[a-z]{2}$")]
+VersionCode = Annotated[str, StringConstraints(pattern=r"^\d+\.\d+$")]
+
+
+class StrictModel(BaseModel):
+    """Shared model config: no unknown keys and alias support."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+
+class Civility(str, Enum):
+    """Common civility titles."""
+    MR = "Mr."
+    MRS = "Mrs."
+    DR = "Dr."
+    PROF = "Prof."
+    MX = "Mx."
+    ME = "Me"
+    OTHER = "other"
+
+
+class ContactType(str, Enum):
+    """Types of contact methods."""
+    EMAIL = "email"
+    PHONE = "phone"
+    LINKEDIN = "linkedin"
+    GITHUB = "github"
+    X = "x"
+    FACEBOOK = "facebook"
+    INSTAGRAM = "instagram"
+    WEBSITE = "website"
+    OTHER = "other"
+
+
+class Mobility(str, Enum):
+    """Types of mobility."""
+    LOCAL = "local"
+    REGIONAL = "regional"
+    NATIONAL = "national"
+    INTERNATIONAL = "international"
+
+
+class Level(str, Enum):
+    """Proficiency levels."""
+    BEGINNER = "beginner"
+    INTERMEDIATE = "intermediate"
+    ADVANCED = "advanced"
+    EXPERT = "expert"
+
+
+class ContractType(str, Enum):
+    """Types of contract."""
+    PERMANENT = "permanent"
+    FIXED_TERM = "fixed-term"
+    FREELANCE = "freelance"
+    MISSION = "mission"
+    INTERNSHIP = "internship"
+    APPRENTICESHIP = "apprenticeship"
+
+
+class RemoteType(str, Enum):
+    """Types of remote work."""
+    NO = "no"
+    PARTIAL = "partial"
+    FULL = "full"
+
+
+class BibliographyType(str, Enum):
+    """Types of bibliography entries."""
+    ARTICLE = "article"
+    BOOK = "book"
+    CONFERENCE = "conference"
+    REPORT = "report"
+    OTHER = "other"
+
+
+class HrxMetadata(StrictModel):
+    """HRX metadata."""
+    version: VersionCode
+    schema_uri: HttpUrl = Field(alias="schema")
+    issuer: str | None = None
+    date: date
+    lang: LanguageCode | None = None
+
+
+class Contact(StrictModel):
+    """Contact information."""
+    type: ContactType
+    value: str
+    primary: bool | None = None
+
+
+class Location(StrictModel):
+    """Location information."""
+    city: str | None = None
+    postal_code: str | None = None
+    country: CountryCode | None = None
+    mobility: Mobility | None = None
+
+
+class Identity(StrictModel):
+    """Identity information."""
+    civility: Civility | None = None
+    last_name: str
+    first_name: str
+    contacts: list[Contact] | None = None
+    location: Location | None = None
+
+
+class SkillItem(StrictModel):
+    """Skill item."""
+    label: str
+    level: Level | None = None
+
+
+class SkillDomain(StrictModel):
+    """Skill domain."""
+    domain: str
+    items: list[SkillItem]
+
+
+class Skills(StrictModel):
+    """Skills information."""
+    hard: list[SkillDomain] | None = None
+    soft: list[SkillDomain] | None = None
+
+
+class Period(StrictModel):
+    """Period information."""
+    start: YearMonth
+    end: YearMonth | None = None
+
+
+class Project(StrictModel):
+    """Project information."""
+    title: str
+    description: str | None = None
+    role: str | None = None
+    period: Period | None = None
+    url: HttpUrl | None = None
+
+
+class Experience(StrictModel):
+    """Experience information."""
+    position: str
+    organisation: str
+    sector: str | None = None
+    period: Period
+    description: str | None = None
+    achievements: list[str] | None = None
+    projects: list[Project] | None = None
+
+
+class Education(StrictModel):
+    """Education information."""
+    title: str
+    institution: str
+    year: int = Field(ge=1900, le=2100)
+    certification: bool | None = None
+
+
+class Award(StrictModel):
+    """Award information."""
+    title: str
+    issuer: str | None = None
+    year: int | None = None
+    description: str | None = None
+
+
+class Reference(StrictModel):
+    """Reference information."""
+    name: str
+    position: str | None = None
+    organisation: str | None = None
+    contact: str | None = None
+
+
+class Bibliography(StrictModel):
+    """Bibliography information."""
+    title: str
+    authors: list[str] | None = None
+    year: int | None = None
+    type: BibliographyType | None = None
+    url: HttpUrl | None = None
+
+
+class Credentials(StrictModel):
+    """Credentials information."""
+    awards: list[Award] | None = None
+    references: list[Reference] | None = None
+    bibliography: list[Bibliography] | None = None
+
+
+class Preferences(StrictModel):
+    """Preferences information."""
+    availability: date | None = None
+    contracts: list[ContractType] | None = None
+    remote: RemoteType | None = None
+    salary_min: int | None = None
+
+
+class Candidate(StrictModel):
+    """Candidate information."""
+    hrx: HrxMetadata = Field(alias="$hrx")
+    identity: Identity
+    skills: Skills | None = None
+    experiences: list[Experience] | None = None
+    education: list[Education] | None = None
+    credentials: Credentials | None = None
+    preferences: Preferences | None = None

hrxlib-0.1.0/hrx/models.pyi

@@ -0,0 +1,200 @@
+"""Stubs des modèles Pydantic utilisés par le SDK HRX.
+
+Ce fichier décrit l'API de type des modèles définis dans `models.py`.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from enum import Enum
+from typing import List, Optional, ClassVar
+
+from pydantic import BaseModel, HttpUrl, ConfigDict
+
+# Types simples (les contraintes sont appliquées au runtime dans `models.py`).
+YearMonth = str
+CountryCode = str
+LanguageCode = str
+VersionCode = str
+
+
+class StrictModel(BaseModel):   # pylint: disable=C0115
+    model_config: ClassVar[ConfigDict]
+
+
+class Civility(str, Enum):   # pylint: disable=C0115
+    MR: str
+    MRS: str
+    DR: str
+    PROF: str
+    MX: str
+    ME: str
+    OTHER: str
+
+
+class ContactType(str, Enum):   # pylint: disable=C0115
+    EMAIL: str
+    PHONE: str
+    LINKEDIN: str
+    GITHUB: str
+    X: str
+    FACEBOOK: str
+    INSTAGRAM: str
+    WEBSITE: str
+    OTHER: str
+
+
+class Mobility(str, Enum):   # pylint: disable=C0115
+    LOCAL: str
+    REGIONAL: str
+    NATIONAL: str
+    INTERNATIONAL: str
+
+
+class Level(str, Enum):   # pylint: disable=C0115
+    BEGINNER: str
+    INTERMEDIATE: str
+    ADVANCED: str
+    EXPERT: str
+
+
+class ContractType(str, Enum):   # pylint: disable=C0115
+    PERMANENT: str
+    FIXED_TERM: str
+    FREELANCE: str
+    MISSION: str
+    INTERNSHIP: str
+    APPRENTICESHIP: str
+
+
+class RemoteType(str, Enum):   # pylint: disable=C0115
+    NO: str
+    PARTIAL: str
+    FULL: str
+
+
+class BibliographyType(str, Enum):   # pylint: disable=C0115
+    ARTICLE: str
+    BOOK: str
+    CONFERENCE: str
+    REPORT: str
+    OTHER: str
+
+
+class HrxMetadata(StrictModel):   # pylint: disable=C0115
+    version: VersionCode
+    schema_uri: HttpUrl
+    issuer: Optional[str]
+    date: date
+    lang: Optional[LanguageCode]
+
+
+class Contact(StrictModel):   # pylint: disable=C0115
+    type: ContactType
+    value: str
+    primary: Optional[bool]
+
+
+class Location(StrictModel):   # pylint: disable=C0115
+    city: Optional[str]
+    postal_code: Optional[str]
+    country: Optional[CountryCode]
+    mobility: Optional[Mobility]
+
+
+class Identity(StrictModel):   # pylint: disable=C0115
+    civility: Optional[Civility]
+    last_name: str
+    first_name: str
+    contacts: Optional[List[Contact]]
+    location: Optional[Location]
+
+
+class SkillItem(StrictModel):   # pylint: disable=C0115
+    label: str
+    level: Optional[Level]
+
+
+class SkillDomain(StrictModel):   # pylint: disable=C0115
+    domain: str
+    items: List[SkillItem]
+
+
+class Skills(StrictModel):   # pylint: disable=C0115
+    hard: Optional[List[SkillDomain]]
+    soft: Optional[List[SkillDomain]]
+
+
+class Period(StrictModel):   # pylint: disable=C0115
+    start: YearMonth
+    end: Optional[YearMonth]
+
+
+class Project(StrictModel):   # pylint: disable=C0115
+    title: str
+    description: Optional[str]
+    role: Optional[str]
+    period: Optional[Period]
+    url: Optional[HttpUrl]
+
+
+class Experience(StrictModel):   # pylint: disable=C0115
+    position: str
+    organisation: str
+    sector: Optional[str]
+    period: Period
+    description: Optional[str]
+    achievements: Optional[List[str]]
+    projects: Optional[List[Project]]
+
+
+class Education(StrictModel):   # pylint: disable=C0115
+    title: str
+    institution: str
+    year: int
+    certification: Optional[bool]
+
+
+class Award(StrictModel):   # pylint: disable=C0115
+    title: str
+    issuer: Optional[str]
+    year: Optional[int]
+    description: Optional[str]
+
+
+class Reference(StrictModel):   # pylint: disable=C0115
+    name: str
+    position: Optional[str]
+    organisation: Optional[str]
+    contact: Optional[str]
+
+
+class Bibliography(StrictModel):   # pylint: disable=C0115
+    title: str
+    authors: Optional[List[str]]
+    year: Optional[int]
+    type: Optional[BibliographyType]
+    url: Optional[HttpUrl]
+
+
+class Credentials(StrictModel):   # pylint: disable=C0115
+    awards: Optional[List[Award]]
+    references: Optional[List[Reference]]
+    bibliography: Optional[List[Bibliography]]
+
+
+class Preferences(StrictModel):   # pylint: disable=C0115
+    availability: Optional[date]
+    contracts: Optional[List[ContractType]]
+    remote: Optional[RemoteType]
+    salary_min: Optional[int]
+
+
+class Candidate(StrictModel):   # pylint: disable=C0115
+    hrx: HrxMetadata
+    identity: Identity
+    skills: Optional[Skills]
+    experiences: Optional[List[Experience]]
+    education: Optional[List[Education]]
+    credentials: Optional[Credentials]
+    preferences: Optional[Preferences]

hrxlib-0.1.0/hrxlib.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: hrxlib
+Version: 0.1.0
+Summary: HRX SDK for Python — types and helpers for HRX models
+Author-email: HRX Project <rverschuur@audit-io.fr>
+License-Expression: MIT
+Project-URL: Homepage, https://example.com/hrx
+Project-URL: Source, https://example.com/hrx/repo
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: jsonschema<5,>=4
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+Dynamic: license-file
+
+# HRX Python SDK (hrxlib)
+
+Paquet Python fournissant les modeles Pydantic et helpers pour le format HRX.
+
+Installation (locally):
+
+```bash
+pip install build
+cd src/hrx/sdk/python
+python -m build
+pip install dist/hrxlib-0.1.0-py3-none-any.whl
+```
+
+Usage:
+
+```python
+from pathlib import Path
+
+from hrx import HRX
+
+doc = HRX.from_path(Path("candidate.hrx"))
+candidate = doc.candidate
+payload_dict = doc.to_dict()
+payload_json = doc.to_json(indent=2)
+
+# Optional: strict JSON schema validation
+doc.validate_against_schema(Path("../../models/hrx-schema-v1.json"))
+```
+
+Erreurs SDK:
+
+- `HrxFileError`: probleme de lecture/ecriture fichier
+- `HrxParseError`: JSON invalide
+- `HrxValidationError`: payload non conforme aux modeles Pydantic
+- `HrxSchemaError`: payload non conforme au schema JSON
+- `HrxVersionError`: version HRX non supportee
+
+Licence: MIT

hrxlib-0.1.0/hrxlib.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+hrx/__init__.py
+hrx/__init__.pyi
+hrx/api.py
+hrx/api.pyi
+hrx/errors.py
+hrx/errors.pyi
+hrx/models.py
+hrx/models.pyi
+hrx/py.typed
+hrxlib.egg-info/PKG-INFO
+hrxlib.egg-info/SOURCES.txt
+hrxlib.egg-info/dependency_links.txt
+hrxlib.egg-info/requires.txt
+hrxlib.egg-info/top_level.txt
+tests/test_hrx_api.py

hrxlib-0.1.0/hrxlib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hrxlib-0.1.0/hrxlib.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pydantic<3,>=2
+jsonschema<5,>=4
+
+[test]
+pytest<9,>=8

hrxlib-0.1.0/hrxlib.egg-info/top_level.txt

@@ -0,0 +1 @@
+hrx

hrxlib-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hrxlib"
+version = "0.1.0"
+description = "HRX SDK for Python — types and helpers for HRX models"
+readme = "README.md"
+authors = [{name = "HRX Project", email = "rverschuur@audit-io.fr"}]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.8"
+dependencies = [
+    "pydantic>=2,<3",
+    "jsonschema>=4,<5",
+]
+classifiers = [
+	"Programming Language :: Python :: 3",
+	"Programming Language :: Python :: 3 :: Only",
+	"Programming Language :: Python :: 3.8",
+	"Programming Language :: Python :: 3.9",
+	"Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+hrx = ["*.pyi", "py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hrx*"]
+
+[project.urls]
+"Homepage" = "https://example.com/hrx"
+"Source" = "https://example.com/hrx/repo"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8,<9",
+]

hrxlib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hrxlib-0.1.0/tests/test_hrx_api.py

@@ -0,0 +1,108 @@
+"""
+Tests for the HRX Python SDK.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from hrx import HRX
+from hrx.errors import (
+    HrxFileError,
+    HrxParseError,
+    HrxSchemaError,
+    HrxValidationError,
+    HrxVersionError,
+)
+
+
+def test_load_from_path_success(hrx_sample_file: Path) -> None:
+    """Test loading an HRX document from a file."""
+    doc = HRX.from_path(hrx_sample_file)
+
+    assert doc.candidate.identity.first_name == "Claire"
+    assert doc.candidate.hrx.version == "1.0"
+
+
+def test_round_trip_dict_and_json(sample_payload: dict[str, Any]) -> None:
+    """Test round-trip serialization to dict and JSON."""
+    doc = HRX.from_dict(sample_payload)
+
+    as_dict = doc.to_dict()
+    as_json = doc.to_json()
+    parsed_back = json.loads(as_json)
+
+    assert as_dict["$hrx"]["version"] == "1.0"
+    assert parsed_back["identity"]["last_name"] == "Martin"
+
+
+def test_invalid_json_raises_parse_error() -> None:
+    """Test parsing invalid JSON."""
+    with pytest.raises(HrxParseError):
+        HRX.from_json("{not-valid-json}")
+
+
+def test_non_existing_file_raises_file_error() -> None:
+    """Test loading from a non-existing file."""
+    with pytest.raises(HrxFileError):
+        HRX.from_path(Path("does-not-exist.hrx"))
+
+
+def test_missing_required_field_raises_validation_error(
+        sample_payload: dict[str, Any]
+    ) -> None:
+    """Test loading a document with missing required fields."""
+    payload = dict(sample_payload)
+    payload.pop("identity", None)
+
+    with pytest.raises(HrxValidationError):
+        HRX.from_dict(payload)
+
+
+def test_unsupported_version_raises_version_error(
+        sample_payload: dict[str, Any]
+    ) -> None:
+    """Test loading a document with an unsupported HRX version."""
+    payload = dict(sample_payload)
+    hrx_meta = dict(sample_payload["$hrx"])
+    hrx_meta["version"] = "2.0"
+    payload["$hrx"] = hrx_meta
+
+    with pytest.raises(HrxVersionError):
+        HRX.from_dict(payload)
+
+
+def test_schema_validation_success(
+        hrx_sample_file: Path, sample_schema_path: Path
+    ) -> None:
+    """Test successful schema validation."""
+    doc = HRX.from_path(hrx_sample_file)
+
+    doc.validate_against_schema(sample_schema_path)
+
+
+def test_schema_validation_failure_raises_schema_error(
+        sample_payload: dict[str, Any]
+    ) -> None:
+    """Test schema validation failure."""
+    invalid_doc = HRX.from_dict(sample_payload)
+    strict_schema = {
+        "type": "object",
+        "required": ["identity"],
+        "properties": {
+            "identity": {
+                "type": "object",
+                "required": ["last_name", "first_name"],
+                "properties": {
+                    "last_name": {"type": "string", "const": "SHOULD_FAIL"},
+                    "first_name": {"type": "string"},
+                },
+            }
+        },
+    }
+
+    with pytest.raises(HrxSchemaError):
+        invalid_doc.validate_against_schema(strict_schema)