# encoding: utf-8 # This file is part of py-serializable # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # SPDX-License-Identifier: Apache-2.0 # Copyright (c) Paul Horton. All Rights Reserved. from datetime import date, datetime from logging import getLogger from re import compile as re_compile from typing import TYPE_CHECKING, Any, Optional, Type, TypeVar, Union if TYPE_CHECKING: # pragma: no cover from xml.etree.ElementTree import Element from . import ObjectMetadataLibrary, ViewType _T = TypeVar('_T') _logger = getLogger(__name__) class BaseHelper: """Base Helper. Inherit from this class and implement/override the needed functions! This class does not provide any functionality, it is more like a Protocol with some fallback implementations. """ # region general/fallback @classmethod def serialize(cls, o: Any) -> Union[Any, str]: """general purpose serializer""" raise NotImplementedError() @classmethod def deserialize(cls, o: Any) -> Any: """general purpose deserializer""" raise NotImplementedError() # endregion general/fallback # region json specific @classmethod def json_normalize(cls, o: Any, *, view: Optional[Type['ViewType']], prop_info: 'ObjectMetadataLibrary.SerializableProperty', ctx: Type[Any], **kwargs: Any) -> Optional[Any]: """json specific normalizer""" return cls.json_serialize(o) @classmethod def json_serialize(cls, o: Any) -> Union[str, Any]: """json specific serializer""" return cls.serialize(o) @classmethod def json_denormalize(cls, o: Any, *, prop_info: 'ObjectMetadataLibrary.SerializableProperty', ctx: Type[Any], **kwargs: Any) -> Any: """json specific denormalizer :param tCls: the class that was desired to denormalize to :param pCls: tha prent class - as context """ return cls.json_deserialize(o) @classmethod def json_deserialize(cls, o: Any) -> Any: """json specific deserializer""" return cls.deserialize(o) # endregion json specific # region xml specific @classmethod def xml_normalize(cls, o: Any, *, element_name: str, view: Optional[Type['ViewType']], xmlns: Optional[str], prop_info: 'ObjectMetadataLibrary.SerializableProperty', ctx: Type[Any], **kwargs: Any) -> Optional[Union['Element', Any]]: """xml specific normalizer""" return cls.xml_serialize(o) @classmethod def xml_serialize(cls, o: Any) -> Union[str, Any]: """xml specific serializer""" return cls.serialize(o) @classmethod def xml_denormalize(cls, o: 'Element', *, default_ns: Optional[str], prop_info: 'ObjectMetadataLibrary.SerializableProperty', ctx: Type[Any], **kwargs: Any) -> Any: """xml specific denormalizer""" return cls.xml_deserialize(o.text) @classmethod def xml_deserialize(cls, o: Union[str, Any]) -> Any: """xml specific deserializer""" return cls.deserialize(o) # endregion xml specific class Iso8601Date(BaseHelper): _PATTERN_DATE = '%Y-%m-%d' @classmethod def serialize(cls, o: Any) -> str: if isinstance(o, date): return o.strftime(Iso8601Date._PATTERN_DATE) raise ValueError(f'Attempt to serialize a non-date: {o.__class__}') @classmethod def deserialize(cls, o: Any) -> date: try: return date.fromisoformat(str(o)) except ValueError: raise ValueError(f'Date string supplied ({o}) does not match either "{Iso8601Date._PATTERN_DATE}"') class XsdDate(BaseHelper): @classmethod def serialize(cls, o: Any) -> str: if isinstance(o, date): return o.isoformat() raise ValueError(f'Attempt to serialize a non-date: {o.__class__}') @classmethod def deserialize(cls, o: Any) -> date: try: v = str(o) if v.startswith('-'): # Remove any leading hyphen v = v[1:] if v.endswith('Z'): v = v[:-1] _logger.warning( 'Potential data loss will occur: dates with timezones not supported in Python', stacklevel=2) if '+' in v: v = v[:v.index('+')] _logger.warning( 'Potential data loss will occur: dates with timezones not supported in Python', stacklevel=2) return date.fromisoformat(v) except ValueError: raise ValueError(f'Date string supplied ({o}) is not a supported ISO Format') class XsdDateTime(BaseHelper): @staticmethod def __fix_tz(dt: datetime) -> datetime: """ Fix for Python's violation of ISO8601: :py:meth:`datetime.isoformat()` might omit the time offset when in doubt, but the ISO-8601 assumes local time zone. Anyway, the time offset is mandatory for this purpose. """ return dt.astimezone() \ if dt.tzinfo is None \ else dt @classmethod def serialize(cls, o: Any) -> str: if isinstance(o, datetime): return cls.__fix_tz(o).isoformat() raise ValueError(f'Attempt to serialize a non-date: {o.__class__}') # region fixup_microseconds # see https://github.com/madpah/serializable/pull/138 __PATTERN_FRACTION = re_compile(r'\.\d+') @classmethod def __fix_microseconds(cls, v: str) -> str: """ Fix for Python's violation of ISO8601 for :py:meth:`datetime.fromisoformat`. 1. Ensure either 0 or exactly 6 decimal places for seconds. Background: py<3.11 supports either 6 or 0 digits for milliseconds when parsing. 2. Ensure correct rounding of microseconds on the 6th digit. """ return cls.__PATTERN_FRACTION.sub(lambda m: f'{(float(m.group(0))):.6f}'[1:], v) # endregion fixup_microseconds @classmethod def deserialize(cls, o: Any) -> datetime: try: v = str(o) if v.startswith('-'): # Remove any leading hyphen v = v[1:] if v.endswith('Z'): # Replace ZULU time with 00:00 offset v = f'{v[:-1]}+00:00' return datetime.fromisoformat( cls.__fix_microseconds(v)) except ValueError: raise ValueError(f'Date-Time string supplied ({o}) is not a supported ISO Format')