From fc924f2c6688819d4719c68355b72ff3cc3749f6 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:23 +0000 Subject: [PATCH 01/15] Generate auditlog --- .../models/audit_log_entry_response.py | 27 +++++++++++++++++++ .../stackit/auditlog/models/error_response.py | 24 ++++++++++++++++- .../auditlog/models/gateway_error_response.py | 9 ++++++- .../models/list_audit_log_entries_response.py | 9 ++++++- 4 files changed, 66 insertions(+), 3 deletions(-) diff --git a/services/auditlog/src/stackit/auditlog/models/audit_log_entry_response.py b/services/auditlog/src/stackit/auditlog/models/audit_log_entry_response.py index 7c9c91cbf..2f73721dd 100644 --- a/services/auditlog/src/stackit/auditlog/models/audit_log_entry_response.py +++ b/services/auditlog/src/stackit/auditlog/models/audit_log_entry_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -118,6 +119,19 @@ class AuditLogEntryResponse(BaseModel): "visibility", ] + @field_validator("event_time_stamp", mode="before") + def event_time_stamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("event_type") def event_type_validate_enum(cls, value): """Validates the enum""" @@ -125,6 +139,19 @@ def event_type_validate_enum(cls, value): raise ValueError("must be one of enum values ('ADMIN_ACTIVITY', 'SYSTEM_EVENT', 'POLICY_DENIED')") return value + @field_validator("received_time_stamp", mode="before") + def received_time_stamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("severity") def severity_validate_enum(cls, value): """Validates the enum""" diff --git a/services/auditlog/src/stackit/auditlog/models/error_response.py b/services/auditlog/src/stackit/auditlog/models/error_response.py index 40308da48..82e420c48 100644 --- a/services/auditlog/src/stackit/auditlog/models/error_response.py +++ b/services/auditlog/src/stackit/auditlog/models/error_response.py @@ -15,10 +15,19 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictFloat, + StrictInt, + StrictStr, + field_validator, +) from typing_extensions import Self @@ -33,6 +42,19 @@ class ErrorResponse(BaseModel): timestamp: Optional[datetime] = Field(default=None, description="Timestamp at which the error occurred.") __properties: ClassVar[List[str]] = ["message", "path", "status", "timestamp"] + @field_validator("timestamp", mode="before") + def timestamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/auditlog/src/stackit/auditlog/models/gateway_error_response.py b/services/auditlog/src/stackit/auditlog/models/gateway_error_response.py index 698598ca0..2b90ea284 100644 --- a/services/auditlog/src/stackit/auditlog/models/gateway_error_response.py +++ b/services/auditlog/src/stackit/auditlog/models/gateway_error_response.py @@ -17,7 +17,14 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictFloat, + StrictInt, + StrictStr, +) from typing_extensions import Self diff --git a/services/auditlog/src/stackit/auditlog/models/list_audit_log_entries_response.py b/services/auditlog/src/stackit/auditlog/models/list_audit_log_entries_response.py index 2b8610151..95b8689b8 100644 --- a/services/auditlog/src/stackit/auditlog/models/list_audit_log_entries_response.py +++ b/services/auditlog/src/stackit/auditlog/models/list_audit_log_entries_response.py @@ -17,7 +17,14 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictFloat, + StrictInt, + StrictStr, +) from typing_extensions import Self from stackit.auditlog.models.audit_log_entry_response import AuditLogEntryResponse From f2a6abc353cb5439926714ea708d20dc390ada05 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:25 +0000 Subject: [PATCH 02/15] Generate authorization --- .../authorization/models/error_response.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/services/authorization/src/stackit/authorization/models/error_response.py b/services/authorization/src/stackit/authorization/models/error_response.py index 7476df1b3..9eff4a3c3 100644 --- a/services/authorization/src/stackit/authorization/models/error_response.py +++ b/services/authorization/src/stackit/authorization/models/error_response.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator from typing_extensions import Self @@ -34,6 +35,19 @@ class ErrorResponse(BaseModel): time_stamp: datetime = Field(alias="timeStamp") __properties: ClassVar[List[str]] = ["error", "message", "path", "status", "timeStamp"] + @field_validator("time_stamp", mode="before") + def time_stamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From f7b02fd3eb86515ced22422a52e200221e68061a Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:27 +0000 Subject: [PATCH 03/15] Generate cdn --- .../src/stackit/cdn/models/distribution.py | 27 +++++++++++++++++ .../cdn/models/distribution_logs_record.py | 24 ++++++++++++++- .../models/distribution_statistics_record.py | 29 ++++++++++++++++++- .../cdn/models/get_cache_info_response.py | 16 +++++++++- .../get_cache_info_response_history_entry.py | 27 +++++++++++++++++ 5 files changed, 120 insertions(+), 3 deletions(-) diff --git a/services/cdn/src/stackit/cdn/models/distribution.py b/services/cdn/src/stackit/cdn/models/distribution.py index 88092b613..de3faf9af 100644 --- a/services/cdn/src/stackit/cdn/models/distribution.py +++ b/services/cdn/src/stackit/cdn/models/distribution.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -63,6 +64,19 @@ class Distribution(BaseModel): "waf", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("status") def status_validate_enum(cls, value): """Validates the enum""" @@ -70,6 +84,19 @@ def status_validate_enum(cls, value): raise ValueError("must be one of enum values ('CREATING', 'ACTIVE', 'UPDATING', 'DELETING', 'ERROR')") return value + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/cdn/src/stackit/cdn/models/distribution_logs_record.py b/services/cdn/src/stackit/cdn/models/distribution_logs_record.py index 8444c7a71..348b69a96 100644 --- a/services/cdn/src/stackit/cdn/models/distribution_logs_record.py +++ b/services/cdn/src/stackit/cdn/models/distribution_logs_record.py @@ -15,10 +15,19 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictInt, + StrictStr, + field_validator, +) from typing_extensions import Annotated, Self @@ -50,6 +59,19 @@ class DistributionLogsRecord(BaseModel): "timestamp", ] + @field_validator("timestamp", mode="before") + def timestamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/cdn/src/stackit/cdn/models/distribution_statistics_record.py b/services/cdn/src/stackit/cdn/models/distribution_statistics_record.py index 97856e86c..13e0154aa 100644 --- a/services/cdn/src/stackit/cdn/models/distribution_statistics_record.py +++ b/services/cdn/src/stackit/cdn/models/distribution_statistics_record.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictInt +from pydantic import BaseModel, ConfigDict, Field, StrictInt, field_validator from typing_extensions import Self from stackit.cdn.models.distribution_statistics_record_regions import ( @@ -48,6 +49,32 @@ class DistributionStatisticsRecord(BaseModel): "start", ] + @field_validator("end", mode="before") + def end_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("start", mode="before") + def start_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/cdn/src/stackit/cdn/models/get_cache_info_response.py b/services/cdn/src/stackit/cdn/models/get_cache_info_response.py index 5df4e1273..8f07720b7 100644 --- a/services/cdn/src/stackit/cdn/models/get_cache_info_response.py +++ b/services/cdn/src/stackit/cdn/models/get_cache_info_response.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field +from pydantic import BaseModel, ConfigDict, Field, field_validator from typing_extensions import Self from stackit.cdn.models.get_cache_info_response_history_entry import ( @@ -38,6 +39,19 @@ class GetCacheInfoResponse(BaseModel): ) __properties: ClassVar[List[str]] = ["history", "lastPurgeTime"] + @field_validator("last_purge_time", mode="before") + def last_purge_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/cdn/src/stackit/cdn/models/get_cache_info_response_history_entry.py b/services/cdn/src/stackit/cdn/models/get_cache_info_response_history_entry.py index 643628a23..ce16e992d 100644 --- a/services/cdn/src/stackit/cdn/models/get_cache_info_response_history_entry.py +++ b/services/cdn/src/stackit/cdn/models/get_cache_info_response_history_entry.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -32,6 +33,32 @@ class GetCacheInfoResponseHistoryEntry(BaseModel): type: StrictStr __properties: ClassVar[List[str]] = ["occuredAt", "occurredAt", "type"] + @field_validator("occured_at", mode="before") + def occured_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("occurred_at", mode="before") + def occurred_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("type") def type_validate_enum(cls, value): """Validates the enum""" From f1fad5264d565d34f543c1211e08284c44297201 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:33 +0000 Subject: [PATCH 04/15] Generate git --- services/git/src/stackit/git/models/instance.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/services/git/src/stackit/git/models/instance.py b/services/git/src/stackit/git/models/instance.py index 2d71925e8..e665b27a7 100644 --- a/services/git/src/stackit/git/models/instance.py +++ b/services/git/src/stackit/git/models/instance.py @@ -16,6 +16,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -61,6 +62,19 @@ class Instance(BaseModel): "version", ] + @field_validator("created", mode="before") + def created_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" From 3a1330fd1026276a252a1251371683495cc32ace Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:38 +0000 Subject: [PATCH 05/15] Generate iaasalpha --- .../add_routing_table_to_area_payload.py | 26 +++++++++++++++++++ .../src/stackit/iaasalpha/models/network.py | 26 +++++++++++++++++++ .../src/stackit/iaasalpha/models/route.py | 26 +++++++++++++++++++ .../stackit/iaasalpha/models/routing_table.py | 26 +++++++++++++++++++ 4 files changed, 104 insertions(+) diff --git a/services/iaasalpha/src/stackit/iaasalpha/models/add_routing_table_to_area_payload.py b/services/iaasalpha/src/stackit/iaasalpha/models/add_routing_table_to_area_payload.py index 0bf1405f7..d5c08e979 100644 --- a/services/iaasalpha/src/stackit/iaasalpha/models/add_routing_table_to_area_payload.py +++ b/services/iaasalpha/src/stackit/iaasalpha/models/add_routing_table_to_area_payload.py @@ -64,6 +64,19 @@ class AddRoutingTableToAreaPayload(BaseModel): "updatedAt", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("id") def id_validate_regular_expression(cls, value): """Validates the regular expression""" @@ -83,6 +96,19 @@ def name_validate_regular_expression(cls, value): raise ValueError(r"must validate the regular expression /^[A-Za-z0-9]+([ \/._-]*[A-Za-z0-9]+)*$/") return value + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/iaasalpha/src/stackit/iaasalpha/models/network.py b/services/iaasalpha/src/stackit/iaasalpha/models/network.py index 309ba1d50..8386da67c 100644 --- a/services/iaasalpha/src/stackit/iaasalpha/models/network.py +++ b/services/iaasalpha/src/stackit/iaasalpha/models/network.py @@ -79,6 +79,19 @@ class Network(BaseModel): "updatedAt", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("id") def id_validate_regular_expression(cls, value): """Validates the regular expression""" @@ -100,6 +113,19 @@ def routing_table_id_validate_regular_expression(cls, value): ) return value + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/iaasalpha/src/stackit/iaasalpha/models/route.py b/services/iaasalpha/src/stackit/iaasalpha/models/route.py index 42eb0fef4..eb703aecd 100644 --- a/services/iaasalpha/src/stackit/iaasalpha/models/route.py +++ b/services/iaasalpha/src/stackit/iaasalpha/models/route.py @@ -49,6 +49,19 @@ class Route(BaseModel): ) __properties: ClassVar[List[str]] = ["createdAt", "destination", "id", "labels", "nexthop", "updatedAt"] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("id") def id_validate_regular_expression(cls, value): """Validates the regular expression""" @@ -61,6 +74,19 @@ def id_validate_regular_expression(cls, value): ) return value + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/iaasalpha/src/stackit/iaasalpha/models/routing_table.py b/services/iaasalpha/src/stackit/iaasalpha/models/routing_table.py index 9eab2461d..c6374160c 100644 --- a/services/iaasalpha/src/stackit/iaasalpha/models/routing_table.py +++ b/services/iaasalpha/src/stackit/iaasalpha/models/routing_table.py @@ -64,6 +64,19 @@ class RoutingTable(BaseModel): "updatedAt", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("id") def id_validate_regular_expression(cls, value): """Validates the regular expression""" @@ -83,6 +96,19 @@ def name_validate_regular_expression(cls, value): raise ValueError(r"must validate the regular expression /^[A-Za-z0-9]+([ \/._-]*[A-Za-z0-9]+)*$/") return value + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From 930774b8071691e7d533a7965dca1105111df211 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:41 +0000 Subject: [PATCH 06/15] Generate intake --- .../src/stackit/intake/models/intake_response.py | 14 ++++++++++++++ .../intake/models/intake_runner_response.py | 14 ++++++++++++++ .../stackit/intake/models/intake_user_response.py | 14 ++++++++++++++ 3 files changed, 42 insertions(+) diff --git a/services/intake/src/stackit/intake/models/intake_response.py b/services/intake/src/stackit/intake/models/intake_response.py index 2f6287974..b560a81f9 100644 --- a/services/intake/src/stackit/intake/models/intake_response.py +++ b/services/intake/src/stackit/intake/models/intake_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -75,6 +76,19 @@ class IntakeResponse(BaseModel): "uri", ] + @field_validator("create_time", mode="before") + def create_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" diff --git a/services/intake/src/stackit/intake/models/intake_runner_response.py b/services/intake/src/stackit/intake/models/intake_runner_response.py index 55d180ddf..1a6d06583 100644 --- a/services/intake/src/stackit/intake/models/intake_runner_response.py +++ b/services/intake/src/stackit/intake/models/intake_runner_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -59,6 +60,19 @@ class IntakeRunnerResponse(BaseModel): "uri", ] + @field_validator("create_time", mode="before") + def create_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" diff --git a/services/intake/src/stackit/intake/models/intake_user_response.py b/services/intake/src/stackit/intake/models/intake_user_response.py index 4cabce2b2..53587f9f0 100644 --- a/services/intake/src/stackit/intake/models/intake_user_response.py +++ b/services/intake/src/stackit/intake/models/intake_user_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -58,6 +59,19 @@ class IntakeUserResponse(BaseModel): "user", ] + @field_validator("create_time", mode="before") + def create_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" From 417ce49009c45e230c2311668c7daf9883d9b76f Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:43 +0000 Subject: [PATCH 07/15] Generate kms --- .../stackit/kms/models/create_key_payload.py | 8 +++++- .../src/stackit/kms/models/decrypt_payload.py | 8 +++++- .../src/stackit/kms/models/decrypted_data.py | 8 +++++- .../src/stackit/kms/models/encrypt_payload.py | 8 +++++- .../src/stackit/kms/models/encrypted_data.py | 8 +++++- services/kms/src/stackit/kms/models/key.py | 27 +++++++++++++++++++ .../kms/src/stackit/kms/models/key_ring.py | 14 ++++++++++ .../src/stackit/kms/models/sign_payload.py | 8 +++++- .../kms/src/stackit/kms/models/signed_data.py | 8 +++++- .../src/stackit/kms/models/verify_payload.py | 8 +++++- .../kms/src/stackit/kms/models/version.py | 27 +++++++++++++++++++ .../src/stackit/kms/models/wrapping_key.py | 27 +++++++++++++++++++ 12 files changed, 151 insertions(+), 8 deletions(-) diff --git a/services/kms/src/stackit/kms/models/create_key_payload.py b/services/kms/src/stackit/kms/models/create_key_payload.py index 8b922067a..25981ef1b 100644 --- a/services/kms/src/stackit/kms/models/create_key_payload.py +++ b/services/kms/src/stackit/kms/models/create_key_payload.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, +) from typing_extensions import Annotated, Self from stackit.kms.models.access_scope import AccessScope diff --git a/services/kms/src/stackit/kms/models/decrypt_payload.py b/services/kms/src/stackit/kms/models/decrypt_payload.py index d9e2256fe..53d97f0b7 100644 --- a/services/kms/src/stackit/kms/models/decrypt_payload.py +++ b/services/kms/src/stackit/kms/models/decrypt_payload.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBytes, + StrictStr, +) from typing_extensions import Self diff --git a/services/kms/src/stackit/kms/models/decrypted_data.py b/services/kms/src/stackit/kms/models/decrypted_data.py index 372a94c43..3d6099f2d 100644 --- a/services/kms/src/stackit/kms/models/decrypted_data.py +++ b/services/kms/src/stackit/kms/models/decrypted_data.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBytes, + StrictStr, +) from typing_extensions import Self diff --git a/services/kms/src/stackit/kms/models/encrypt_payload.py b/services/kms/src/stackit/kms/models/encrypt_payload.py index 879b357dc..43574df1a 100644 --- a/services/kms/src/stackit/kms/models/encrypt_payload.py +++ b/services/kms/src/stackit/kms/models/encrypt_payload.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBytes, + StrictStr, +) from typing_extensions import Self diff --git a/services/kms/src/stackit/kms/models/encrypted_data.py b/services/kms/src/stackit/kms/models/encrypted_data.py index 3cf913e67..f7e1122dc 100644 --- a/services/kms/src/stackit/kms/models/encrypted_data.py +++ b/services/kms/src/stackit/kms/models/encrypted_data.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBytes, + StrictStr, +) from typing_extensions import Self diff --git a/services/kms/src/stackit/kms/models/key.py b/services/kms/src/stackit/kms/models/key.py index 917c7d7c6..d84f61725 100644 --- a/services/kms/src/stackit/kms/models/key.py +++ b/services/kms/src/stackit/kms/models/key.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -80,6 +81,32 @@ class Key(BaseModel): "state", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("deletion_date", mode="before") + def deletion_date_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" diff --git a/services/kms/src/stackit/kms/models/key_ring.py b/services/kms/src/stackit/kms/models/key_ring.py index a5f062a21..8d1d1f9bb 100644 --- a/services/kms/src/stackit/kms/models/key_ring.py +++ b/services/kms/src/stackit/kms/models/key_ring.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -40,6 +41,19 @@ class KeyRing(BaseModel): state: StrictStr = Field(description="The current state of the key ring.") __properties: ClassVar[List[str]] = ["createdAt", "description", "displayName", "id", "state"] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" diff --git a/services/kms/src/stackit/kms/models/sign_payload.py b/services/kms/src/stackit/kms/models/sign_payload.py index 893e1f839..af0a3759d 100644 --- a/services/kms/src/stackit/kms/models/sign_payload.py +++ b/services/kms/src/stackit/kms/models/sign_payload.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBytes, + StrictStr, +) from typing_extensions import Self diff --git a/services/kms/src/stackit/kms/models/signed_data.py b/services/kms/src/stackit/kms/models/signed_data.py index f80d3c400..5670c82d4 100644 --- a/services/kms/src/stackit/kms/models/signed_data.py +++ b/services/kms/src/stackit/kms/models/signed_data.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBytes, + StrictStr, +) from typing_extensions import Self diff --git a/services/kms/src/stackit/kms/models/verify_payload.py b/services/kms/src/stackit/kms/models/verify_payload.py index 72ce7d3db..9aaaa3150 100644 --- a/services/kms/src/stackit/kms/models/verify_payload.py +++ b/services/kms/src/stackit/kms/models/verify_payload.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBytes, + StrictStr, +) from typing_extensions import Self diff --git a/services/kms/src/stackit/kms/models/version.py b/services/kms/src/stackit/kms/models/version.py index 329702db3..93fb87d5e 100644 --- a/services/kms/src/stackit/kms/models/version.py +++ b/services/kms/src/stackit/kms/models/version.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -66,6 +67,32 @@ class Version(BaseModel): "state", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("destroy_date", mode="before") + def destroy_date_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" diff --git a/services/kms/src/stackit/kms/models/wrapping_key.py b/services/kms/src/stackit/kms/models/wrapping_key.py index e3abf0a48..422ead663 100644 --- a/services/kms/src/stackit/kms/models/wrapping_key.py +++ b/services/kms/src/stackit/kms/models/wrapping_key.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -69,6 +70,32 @@ class WrappingKey(BaseModel): "state", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("expires_at", mode="before") + def expires_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("state") def state_validate_enum(cls, value): """Validates the enum""" From a1380e4204a9c98edbb6d306631f09ab661e7ade Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:54 +0000 Subject: [PATCH 08/15] Generate modelserving --- .../src/stackit/modelserving/models/token.py | 13 +++++++++++++ .../stackit/modelserving/models/token_created.py | 13 +++++++++++++ 2 files changed, 26 insertions(+) diff --git a/services/modelserving/src/stackit/modelserving/models/token.py b/services/modelserving/src/stackit/modelserving/models/token.py index 1d74ce13d..af54ee7f5 100644 --- a/services/modelserving/src/stackit/modelserving/models/token.py +++ b/services/modelserving/src/stackit/modelserving/models/token.py @@ -61,6 +61,19 @@ def state_validate_enum(cls, value): raise ValueError("must be one of enum values ('creating', 'active', 'deleting', 'inactive')") return value + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/modelserving/src/stackit/modelserving/models/token_created.py b/services/modelserving/src/stackit/modelserving/models/token_created.py index b3b0d695a..e043eb1fe 100644 --- a/services/modelserving/src/stackit/modelserving/models/token_created.py +++ b/services/modelserving/src/stackit/modelserving/models/token_created.py @@ -69,6 +69,19 @@ def state_validate_enum(cls, value): raise ValueError("must be one of enum values ('creating', 'active', 'deleting')") return value + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From 8bc16566fcf206d1e0b3128b45888a51ccec7631 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:46:59 +0000 Subject: [PATCH 09/15] Generate objectstorage --- .../models/create_access_key_payload.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/services/objectstorage/src/stackit/objectstorage/models/create_access_key_payload.py b/services/objectstorage/src/stackit/objectstorage/models/create_access_key_payload.py index 2bbddfa11..521f6d0d3 100644 --- a/services/objectstorage/src/stackit/objectstorage/models/create_access_key_payload.py +++ b/services/objectstorage/src/stackit/objectstorage/models/create_access_key_payload.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field +from pydantic import BaseModel, ConfigDict, Field, field_validator from typing_extensions import Self @@ -30,6 +31,19 @@ class CreateAccessKeyPayload(BaseModel): expires: Optional[datetime] = Field(default=None, description="Expiration date. Null means never expires.") __properties: ClassVar[List[str]] = ["expires"] + @field_validator("expires", mode="before") + def expires_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From b464ad7bb79de268b5ba75c4416e2439d0bae45e Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:47:06 +0000 Subject: [PATCH 10/15] Generate resourcemanager --- .../resourcemanager/models/error_response.py | 24 ++++++++++++++- .../resourcemanager/models/folder_response.py | 29 ++++++++++++++++++- .../models/get_folder_details_response.py | 29 ++++++++++++++++++- .../models/get_project_response.py | 29 ++++++++++++++++++- .../list_folders_response_items_inner.py | 29 ++++++++++++++++++- ...list_organizations_response_items_inner.py | 29 ++++++++++++++++++- .../models/organization_response.py | 29 ++++++++++++++++++- .../stackit/resourcemanager/models/project.py | 29 ++++++++++++++++++- 8 files changed, 219 insertions(+), 8 deletions(-) diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/error_response.py b/services/resourcemanager/src/stackit/resourcemanager/models/error_response.py index d6225a663..384952ee5 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/error_response.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/error_response.py @@ -15,10 +15,19 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set, Union -from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictFloat, + StrictInt, + StrictStr, + field_validator, +) from typing_extensions import Self @@ -34,6 +43,19 @@ class ErrorResponse(BaseModel): time_stamp: datetime = Field(description="Timestamp at which the error occurred.", alias="timeStamp") __properties: ClassVar[List[str]] = ["error", "message", "path", "status", "timeStamp"] + @field_validator("time_stamp", mode="before") + def time_stamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/folder_response.py b/services/resourcemanager/src/stackit/resourcemanager/models/folder_response.py index 37d8925ef..f95576806 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/folder_response.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/folder_response.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.resourcemanager.models.parent import Parent @@ -49,6 +50,32 @@ class FolderResponse(BaseModel): "updateTime", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("update_time", mode="before") + def update_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/get_folder_details_response.py b/services/resourcemanager/src/stackit/resourcemanager/models/get_folder_details_response.py index 1971ad9e1..a9dbd6cb0 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/get_folder_details_response.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/get_folder_details_response.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.resourcemanager.models.parent import Parent @@ -52,6 +53,32 @@ class GetFolderDetailsResponse(BaseModel): "updateTime", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("update_time", mode="before") + def update_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/get_project_response.py b/services/resourcemanager/src/stackit/resourcemanager/models/get_project_response.py index 60b1308a2..469589f63 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/get_project_response.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/get_project_response.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.resourcemanager.models.lifecycle_state import LifecycleState @@ -55,6 +56,32 @@ class GetProjectResponse(BaseModel): "updateTime", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("update_time", mode="before") + def update_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/list_folders_response_items_inner.py b/services/resourcemanager/src/stackit/resourcemanager/models/list_folders_response_items_inner.py index 45a7b0242..117fad493 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/list_folders_response_items_inner.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/list_folders_response_items_inner.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.resourcemanager.models.parent import Parent @@ -49,6 +50,32 @@ class ListFoldersResponseItemsInner(BaseModel): "updateTime", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("update_time", mode="before") + def update_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/list_organizations_response_items_inner.py b/services/resourcemanager/src/stackit/resourcemanager/models/list_organizations_response_items_inner.py index dc0ab923a..71c2931ae 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/list_organizations_response_items_inner.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/list_organizations_response_items_inner.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.resourcemanager.models.lifecycle_state import LifecycleState @@ -53,6 +54,32 @@ class ListOrganizationsResponseItemsInner(BaseModel): "updateTime", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("update_time", mode="before") + def update_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/organization_response.py b/services/resourcemanager/src/stackit/resourcemanager/models/organization_response.py index a21adec45..0084e28ad 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/organization_response.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/organization_response.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.resourcemanager.models.lifecycle_state import LifecycleState @@ -53,6 +54,32 @@ class OrganizationResponse(BaseModel): "updateTime", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("update_time", mode="before") + def update_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/resourcemanager/src/stackit/resourcemanager/models/project.py b/services/resourcemanager/src/stackit/resourcemanager/models/project.py index 2e8840dfb..3f5a18f12 100644 --- a/services/resourcemanager/src/stackit/resourcemanager/models/project.py +++ b/services/resourcemanager/src/stackit/resourcemanager/models/project.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.resourcemanager.models.lifecycle_state import LifecycleState @@ -52,6 +53,32 @@ class Project(BaseModel): "updateTime", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("update_time", mode="before") + def update_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From 3e1fc2b80ab89065f9c293c4be497498fc0f42ab Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:47:09 +0000 Subject: [PATCH 11/15] Generate scf --- .../scf/src/stackit/scf/models/org_manager.py | 29 ++++++++++++++- .../scf/models/org_manager_response.py | 29 ++++++++++++++- .../src/stackit/scf/models/organization.py | 36 ++++++++++++++++++- .../scf/models/organizations_list_item.py | 36 ++++++++++++++++++- services/scf/src/stackit/scf/models/quota.py | 29 ++++++++++++++- services/scf/src/stackit/scf/models/space.py | 29 ++++++++++++++- 6 files changed, 182 insertions(+), 6 deletions(-) diff --git a/services/scf/src/stackit/scf/models/org_manager.py b/services/scf/src/stackit/scf/models/org_manager.py index d1faa8188..9a03a4e24 100644 --- a/services/scf/src/stackit/scf/models/org_manager.py +++ b/services/scf/src/stackit/scf/models/org_manager.py @@ -16,10 +16,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self @@ -47,6 +48,32 @@ class OrgManager(BaseModel): "username", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/scf/src/stackit/scf/models/org_manager_response.py b/services/scf/src/stackit/scf/models/org_manager_response.py index 03fc76263..5591bb20e 100644 --- a/services/scf/src/stackit/scf/models/org_manager_response.py +++ b/services/scf/src/stackit/scf/models/org_manager_response.py @@ -16,10 +16,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self @@ -49,6 +50,32 @@ class OrgManagerResponse(BaseModel): "username", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/scf/src/stackit/scf/models/organization.py b/services/scf/src/stackit/scf/models/organization.py index c7f35c1d0..64c5f5c99 100644 --- a/services/scf/src/stackit/scf/models/organization.py +++ b/services/scf/src/stackit/scf/models/organization.py @@ -16,10 +16,18 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, + field_validator, +) from typing_extensions import Self @@ -53,6 +61,32 @@ class Organization(BaseModel): "updatedAt", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/scf/src/stackit/scf/models/organizations_list_item.py b/services/scf/src/stackit/scf/models/organizations_list_item.py index 1f22e6227..b3a07f999 100644 --- a/services/scf/src/stackit/scf/models/organizations_list_item.py +++ b/services/scf/src/stackit/scf/models/organizations_list_item.py @@ -16,10 +16,18 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, + field_validator, +) from typing_extensions import Self @@ -53,6 +61,32 @@ class OrganizationsListItem(BaseModel): "updatedAt", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/scf/src/stackit/scf/models/quota.py b/services/scf/src/stackit/scf/models/quota.py index 2ab4d0ee7..893a8a42e 100644 --- a/services/scf/src/stackit/scf/models/quota.py +++ b/services/scf/src/stackit/scf/models/quota.py @@ -16,10 +16,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self from stackit.scf.models.quota_apps import QuotaApps @@ -60,6 +61,32 @@ class Quota(BaseModel): "updatedAt", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/scf/src/stackit/scf/models/space.py b/services/scf/src/stackit/scf/models/space.py index 01b990db5..01e52eb88 100644 --- a/services/scf/src/stackit/scf/models/space.py +++ b/services/scf/src/stackit/scf/models/space.py @@ -16,10 +16,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self @@ -47,6 +48,32 @@ class Space(BaseModel): "updatedAt", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("updated_at", mode="before") + def updated_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From 7733b687e2e51940ae4ca93c2df68367d0dd99b5 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:47:12 +0000 Subject: [PATCH 12/15] Generate serviceaccount --- .../serviceaccount/models/access_token.py | 36 ++++++++++++++++++- .../models/access_token_metadata.py | 36 ++++++++++++++++++- .../create_service_account_key_payload.py | 14 ++++++++ .../create_service_account_key_response.py | 27 ++++++++++++++ .../stackit/serviceaccount/models/error.py | 16 ++++++++- .../get_service_account_key_response.py | 27 ++++++++++++++ ...tial_update_service_account_key_payload.py | 16 ++++++++- ...ial_update_service_account_key_response.py | 27 ++++++++++++++ .../serviceaccount/models/service_account.py | 8 ++++- .../service_account_key_list_response.py | 27 ++++++++++++++ 10 files changed, 229 insertions(+), 5 deletions(-) diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/access_token.py b/services/serviceaccount/src/stackit/serviceaccount/models/access_token.py index 8aeee5414..7bb265cc6 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/access_token.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/access_token.py @@ -15,10 +15,18 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, + field_validator, +) from typing_extensions import Self @@ -39,6 +47,32 @@ class AccessToken(BaseModel): ) __properties: ClassVar[List[str]] = ["active", "createdAt", "id", "token", "validUntil"] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/access_token_metadata.py b/services/serviceaccount/src/stackit/serviceaccount/models/access_token_metadata.py index df2ffbfe1..b3bd0779b 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/access_token_metadata.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/access_token_metadata.py @@ -15,10 +15,18 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, + field_validator, +) from typing_extensions import Self @@ -38,6 +46,32 @@ class AccessTokenMetadata(BaseModel): ) __properties: ClassVar[List[str]] = ["active", "createdAt", "id", "validUntil"] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_payload.py b/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_payload.py index ab577b157..6865e45f3 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_payload.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_payload.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -53,6 +54,19 @@ def algorithm_validate_enum(cls, value): raise ValueError("must be one of enum values ('RSA_2048', 'RSA_4096')") return value + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_response.py b/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_response.py index 5de09c8d0..72b1998fd 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_response.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/create_service_account_key_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -63,6 +64,19 @@ class CreateServiceAccountKeyResponse(BaseModel): "validUntil", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("key_algorithm") def key_algorithm_validate_enum(cls, value): """Validates the enum""" @@ -84,6 +98,19 @@ def key_type_validate_enum(cls, value): raise ValueError("must be one of enum values ('USER_MANAGED', 'SYSTEM_MANAGED')") return value + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/error.py b/services/serviceaccount/src/stackit/serviceaccount/models/error.py index 9c1bcb0f1..2016ce21c 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/error.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/error.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator from typing_extensions import Self @@ -34,6 +35,19 @@ class Error(BaseModel): time_stamp: datetime = Field(alias="timeStamp") __properties: ClassVar[List[str]] = ["error", "message", "path", "status", "timeStamp"] + @field_validator("time_stamp", mode="before") + def time_stamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/get_service_account_key_response.py b/services/serviceaccount/src/stackit/serviceaccount/models/get_service_account_key_response.py index 998de674a..bcd33a0fc 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/get_service_account_key_response.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/get_service_account_key_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -63,6 +64,19 @@ class GetServiceAccountKeyResponse(BaseModel): "validUntil", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("key_algorithm") def key_algorithm_validate_enum(cls, value): """Validates the enum""" @@ -84,6 +98,19 @@ def key_type_validate_enum(cls, value): raise ValueError("must be one of enum values ('USER_MANAGED', 'SYSTEM_MANAGED')") return value + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_payload.py b/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_payload.py index c4c16a7fc..7bd9b1dd4 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_payload.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_payload.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool +from pydantic import BaseModel, ConfigDict, Field, StrictBool, field_validator from typing_extensions import Self @@ -37,6 +38,19 @@ class PartialUpdateServiceAccountKeyPayload(BaseModel): ) __properties: ClassVar[List[str]] = ["active", "validUntil"] + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_response.py b/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_response.py index c567aea2b..cf6c64f6f 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_response.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/partial_update_service_account_key_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -53,6 +54,19 @@ class PartialUpdateServiceAccountKeyResponse(BaseModel): "validUntil", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("key_algorithm") def key_algorithm_validate_enum(cls, value): """Validates the enum""" @@ -74,6 +88,19 @@ def key_type_validate_enum(cls, value): raise ValueError("must be one of enum values ('USER_MANAGED', 'SYSTEM_MANAGED')") return value + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/service_account.py b/services/serviceaccount/src/stackit/serviceaccount/models/service_account.py index 7d781fca1..ee257b1bd 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/service_account.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/service_account.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, +) from typing_extensions import Self diff --git a/services/serviceaccount/src/stackit/serviceaccount/models/service_account_key_list_response.py b/services/serviceaccount/src/stackit/serviceaccount/models/service_account_key_list_response.py index 1e8c9c136..257d6b483 100644 --- a/services/serviceaccount/src/stackit/serviceaccount/models/service_account_key_list_response.py +++ b/services/serviceaccount/src/stackit/serviceaccount/models/service_account_key_list_response.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -53,6 +54,19 @@ class ServiceAccountKeyListResponse(BaseModel): "validUntil", ] + @field_validator("created_at", mode="before") + def created_at_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("key_algorithm") def key_algorithm_validate_enum(cls, value): """Validates the enum""" @@ -74,6 +88,19 @@ def key_type_validate_enum(cls, value): raise ValueError("must be one of enum values ('USER_MANAGED', 'SYSTEM_MANAGED')") return value + @field_validator("valid_until", mode="before") + def valid_until_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From 6a7c3dfeac37dbf2c9ad1615b57f315ebea4ab5e Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:47:14 +0000 Subject: [PATCH 13/15] Generate serviceenablement --- .../serviceenablement/models/error_response.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/services/serviceenablement/src/stackit/serviceenablement/models/error_response.py b/services/serviceenablement/src/stackit/serviceenablement/models/error_response.py index 3419206ed..d907adc82 100644 --- a/services/serviceenablement/src/stackit/serviceenablement/models/error_response.py +++ b/services/serviceenablement/src/stackit/serviceenablement/models/error_response.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr +from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr, field_validator from typing_extensions import Self @@ -34,6 +35,19 @@ class ErrorResponse(BaseModel): timestamp: Optional[datetime] = None __properties: ClassVar[List[str]] = ["error", "message", "path", "status", "timestamp"] + @field_validator("timestamp", mode="before") + def timestamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From aeaa93cc97e09675735a864b068a387e3661db92 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 14 Oct 2025 11:47:17 +0000 Subject: [PATCH 14/15] Generate ske --- services/ske/src/stackit/ske/models/acl.py | 8 ++++- .../src/stackit/ske/models/cluster_status.py | 23 ++++++++++++++- .../ske/models/credentials_rotation_state.py | 27 +++++++++++++++++ .../ske/src/stackit/ske/models/kubeconfig.py | 16 +++++++++- .../stackit/ske/models/kubernetes_version.py | 13 +++++++++ .../ske/models/machine_image_version.py | 13 +++++++++ .../ske/src/stackit/ske/models/nodepool.py | 9 +++++- .../src/stackit/ske/models/observability.py | 8 ++++- .../ske/src/stackit/ske/models/time_window.py | 29 ++++++++++++++++++- 9 files changed, 140 insertions(+), 6 deletions(-) diff --git a/services/ske/src/stackit/ske/models/acl.py b/services/ske/src/stackit/ske/models/acl.py index 8d1331349..7a0536ec6 100644 --- a/services/ske/src/stackit/ske/models/acl.py +++ b/services/ske/src/stackit/ske/models/acl.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, +) from typing_extensions import Annotated, Self diff --git a/services/ske/src/stackit/ske/models/cluster_status.py b/services/ske/src/stackit/ske/models/cluster_status.py index 4c2a9b37d..1c79adbc7 100644 --- a/services/ske/src/stackit/ske/models/cluster_status.py +++ b/services/ske/src/stackit/ske/models/cluster_status.py @@ -15,10 +15,18 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, + field_validator, +) from typing_extensions import Self from stackit.ske.models.cluster_error import ClusterError @@ -61,6 +69,19 @@ class ClusterStatus(BaseModel): "podAddressRanges", ] + @field_validator("creation_time", mode="before") + def creation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/ske/src/stackit/ske/models/credentials_rotation_state.py b/services/ske/src/stackit/ske/models/credentials_rotation_state.py index adda37e8f..e111bfdad 100644 --- a/services/ske/src/stackit/ske/models/credentials_rotation_state.py +++ b/services/ske/src/stackit/ske/models/credentials_rotation_state.py @@ -15,6 +15,7 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set @@ -39,6 +40,32 @@ class CredentialsRotationState(BaseModel): ) __properties: ClassVar[List[str]] = ["lastCompletionTime", "lastInitiationTime", "phase"] + @field_validator("last_completion_time", mode="before") + def last_completion_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("last_initiation_time", mode="before") + def last_initiation_time_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("phase") def phase_validate_enum(cls, value): """Validates the enum""" diff --git a/services/ske/src/stackit/ske/models/kubeconfig.py b/services/ske/src/stackit/ske/models/kubeconfig.py index e1bcc9018..b40eb485e 100644 --- a/services/ske/src/stackit/ske/models/kubeconfig.py +++ b/services/ske/src/stackit/ske/models/kubeconfig.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictStr +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator from typing_extensions import Self @@ -31,6 +32,19 @@ class Kubeconfig(BaseModel): kubeconfig: Optional[StrictStr] = None __properties: ClassVar[List[str]] = ["expirationTimestamp", "kubeconfig"] + @field_validator("expiration_timestamp", mode="before") + def expiration_timestamp_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, diff --git a/services/ske/src/stackit/ske/models/kubernetes_version.py b/services/ske/src/stackit/ske/models/kubernetes_version.py index b5d506e75..628ee5e08 100644 --- a/services/ske/src/stackit/ske/models/kubernetes_version.py +++ b/services/ske/src/stackit/ske/models/kubernetes_version.py @@ -34,6 +34,19 @@ class KubernetesVersion(BaseModel): version: Optional[Annotated[str, Field(strict=True)]] = None __properties: ClassVar[List[str]] = ["expirationDate", "featureGates", "state", "version"] + @field_validator("expiration_date", mode="before") + def expiration_date_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("version") def version_validate_regular_expression(cls, value): """Validates the regular expression""" diff --git a/services/ske/src/stackit/ske/models/machine_image_version.py b/services/ske/src/stackit/ske/models/machine_image_version.py index 22939cbc2..c2fcf2266 100644 --- a/services/ske/src/stackit/ske/models/machine_image_version.py +++ b/services/ske/src/stackit/ske/models/machine_image_version.py @@ -36,6 +36,19 @@ class MachineImageVersion(BaseModel): version: Optional[Annotated[str, Field(strict=True)]] = None __properties: ClassVar[List[str]] = ["cri", "expirationDate", "state", "version"] + @field_validator("expiration_date", mode="before") + def expiration_date_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + @field_validator("version") def version_validate_regular_expression(cls, value): """Validates the regular expression""" diff --git a/services/ske/src/stackit/ske/models/nodepool.py b/services/ske/src/stackit/ske/models/nodepool.py index 57344aa66..b856971a5 100644 --- a/services/ske/src/stackit/ske/models/nodepool.py +++ b/services/ske/src/stackit/ske/models/nodepool.py @@ -17,7 +17,14 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictInt, + StrictStr, +) from typing_extensions import Annotated, Self from stackit.ske.models.cri import CRI diff --git a/services/ske/src/stackit/ske/models/observability.py b/services/ske/src/stackit/ske/models/observability.py index 9c28159d8..ff819a83c 100644 --- a/services/ske/src/stackit/ske/models/observability.py +++ b/services/ske/src/stackit/ske/models/observability.py @@ -17,7 +17,13 @@ import pprint from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr +from pydantic import ( + BaseModel, + ConfigDict, + Field, + StrictBool, + StrictStr, +) from typing_extensions import Self diff --git a/services/ske/src/stackit/ske/models/time_window.py b/services/ske/src/stackit/ske/models/time_window.py index 47e6964dc..2df0fb352 100644 --- a/services/ske/src/stackit/ske/models/time_window.py +++ b/services/ske/src/stackit/ske/models/time_window.py @@ -15,10 +15,11 @@ import json import pprint +import re # noqa: F401 from datetime import datetime from typing import Any, ClassVar, Dict, List, Optional, Set -from pydantic import BaseModel, ConfigDict +from pydantic import BaseModel, ConfigDict, field_validator from typing_extensions import Self @@ -31,6 +32,32 @@ class TimeWindow(BaseModel): start: datetime __properties: ClassVar[List[str]] = ["end", "start"] + @field_validator("end", mode="before") + def end_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + + @field_validator("start", mode="before") + def start_change_year_zero_to_one(cls, value): + """Workaround which prevents year 0 issue""" + if isinstance(value, str): + # Check for year "0000" at the beginning of the string + # This assumes common date formats like YYYY-MM-DDTHH:MM:SS+00:00 or YYYY-MM-DDTHH:MM:SSZ + if value.startswith("0000-01-01T") and re.match( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\+\d{2}:\d{2}|Z)$", value + ): + # Workaround: Replace "0000" with "0001" + return "0001" + value[4:] # Take "0001" and append the rest of the string + return value + model_config = ConfigDict( populate_by_name=True, validate_assignment=True, From c43c9be67fb685430132d92a8d498fd2d08b315a Mon Sep 17 00:00:00 2001 From: Alexander Dahmen Date: Tue, 14 Oct 2025 15:00:00 +0200 Subject: [PATCH 15/15] Add changelogs Signed-off-by: Alexander Dahmen --- CHANGELOG.md | 28 +++++++++++++++++++++++ services/auditlog/CHANGELOG.md | 3 +++ services/auditlog/pyproject.toml | 2 +- services/authorization/CHANGELOG.md | 3 +++ services/authorization/pyproject.toml | 2 +- services/cdn/CHANGELOG.md | 3 +++ services/cdn/pyproject.toml | 2 +- services/git/CHANGELOG.md | 3 +++ services/git/pyproject.toml | 2 +- services/intake/CHANGELOG.md | 3 +++ services/intake/pyproject.toml | 2 +- services/kms/CHANGELOG.md | 3 +++ services/kms/pyproject.toml | 2 +- services/modelserving/CHANGELOG.md | 3 +++ services/modelserving/pyproject.toml | 2 +- services/objectstorage/CHANGELOG.md | 3 +++ services/objectstorage/pyproject.toml | 2 +- services/resourcemanager/CHANGELOG.md | 3 +++ services/resourcemanager/pyproject.toml | 2 +- services/scf/CHANGELOG.md | 3 +++ services/scf/pyproject.toml | 2 +- services/serviceaccount/CHANGELOG.md | 3 +++ services/serviceaccount/pyproject.toml | 2 +- services/serviceenablement/CHANGELOG.md | 3 +++ services/serviceenablement/pyproject.toml | 2 +- services/ske/CHANGELOG.md | 3 +++ services/ske/pyproject.toml | 2 +- 27 files changed, 80 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f04e96b43..fa60a18e4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,31 @@ +## Release (2025-xx-xx) +- `auditlog`: [v0.1.1](services/auditlog/CHANGELOG.md#v011) + - **Bugfix:** Prevent year 0 timestamp issue +- `authorization`: [v0.4.1](services/authorization/CHANGELOG.md#v041) + - **Bugfix:** Prevent year 0 timestamp issue +- `cdn`: [v1.7.1](services/cdn/CHANGELOG.md#v171) + - **Bugfix:** Prevent year 0 timestamp issue +- `git`: [v0.5.1](services/git/CHANGELOG.md#v051) + - **Bugfix:** Prevent year 0 timestamp issue +- `intake`: [v0.2.1](services/intake/CHANGELOG.md#v021) + - **Bugfix:** Prevent year 0 timestamp issue +- `kms`: [v0.4.1](services/kms/CHANGELOG.md#v041) + - **Bugfix:** Prevent year 0 timestamp issue +- `modelserving`: [v0.2.2](services/modelserving/CHANGELOG.md#v022) + - **Bugfix:** Prevent year 0 timestamp issue +- `objectstorage`: [v1.2.1](services/objectstorage/CHANGELOG.md#v121) + - **Bugfix:** Prevent year 0 timestamp issue +- `resourcemanager`: [v0.6.1](services/resourcemanager/CHANGELOG.md#v061) + - **Bugfix:** Prevent year 0 timestamp issue +- `scf`: [v0.2.1](services/scf/CHANGELOG.md#v021) + - **Bugfix:** Prevent year 0 timestamp issue +- `serviceaccount`: [v0.4.2](services/serviceaccount/CHANGELOG.md#v042) + - **Bugfix:** Prevent year 0 timestamp issue +- `serviceenablement`: [v1.1.1](services/serviceenablement/CHANGELOG.md#v111) + - **Bugfix:** Prevent year 0 timestamp issue +- `ske`: [v1.3.1](services/ske/CHANGELOG.md#v131) + - **Bugfix:** Prevent year 0 timestamp issue + ## Release (2025-10-13) - `observability`: [v0.11.0](services/observability/CHANGELOG.md#v0110) - **Deprecation:** The `JaegerHttpTracesUrl` field is now deprecated in all relevant models and will be removed after 9th April 2026. Use the new `JaegerHttpUrl` field instead. diff --git a/services/auditlog/CHANGELOG.md b/services/auditlog/CHANGELOG.md index 938f25720..79a93e5b6 100644 --- a/services/auditlog/CHANGELOG.md +++ b/services/auditlog/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.1.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.1.0 - **New**: STACKIT Audit Log module for retrieving recorded actions and system changes. Download audit log entries for folders, organizations, and projects with time range filtering, pagination, and configurable result limits. \ No newline at end of file diff --git a/services/auditlog/pyproject.toml b/services/auditlog/pyproject.toml index 1074b641a..2dd8cdd98 100644 --- a/services/auditlog/pyproject.toml +++ b/services/auditlog/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-auditlog" [tool.poetry] name = "stackit-auditlog" -version = "v0.1.0" +version = "v0.1.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/authorization/CHANGELOG.md b/services/authorization/CHANGELOG.md index eb0bae994..46b0bfe1c 100644 --- a/services/authorization/CHANGELOG.md +++ b/services/authorization/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.4.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.4.0 - **Feature**: Add support for assignable subjects diff --git a/services/authorization/pyproject.toml b/services/authorization/pyproject.toml index 3a20f591d..6b8e60b86 100644 --- a/services/authorization/pyproject.toml +++ b/services/authorization/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-authorization" [tool.poetry] name = "stackit-authorization" -version = "v0.4.0" +version = "v0.4.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/cdn/CHANGELOG.md b/services/cdn/CHANGELOG.md index 3621c2571..d82a2deae 100644 --- a/services/cdn/CHANGELOG.md +++ b/services/cdn/CHANGELOG.md @@ -1,3 +1,6 @@ +## v1.7.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v1.7.0 - **Feature:** Add models: `DistributionWaf`, `WafConfig`, `WAFConfigPatch`, `WAFMode`, `WAFRule`, `WAFRuleCollection`, `WAFRuleGroup` and `WAFStatusRuleBlock` - **Feature:** Add `Waf` attribute to `Config` and `Distribution` diff --git a/services/cdn/pyproject.toml b/services/cdn/pyproject.toml index a3b89e9f9..2ab578ce9 100644 --- a/services/cdn/pyproject.toml +++ b/services/cdn/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-cdn" [tool.poetry] name = "stackit-cdn" -version = "v1.7.0" +version = "v1.7.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/git/CHANGELOG.md b/services/git/CHANGELOG.md index b419a88e2..2fd8732d7 100644 --- a/services/git/CHANGELOG.md +++ b/services/git/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.5.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.5.0 - **Feature**: Add support for instance patch operation diff --git a/services/git/pyproject.toml b/services/git/pyproject.toml index e5b8a4c68..f4f4f5bdd 100644 --- a/services/git/pyproject.toml +++ b/services/git/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-git" [tool.poetry] name = "stackit-git" -version = "v0.5.0" +version = "v0.5.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/intake/CHANGELOG.md b/services/intake/CHANGELOG.md index 88e13eef6..f26501e68 100644 --- a/services/intake/CHANGELOG.md +++ b/services/intake/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.2.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.2.0 - **Feature:** Add response `IntakeRunnerResponse` to `UpdateIntakeRunnerExecute` request - **Feature:** Add response `IntakeUserResponse` to `UpdateIntakeUserExecute` request diff --git a/services/intake/pyproject.toml b/services/intake/pyproject.toml index 5f921023c..a197783de 100644 --- a/services/intake/pyproject.toml +++ b/services/intake/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-intake" [tool.poetry] name = "stackit-intake" -version = "v0.2.0" +version = "v0.2.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/kms/CHANGELOG.md b/services/kms/CHANGELOG.md index a349f9eea..7388e0ede 100644 --- a/services/kms/CHANGELOG.md +++ b/services/kms/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.4.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.4.0 - Switch to API version `v1` of STACKIT KMS service (previously `v1beta`) - **Breaking Change:** Removal of deprecated `Backend` model diff --git a/services/kms/pyproject.toml b/services/kms/pyproject.toml index 10936ec48..6bd382c69 100644 --- a/services/kms/pyproject.toml +++ b/services/kms/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-kms" [tool.poetry] name = "stackit-kms" -version = "v0.4.0" +version = "v0.4.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/modelserving/CHANGELOG.md b/services/modelserving/CHANGELOG.md index e245cb2d6..effaae1de 100644 --- a/services/modelserving/CHANGELOG.md +++ b/services/modelserving/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.2.2 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.2.1 - **Feature:** Extend enums in field `type` in model `Model`: `audio`, `image` diff --git a/services/modelserving/pyproject.toml b/services/modelserving/pyproject.toml index 6ffb46efc..4d709a56d 100644 --- a/services/modelserving/pyproject.toml +++ b/services/modelserving/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-modelserving" [tool.poetry] name = "stackit-modelserving" -version = "v0.2.1" +version = "v0.2.2" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/objectstorage/CHANGELOG.md b/services/objectstorage/CHANGELOG.md index e8bbf898d..efcb358a7 100644 --- a/services/objectstorage/CHANGELOG.md +++ b/services/objectstorage/CHANGELOG.md @@ -1,3 +1,6 @@ +## v1.2.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v1.2.0 - **Breaking change:** Set `expires` field in `CreateAccessKeyResponse` model to optional diff --git a/services/objectstorage/pyproject.toml b/services/objectstorage/pyproject.toml index 2566e2293..1f1e86ba1 100644 --- a/services/objectstorage/pyproject.toml +++ b/services/objectstorage/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-objectstorage" [tool.poetry] name = "stackit-objectstorage" -version = "v1.2.0" +version = "v1.2.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/resourcemanager/CHANGELOG.md b/services/resourcemanager/CHANGELOG.md index 1c752b4f0..1616cb0a9 100644 --- a/services/resourcemanager/CHANGELOG.md +++ b/services/resourcemanager/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.6.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.6.0 - **Version**: Minimal version is now python 3.9 diff --git a/services/resourcemanager/pyproject.toml b/services/resourcemanager/pyproject.toml index 17cafa1de..a3b76a45f 100644 --- a/services/resourcemanager/pyproject.toml +++ b/services/resourcemanager/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-resourcemanager" [tool.poetry] name = "stackit-resourcemanager" -version = "v0.6.0" +version = "v0.6.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/scf/CHANGELOG.md b/services/scf/CHANGELOG.md index e4ee50462..b8b505012 100644 --- a/services/scf/CHANGELOG.md +++ b/services/scf/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.2.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.2.0 - **Feature:** Add field `OrgId` in model `OrgManager` - **Feature:** Add new model `OrganizationCreateBffResponse` and `SpaceCreatedBffResponse` diff --git a/services/scf/pyproject.toml b/services/scf/pyproject.toml index a9215e06c..8c240c739 100644 --- a/services/scf/pyproject.toml +++ b/services/scf/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-scf" [tool.poetry] name = "stackit-scf" -version = "v0.2.0" +version = "v0.2.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/serviceaccount/CHANGELOG.md b/services/serviceaccount/CHANGELOG.md index e15193aae..adcc09ca6 100644 --- a/services/serviceaccount/CHANGELOG.md +++ b/services/serviceaccount/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.4.2 +- **Bugfix:** Prevent year 0 timestamp issue + ## v0.4.1 - **Improvement:** Improve error handling for `CreateShortLivedAccessToken` diff --git a/services/serviceaccount/pyproject.toml b/services/serviceaccount/pyproject.toml index 86e121572..bec0fd4be 100644 --- a/services/serviceaccount/pyproject.toml +++ b/services/serviceaccount/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-serviceaccount" [tool.poetry] name = "stackit-serviceaccount" -version = "v0.4.1" +version = "v0.4.2" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/serviceenablement/CHANGELOG.md b/services/serviceenablement/CHANGELOG.md index e47efbc28..ccac8501e 100644 --- a/services/serviceenablement/CHANGELOG.md +++ b/services/serviceenablement/CHANGELOG.md @@ -1,3 +1,6 @@ +## v1.1.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v1.1.0 - **Version**: Minimal version is now python 3.9 diff --git a/services/serviceenablement/pyproject.toml b/services/serviceenablement/pyproject.toml index 57f75ba70..2d809daf4 100644 --- a/services/serviceenablement/pyproject.toml +++ b/services/serviceenablement/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-serviceenablement" [tool.poetry] name = "stackit-serviceenablement" -version = "v1.1.0" +version = "v1.1.1" authors = [ "STACKIT Developer Tools ", ] diff --git a/services/ske/CHANGELOG.md b/services/ske/CHANGELOG.md index 5eb336510..ca46a780b 100644 --- a/services/ske/CHANGELOG.md +++ b/services/ske/CHANGELOG.md @@ -1,3 +1,6 @@ +## v1.3.1 +- **Bugfix:** Prevent year 0 timestamp issue + ## v1.3.0 - **Feature:** Add new field `kubernetes` to `Nodepool` model diff --git a/services/ske/pyproject.toml b/services/ske/pyproject.toml index 6ce78a17e..88feda11c 100644 --- a/services/ske/pyproject.toml +++ b/services/ske/pyproject.toml @@ -3,7 +3,7 @@ name = "stackit-ske" [tool.poetry] name = "stackit-ske" -version = "v1.3.0" +version = "v1.3.1" authors = [ "STACKIT Developer Tools ", ]