plansolve 0.25.2__tar.gz → 0.25.4__tar.gz

{plansolve-0.25.2/plansolve.egg-info → plansolve-0.25.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plansolve
-Version: 0.25.2
+Version: 0.25.4
 Summary: Python SDK for PlanSolve optimization API
 Author-email: PlanSolve <support@plansolve.app>
 License: MIT

{plansolve-0.25.2 → plansolve-0.25.4}/plansolve/__init__.py

@@ -5,7 +5,6 @@ A Python client library for the PlanSolve optimization API.
 """
 
 from .client import PlanSolveClient
-from .field_service.constraint_weight import ConstraintWeight
 from .field_service.api_client import FieldServiceApiClient
 from .professional_services.api_client import ProfessionalServicesApiClient
 
@@ -16,7 +15,6 @@ from .field_service.models import (
     Vehicle,
     Visit,
     SolverOptions,
-    Weights,
     FieldServiceRequest,
     ScheduledVehicle,
     ScheduledVisit,
@@ -35,20 +33,18 @@ from .professional_services.models import (
     ProfessionalServicesResultResponse,
 )
 
-__version__ = "0.25.2"
+__version__ = "0.25.4"
 
 __all__ = [
     "PlanSolveClient",
     "FieldServiceApiClient",
     "ProfessionalServicesApiClient",
-    "ConstraintWeight",
     # Field Service Models
     "Shift",
     "TimeWindow",
     "Vehicle",
     "Visit",
     "SolverOptions",
-    "Weights",
     "FieldServiceRequest",
     "ScheduledVehicle",
     "ScheduledVisit",

plansolve-0.25.4/plansolve/errors.py

@@ -0,0 +1,91 @@
+"""HTTP error handling helpers for the PlanSolve SDK.
+
+The PlanSolve API documents three distinct error body shapes:
+
+- ``ValidationProblemDetails`` (400)::
+
+      {"type", "title", "status", "detail", "instance",
+       "errors": {"<field>": ["<msg>", ...]}}
+
+- ``ErrorResponse`` (402/422)::
+
+      {"error": "<string>"}
+
+- ``ProblemDetails`` (401/403/502)::
+
+      {"type", "title", "status", "detail", "instance"}
+
+``extract_error_message`` turns any of these into a short human-readable
+string instead of dumping the raw JSON body at the caller.
+"""
+
+import json
+
+import requests
+
+
+def extract_error_message(body: str) -> str:
+    """Extract a clean, human-readable message from an HTTP error body.
+
+    Priority order (highest first): validation ``errors`` > ``error`` >
+    ``detail`` > ``title`` > the raw body.
+
+    Args:
+        body: The raw response body text.
+
+    Returns:
+        A concise error message derived from the body, or the raw body when
+        no recognized field is present or the body is not valid JSON.
+    """
+    try:
+        parsed = json.loads(body)
+    except (ValueError, TypeError):
+        return body
+
+    if isinstance(parsed, dict):
+        errors = parsed.get("errors")
+        if isinstance(errors, dict):
+            messages = []
+            for field, msgs in errors.items():
+                if isinstance(msgs, list):
+                    for msg in msgs:
+                        messages.append(f"{field}: {msg}")
+            messages.sort()
+            if messages:
+                return "; ".join(messages)
+
+        error = parsed.get("error")
+        if isinstance(error, str) and error:
+            return error
+
+        detail = parsed.get("detail")
+        if isinstance(detail, str) and detail:
+            return detail
+
+        title = parsed.get("title")
+        if isinstance(title, str) and title:
+            return title
+
+    return body
+
+
+def raise_for_status(response: requests.Response) -> None:
+    """Raise ``requests.HTTPError`` with a clean message for non-2xx responses.
+
+    Behaves like ``response.raise_for_status()`` but replaces the raw JSON body
+    in the exception message with the output of :func:`extract_error_message`,
+    while preserving the HTTP status code.
+
+    Args:
+        response: The response to validate.
+
+    Raises:
+        requests.HTTPError: If the response has a 4xx or 5xx status code.
+    """
+    if response.status_code < 400:
+        return
+
+    message = extract_error_message(response.text)
+    raise requests.HTTPError(
+        f"HTTP {response.status_code}: {message}", response=response
+    )

{plansolve-0.25.2 → plansolve-0.25.4}/plansolve/field_service/__init__.py

@@ -1,14 +1,12 @@
 """Field service optimization module."""
 
 from .api_client import FieldServiceApiClient
-from .constraint_weight import ConstraintWeight
 from .models import (
     Shift,
     TimeWindow,
     Vehicle,
     Visit,
     SolverOptions,
-    Weights,
     FieldServiceRequest,
     ScheduledVehicle,
     ScheduledVisit,
@@ -18,17 +16,14 @@ from .models import (
 
 __all__ = [
     "FieldServiceApiClient",
-    "ConstraintWeight",
     "Shift",
     "TimeWindow",
     "Vehicle",
     "Visit",
     "SolverOptions",
-    "Weights",
     "FieldServiceRequest",
     "ScheduledVehicle",
     "ScheduledVisit",
     "FieldServiceResponse",
     "FieldServiceResultResponse",
 ]
-

{plansolve-0.25.2 → plansolve-0.25.4}/plansolve/field_service/api_client.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional, Union
 
 import requests
 
+from ..errors import raise_for_status
 from ..routes import Routes
 from ..solver_status import SOLVER_STATUS, SolverStatusResponse
 from .models import (
@@ -58,7 +59,7 @@ class FieldServiceApiClient:
         response = requests.post(
             self.base_url, json=api_request, headers=self._get_headers()
         )
-        response.raise_for_status()
+        raise_for_status(response)
         return FieldServiceResponse.from_dict(response.json())
 
     def get_result(self, job_id: str) -> FieldServiceResultResponse:
@@ -79,7 +80,7 @@ class FieldServiceApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return FieldServiceResultResponse.from_dict(response.json())
 
     def get_status(self, job_id: str) -> SolverStatusResponse:
@@ -100,7 +101,7 @@ class FieldServiceApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return response.json()
 
     def analyze(self, job_id: str) -> Dict[str, Any]:
@@ -121,7 +122,7 @@ class FieldServiceApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return response.json()
 
     def start_and_wait_for_completion(

{plansolve-0.25.2 → plansolve-0.25.4}/plansolve/field_service/models.py

@@ -3,8 +3,6 @@
 from dataclasses import dataclass, field
 from typing import List, Optional, Tuple, Dict, Any, Literal
 
-from .constraint_weight import ConstraintWeight
-
 
 @dataclass
 class Shift:
@@ -184,99 +182,16 @@ class SolverOptions:
         )
 
 
-@dataclass
-class Weights:
-    """Configuration weights for field service optimization constraints."""
-
-    pinned_visit_vehicle_assignment: Optional[ConstraintWeight] = None
-    pinned_visit_service_time: Optional[ConstraintWeight] = None
-    no_missing_skills: Optional[ConstraintWeight] = None
-    service_time_missing: Optional[ConstraintWeight] = None
-    vehicle_unassigned: Optional[ConstraintWeight] = None
-    prefer_high_priority: Optional[ConstraintWeight] = None
-    minimize_travel_time: Optional[ConstraintWeight] = None
-    prefer_using_idle_vehicles: Optional[ConstraintWeight] = None
-    minimize_early_arrival_wait: Optional[ConstraintWeight] = None
-    prefer_initial_vehicle_assignment: Optional[ConstraintWeight] = None
-    prefer_earlier_visit_dates: Optional[ConstraintWeight] = None
-
-    def to_dict(self) -> Dict[str, str]:
-        """Convert to dictionary for API serialization."""
-        result = {}
-        if self.pinned_visit_vehicle_assignment is not None:
-            result["pinnedVisitVehicleAssignment"] = str(
-                self.pinned_visit_vehicle_assignment
-            )
-        if self.pinned_visit_service_time is not None:
-            result["pinnedVisitServiceTime"] = str(self.pinned_visit_service_time)
-        if self.no_missing_skills is not None:
-            result["noMissingSkills"] = str(self.no_missing_skills)
-        if self.service_time_missing is not None:
-            result["serviceTimeMissing"] = str(self.service_time_missing)
-        if self.vehicle_unassigned is not None:
-            result["vehicleUnassigned"] = str(self.vehicle_unassigned)
-        if self.prefer_high_priority is not None:
-            result["preferHighPriority"] = str(self.prefer_high_priority)
-        if self.minimize_travel_time is not None:
-            result["minimizeTravelTime"] = str(self.minimize_travel_time)
-        if self.prefer_using_idle_vehicles is not None:
-            result["preferUsingIdleVehicles"] = str(self.prefer_using_idle_vehicles)
-        if self.minimize_early_arrival_wait is not None:
-            result["minimizeEarlyArrivalWait"] = str(self.minimize_early_arrival_wait)
-        if self.prefer_initial_vehicle_assignment is not None:
-            result["preferInitialVehicleAssignment"] = str(
-                self.prefer_initial_vehicle_assignment
-            )
-        if self.prefer_earlier_visit_dates is not None:
-            result["PreferEarlierVisitDates"] = str(self.prefer_earlier_visit_dates)
-        return result
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Weights":
-        """Create from dictionary."""
-        from .constraint_weight import ConstraintWeight
-
-        def parse_weight(value: Any) -> Optional[ConstraintWeight]:
-            if value is None:
-                return None
-            if isinstance(value, ConstraintWeight):
-                return value
-            if isinstance(value, str):
-                return ConstraintWeight.try_parse(value)
-            return None
-
-        return cls(
-            pinned_visit_vehicle_assignment=parse_weight(
-                data.get("pinnedVisitVehicleAssignment")
-            ),
-            pinned_visit_service_time=parse_weight(data.get("pinnedVisitServiceTime")),
-            no_missing_skills=parse_weight(data.get("noMissingSkills")),
-            service_time_missing=parse_weight(data.get("serviceTimeMissing")),
-            vehicle_unassigned=parse_weight(data.get("vehicleUnassigned")),
-            prefer_high_priority=parse_weight(data.get("preferHighPriority")),
-            minimize_travel_time=parse_weight(data.get("minimizeTravelTime")),
-            prefer_using_idle_vehicles=parse_weight(
-                data.get("preferUsingIdleVehicles")
-            ),
-            minimize_early_arrival_wait=parse_weight(
-                data.get("minimizeEarlyArrivalWait")
-            ),
-            prefer_initial_vehicle_assignment=parse_weight(
-                data.get("preferInitialVehicleAssignment")
-            ),
-            prefer_earlier_visit_dates=parse_weight(
-                data.get("PreferEarlierVisitDates")
-            ),
-        )
-
-
 @dataclass
 class FieldServiceRequest:
     """Request for field service optimization."""
 
     vehicles: List[Vehicle]
     visits: List[Visit]
-    weights: Optional[Weights] = None
+    # Open map of constraint name -> score string, e.g.
+    # {"minimizeTravelTime": "0hard/0medium/1soft"}. Keys are arbitrary
+    # (mostly camelCase, but some capitalized) and the key set is open-ended.
+    weights: Optional[Dict[str, str]] = None
     options: Optional[SolverOptions] = None
 
     def to_dict(self) -> Dict[str, Any]:
@@ -285,10 +200,8 @@ class FieldServiceRequest:
             "vehicles": [v.to_dict() for v in self.vehicles],
             "visits": [v.to_dict() for v in self.visits],
         }
-        if self.weights is not None:
-            weights_dict = self.weights.to_dict()
-            if weights_dict:
-                result["weights"] = weights_dict
+        if self.weights:
+            result["weights"] = {str(k): str(v) for k, v in self.weights.items()}
         if self.options is not None:
             options_dict = self.options.to_dict()
             if options_dict:
@@ -298,10 +211,13 @@ class FieldServiceRequest:
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "FieldServiceRequest":
         """Create from dictionary."""
+        weights = data.get("weights")
         return cls(
             vehicles=[Vehicle.from_dict(v) for v in data["vehicles"]],
             visits=[Visit.from_dict(v) for v in data["visits"]],
-            weights=Weights.from_dict(data["weights"]) if data.get("weights") else None,
+            weights=(
+                {str(k): str(v) for k, v in weights.items()} if weights else None
+            ),
             options=(
                 SolverOptions.from_dict(data["options"])
                 if data.get("options")

{plansolve-0.25.2 → plansolve-0.25.4}/plansolve/professional_services/api_client.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional, Union
 
 import requests
 
+from ..errors import raise_for_status
 from ..routes import Routes
 from ..solver_status import SOLVER_STATUS, SolverStatusResponse
 from .models import (
@@ -58,7 +59,7 @@ class ProfessionalServicesApiClient:
         response = requests.post(
             self.base_url, json=api_request, headers=self._get_headers()
         )
-        response.raise_for_status()
+        raise_for_status(response)
         return ProfessionalServicesResponse.from_dict(response.json())
 
     def get_result(self, job_id: str) -> ProfessionalServicesResultResponse:
@@ -79,7 +80,7 @@ class ProfessionalServicesApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return ProfessionalServicesResultResponse.from_dict(response.json())
 
     def get_status(self, job_id: str) -> SolverStatusResponse:
@@ -100,7 +101,7 @@ class ProfessionalServicesApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return response.json()
 
     def analyze(self, job_id: str) -> Dict[str, Any]:
@@ -121,7 +122,7 @@ class ProfessionalServicesApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return response.json()
 
     def start_and_wait_for_completion(

{plansolve-0.25.2 → plansolve-0.25.4}/plansolve/shift/api_client.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional, Union
 
 import requests
 
+from ..errors import raise_for_status
 from ..routes import Routes
 from ..solver_status import SOLVER_STATUS, SolverStatusResponse
 from .models import (
@@ -58,7 +59,7 @@ class ShiftApiClient:
         response = requests.post(
             self.base_url, json=api_request, headers=self._get_headers()
         )
-        response.raise_for_status()
+        raise_for_status(response)
         return ShiftResponse.from_dict(response.json())
 
     def get_result(self, job_id: str) -> ShiftResultResponse:
@@ -79,7 +80,7 @@ class ShiftApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return ShiftResultResponse.from_dict(response.json())
 
     def get_status(self, job_id: str) -> SolverStatusResponse:
@@ -100,7 +101,7 @@ class ShiftApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return response.json()
 
     def analyze(self, job_id: str) -> Dict[str, Any]:
@@ -121,7 +122,7 @@ class ShiftApiClient:
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         response = requests.get(url, headers=headers)
-        response.raise_for_status()
+        raise_for_status(response)
         return response.json()
 
     def start_and_wait_for_completion(

{plansolve-0.25.2 → plansolve-0.25.4/plansolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plansolve
-Version: 0.25.2
+Version: 0.25.4
 Summary: Python SDK for PlanSolve optimization API
 Author-email: PlanSolve <support@plansolve.app>
 License: MIT

{plansolve-0.25.2 → plansolve-0.25.4}/plansolve.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.md
 pyproject.toml
 plansolve/__init__.py
 plansolve/client.py
+plansolve/errors.py
 plansolve/py.typed
 plansolve/routes.py
 plansolve/solver_status.py
@@ -14,7 +15,6 @@ plansolve.egg-info/requires.txt
 plansolve.egg-info/top_level.txt
 plansolve/field_service/__init__.py
 plansolve/field_service/api_client.py
-plansolve/field_service/constraint_weight.py
 plansolve/field_service/models.py
 plansolve/professional_services/__init__.py
 plansolve/professional_services/api_client.py
@@ -35,4 +35,6 @@ plansolve/shift/planning_period.py
 plansolve/shift/shift_assignment.py
 plansolve/shift/shift_employee.py
 plansolve/shift/shift_off_request.py
-plansolve/shift/weights.py
+plansolve/shift/weights.py
+tests/test_error_messages.py
+tests/test_field_service_weights.py

{plansolve-0.25.2 → plansolve-0.25.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "plansolve"
-version = "0.25.2"
+version = "0.25.4"
 description = "Python SDK for PlanSolve optimization API"
 readme = "README.md"
 requires-python = ">=3.8"

plansolve-0.25.4/tests/test_error_messages.py

@@ -0,0 +1,81 @@
+"""Tests for HTTP error message extraction."""
+
+import json
+
+from plansolve.errors import extract_error_message
+
+
+def test_validation_problem_details_joins_sorted_field_messages():
+    body = json.dumps(
+        {
+            "type": "https://httpstatuses.io/400",
+            "title": "One or more validation errors occurred.",
+            "status": 400,
+            "detail": "See the errors property for details.",
+            "instance": "/api/field-service",
+            "errors": {
+                "vehicles": ["The vehicles field is required.", "At least one vehicle is needed."],
+                "visits": ["The visits field is required."],
+            },
+        }
+    )
+
+    message = extract_error_message(body)
+
+    # Every field/message pair rendered as "field: msg", sorted ascending,
+    # joined with "; ". errors wins over detail/title.
+    assert message == (
+        "vehicles: At least one vehicle is needed.; "
+        "vehicles: The vehicles field is required.; "
+        "visits: The visits field is required."
+    )
+
+
+def test_error_response_returns_error_string():
+    body = json.dumps({"error": "Quota exceeded for this API key."})
+
+    assert extract_error_message(body) == "Quota exceeded for this API key."
+
+
+def test_problem_details_returns_detail():
+    body = json.dumps(
+        {
+            "type": "https://httpstatuses.io/401",
+            "title": "Unauthorized",
+            "status": 401,
+            "detail": "The provided API key is invalid.",
+            "instance": "/api/field-service",
+        }
+    )
+
+    assert extract_error_message(body) == "The provided API key is invalid."
+
+
+def test_problem_details_falls_back_to_title_when_no_detail():
+    body = json.dumps(
+        {
+            "type": "https://httpstatuses.io/403",
+            "title": "Forbidden",
+            "status": 403,
+        }
+    )
+
+    assert extract_error_message(body) == "Forbidden"
+
+
+def test_non_json_body_returns_raw_text():
+    body = "502 Bad Gateway"
+
+    assert extract_error_message(body) == "502 Bad Gateway"
+
+
+def test_error_takes_priority_over_detail_and_title():
+    body = json.dumps({"error": "boom", "detail": "ignored", "title": "ignored"})
+
+    assert extract_error_message(body) == "boom"
+
+
+def test_empty_errors_dict_falls_through_to_detail():
+    body = json.dumps({"errors": {}, "detail": "fallback detail"})
+
+    assert extract_error_message(body) == "fallback detail"

plansolve-0.25.4/tests/test_field_service_weights.py

@@ -0,0 +1,99 @@
+"""Tests for the field-service open-map weights model."""
+
+from plansolve.field_service.models import FieldServiceRequest, Vehicle, Visit, Shift, TimeWindow
+
+
+def _minimal_vehicle() -> Vehicle:
+    return Vehicle(
+        id="tech1",
+        location=(40.7128, -74.0060),
+        shifts=[
+            Shift(
+                id="morning-shift",
+                min_start_time="2024-01-15T08:00:00",
+                max_end_time="2024-01-15T17:00:00",
+            )
+        ],
+        skills=["repair"],
+    )
+
+
+def _minimal_visit() -> Visit:
+    return Visit(
+        id="visit1",
+        name="Times Square Repair",
+        location=(40.7589, -73.9851),
+        time_windows=[
+            TimeWindow(
+                min_start_time="2024-01-15T09:00:00",
+                max_end_time="2024-01-15T17:00:00",
+            )
+        ],
+        service_duration="PT30M",
+        priority="HIGH",
+        required_skills=["repair"],
+    )
+
+
+# The exact weights block from the PlanSolve API contract: an open string map
+# with mostly camelCase keys plus a capitalized "PreferEarlierVisitDates" key.
+EXAMPLE_WEIGHTS = {
+    "pinnedVisitVehicleAssignment": "1hard/0medium/0soft",
+    "vehicleUnassigned": "0hard/1medium/0soft",
+    "minimizeTravelTime": "0hard/0medium/1soft",
+    "PreferEarlierVisitDates": "0hard/0medium/20soft",
+}
+
+
+def test_weights_serialize_as_exact_string_map():
+    request = FieldServiceRequest(
+        vehicles=[_minimal_vehicle()],
+        visits=[_minimal_visit()],
+        weights=dict(EXAMPLE_WEIGHTS),
+    )
+
+    payload = request.to_dict()
+
+    # Weights survive round-trip serialization exactly, preserving arbitrary
+    # and capitalized keys and the raw score strings.
+    assert payload["weights"] == EXAMPLE_WEIGHTS
+    assert "PreferEarlierVisitDates" in payload["weights"]
+    assert payload["weights"]["PreferEarlierVisitDates"] == "0hard/0medium/20soft"
+
+    # Every value must serialize as a plain JSON string, not a nested object.
+    for key, value in payload["weights"].items():
+        assert isinstance(key, str)
+        assert isinstance(value, str)
+
+
+def test_weights_accept_arbitrary_unknown_keys():
+    weights = {"someBrandNewConstraint": "5hard/0medium/0soft"}
+    request = FieldServiceRequest(
+        vehicles=[_minimal_vehicle()],
+        visits=[_minimal_visit()],
+        weights=weights,
+    )
+
+    assert request.to_dict()["weights"] == weights
+
+
+def test_weights_round_trip_from_dict():
+    data = {
+        "vehicles": [_minimal_vehicle().to_dict()],
+        "visits": [_minimal_visit().to_dict()],
+        "weights": dict(EXAMPLE_WEIGHTS),
+    }
+
+    request = FieldServiceRequest.from_dict(data)
+
+    assert request.weights == EXAMPLE_WEIGHTS
+    assert request.to_dict()["weights"] == EXAMPLE_WEIGHTS
+
+
+def test_weights_omitted_when_none():
+    request = FieldServiceRequest(
+        vehicles=[_minimal_vehicle()],
+        visits=[_minimal_visit()],
+    )
+
+    assert "weights" not in request.to_dict()

plansolve-0.25.2/plansolve/field_service/constraint_weight.py

@@ -1,143 +0,0 @@
-"""Constraint weight representation for field service optimization."""
-
-import re
-from typing import Optional
-
-
-class ConstraintWeight:
-    """
-    Represents a constraint weight in the format "Xhard/Ymedium/Zsoft" where X, Y, Z are numeric values.
-    Only one of hard, medium, or soft can be non-zero at a time.
-    Examples: "1hard/0medium/0soft", "0hard/1medium/0soft", "0hard/0medium/1soft"
-    """
-
-    def __init__(self, hard: int, medium: int, soft: int):
-        """
-        Create a new ConstraintWeight with the specified values.
-        Only one of hard, medium, or soft can be non-zero.
-
-        Args:
-            hard: Hard constraint weight value
-            medium: Medium constraint weight value
-            soft: Soft constraint weight value
-
-        Raises:
-            ValueError: When more than one value is non-zero
-        """
-        non_zero_count = sum(1 for x in [hard, medium, soft] if x != 0)
-        if non_zero_count > 1:
-            raise ValueError(
-                f"Only one of hard, medium, or soft can be non-zero. "
-                f"Received: hard={hard}, medium={medium}, soft={soft}"
-            )
-
-        self.hard = hard
-        self.medium = medium
-        self.soft = soft
-
-    @staticmethod
-    def parse(value: str) -> "ConstraintWeight":
-        """
-        Parse a weight string in the format "Xhard/Ymedium/Zsoft".
-        Only one of X, Y, or Z can be non-zero.
-
-        Args:
-            value: The weight string to parse
-
-        Returns:
-            A ConstraintWeight instance
-
-        Raises:
-            ValueError: When the string format is invalid or more than one value is non-zero
-        """
-        if not value or not value.strip():
-            raise ValueError("Weight value cannot be null or empty")
-
-        # Pattern: (\d+)hard/(\d+)medium/(\d+)soft
-        pattern = r"^(\d+)hard/(\d+)medium/(\d+)soft$"
-        match = re.match(pattern, value, re.IGNORECASE)
-
-        if not match:
-            raise ValueError(
-                f"Invalid weight format: '{value}'. Expected format: 'Xhard/Ymedium/Zsoft'"
-            )
-
-        hard = int(match.group(1))
-        medium = int(match.group(2))
-        soft = int(match.group(3))
-
-        return ConstraintWeight(hard, medium, soft)
-
-    @staticmethod
-    def try_parse(value: Optional[str]) -> Optional["ConstraintWeight"]:
-        """
-        Attempt to parse a weight string. Returns the ConstraintWeight if successful, None otherwise.
-
-        Args:
-            value: The weight string to parse, or None
-
-        Returns:
-            ConstraintWeight instance if successful, None otherwise
-        """
-        if not value or not value.strip():
-            return None
-
-        try:
-            return ConstraintWeight.parse(value)
-        except (ValueError, AttributeError):
-            return None
-
-    def __str__(self) -> str:
-        """
-        Return the string representation in the format "Xhard/Ymedium/Zsoft".
-
-        Returns:
-            String representation of the weight
-        """
-        return f"{self.hard}hard/{self.medium}medium/{self.soft}soft"
-
-    def __repr__(self) -> str:
-        """Return a string representation of the ConstraintWeight."""
-        return f"ConstraintWeight(hard={self.hard}, medium={self.medium}, soft={self.soft})"
-
-    @staticmethod
-    def create_hard(value: int) -> "ConstraintWeight":
-        """
-        Create a hard constraint weight (Xhard/0medium/0soft).
-
-        Args:
-            value: The hard constraint value
-
-        Returns:
-            ConstraintWeight instance
-        """
-        return ConstraintWeight(value, 0, 0)
-
-    @staticmethod
-    def create_medium(value: int) -> "ConstraintWeight":
-        """
-        Create a medium constraint weight (0hard/Xmedium/0soft).
-
-        Args:
-            value: The medium constraint value
-
-        Returns:
-            ConstraintWeight instance
-        """
-        return ConstraintWeight(0, value, 0)
-
-    @staticmethod
-    def create_soft(value: int) -> "ConstraintWeight":
-        """
-        Create a soft constraint weight (0hard/0medium/Xsoft).
-
-        Args:
-            value: The soft constraint value
-
-        Returns:
-            ConstraintWeight instance
-        """
-        return ConstraintWeight(0, 0, value)
-
-
-