extract-msg 0.48.2__py3-none-any.whl

extract_msg/structures/time_zone_definition.py

@@ -0,0 +1,111 @@
+__all__ = [
+    'TimeZoneDefinition',
+]
+
+
+from typing import List, Optional
+
+from ..constants import st
+from ._helpers import BytesReader
+from .tz_rule import TZRule
+
+
+class TimeZoneDefinition:
+    """
+    Structure for PidLidAppointmentTimeZoneDefinitionRecur from [MS-OXOCAL].
+    """
+
+    def __init__(self, data: Optional[bytes] = None):
+        if not data:
+            self.__majorVersion = 2
+            self.__minorVersion = 1
+            self.__keyName = ''
+            self.__rules = [TZRule()]
+            return
+        reader = BytesReader(data)
+        self.__majorVersion = reader.readUnsignedByte()
+        self.__minorVersion = reader.readUnsignedByte()
+        cbHeader = reader.readUnsignedShort()
+        reader.assertRead(b'\x02\x00')
+        cchKeyName = reader.readUnsignedShort()
+        self.__keyName = reader.read(2 * cchKeyName).decode('utf-16-le')
+        cRules = reader.readUnsignedShort()
+        if cRules < 1 or cRules > 1024:
+            raise ValueError('Value for cRules was out of range.')
+        self.__rules = [reader.readClass(TZRule) for _ in range(cRules)]
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        # Validate some of the data.
+        if len(self.__rules) < 1:
+            raise ValueError('Cannot pack a TimeZoneDefinition with no rules.')
+        if len(self.__rules) > 1024:
+            raise ValueError('TimeZoneDefintion can only have up to 1024 rules.')
+
+        ret = bytes((self.__majorVersion, self.__minorVersion))
+        ret += st.ST_LE_UI16.pack(6 + 2 * len(self.__keyName))
+        ret += b'\x02\x00'
+        ret += st.ST_LE_UI16.pack(2* len(self.__keyName))
+        ret += st.ST_LE_UI16.pack(len(self.__rules))
+        ret += b''.join(bytes(x) for x in self.__rules)
+
+        return ret
+
+    @property
+    def keyName(self) -> str:
+        """
+        The name of the associated time zone.
+
+        Not localized but instead set to the unique name of the desired time
+        zone.
+        """
+        return self.__keyName
+
+    @keyName.setter
+    def keyName(self, value: str) -> None:
+        value = str(value)
+        if len(value) > 260:
+            raise ValueError('Key name must be a string less than 261 characters.')
+
+        self.__keyName = value
+
+    @property
+    def majorVersion(self) -> int:
+        """
+        The major version.
+        """
+        return self.__majorVersion
+
+    @majorVersion.setter
+    def majorVersion(self, value: int) -> None:
+        if value > 255:
+            raise ValueError('Major version cannot be greater than 255')
+        if value < 0:
+            raise ValueError('Major version must be positive.')
+
+        self.__minorVersion = value
+
+    @property
+    def minorVersion(self) -> int:
+        """
+        The minor version.
+        """
+        return self.__minorVersion
+
+    @minorVersion.setter
+    def minorVersion(self, value: int) -> None:
+        if value > 255:
+            raise ValueError('Minor version cannot be greater than 255')
+        if value < 0:
+            raise ValueError('Minor version must be positive.')
+
+        self.__minorVersion = value
+
+    @property
+    def rules(self) -> List[TZRule]:
+        """
+        A tuple of TZRule structures that specifies a time zone.
+        """
+        return self.__rules

extract_msg/structures/time_zone_struct.py

@@ -0,0 +1,102 @@
+__all__ = [
+    'TimeZoneStruct',
+]
+
+
+from typing import Optional
+
+from .. import constants
+from .system_time import SystemTime
+
+
+class TimeZoneStruct:
+    """
+    A TimeZoneStruct, as specified in [MS-OXOCAL].
+    """
+
+    def __init__(self, data: Optional[bytes] = None):
+        if not data:
+            self.__bias = 0
+            self.__standardBias = 0
+            self.__daylightBias = 0
+            self.__standardDate = SystemTime()
+            self.__daylightDate = SystemTime()
+
+            return
+        unpacked = constants.st.ST_TZ.unpack(data)
+        self.__bias = unpacked[0]
+        self.__standardBias = unpacked[1]
+        self.__daylightBias = unpacked[2]
+        self.__standardDate = SystemTime(unpacked[4])
+        self.__daylightDate = SystemTime(unpacked[6])
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        return constants.st.ST_TZ.pack(self.__bias,
+                                       self.__standardBias,
+                                       self.__daylightBias,
+                                       self.standardYear,
+                                       bytes(self.__standardDate),
+                                       self.daylightYear,
+                                       bytes(self.__daylightDate))
+
+    @property
+    def bias(self) -> int:
+        """
+        The time zone's offset in minutes from UTC.
+        """
+        return self.__bias
+
+    @property
+    def daylightBias(self) -> int:
+        """
+        The offset in minutes from the value of the bias field during daylight
+        saving time.
+        """
+        return self.__daylightBias
+
+    @property
+    def daylightDate(self) -> SystemTime:
+        """
+        The date and local time that indicate when to begin using the value
+        specified in the daylightBias field. Uses the same format as
+        standardDate.
+        """
+        return self.__daylightDate
+
+    @property
+    def daylightYear(self) -> int:
+        """
+        The value of the daylightDate field's year.
+        """
+        return self.__daylightDate.year
+
+    @property
+    def standardBias(self) -> int:
+        """
+        The offset in minutes from the value of the bias field during standard
+        time.
+        """
+        return self.__standardBias
+
+    @property
+    def standardDate(self) -> SystemTime:
+        """
+        The date and local time that indicate when to begin using the value
+        specified in the standardBias field. If the time zone does not support
+        daylight's savings time, the month member must be 0. If the year is not
+        0, then it is an absolute date than only occurs once, otherwise it is a
+        relative date that occurs yearly.
+
+        See [MS-OXOCAL] for details.
+        """
+        return self.__standardDate
+
+    @property
+    def standardYear(self) -> int:
+        """
+        The value of the standardDate field's year.
+        """
+        return self.__standardDate.year

extract_msg/structures/toc_entry.py

@@ -0,0 +1,137 @@
+__all__ = [
+    'TOCEntry',
+]
+
+
+from typing import Optional, Union
+
+from ._helpers import BytesReader
+from .cfoas import ClipboardFormatOrAnsiString
+from ..constants import st
+from .dv_target_device import DVTargetDevice
+from ..enums import ADVF, DVAspect
+
+
+class TOCEntry:
+    def __init__(self, reader: Optional[Union[bytes, BytesReader]] = None):
+        if reader is None:
+            self.__clipFormat = ClipboardFormatOrAnsiString()
+            self.__aspect = 0
+            self.__lindex = 0
+            self.__tymed = 0
+            self.__advf = 0
+            self.__targetDevice = DVTargetDevice()
+            return
+
+        if isinstance(reader, bytes):
+            reader = BytesReader(reader)
+
+        self.__clipFormat = ClipboardFormatOrAnsiString(reader)
+        targetDeviceSize = reader.readUnsignedInt()
+        self.__aspect = reader.readUnsignedInt()
+        self.__lindex = reader.readUnsignedInt()
+        self.__tymed = reader.readUnsignedInt()
+        reader.read(12)
+        self.__advf = reader.readUnsignedInt()
+
+        # Based off the wording of the documentation, it seems like this can't
+        # actually be 0 bytes, so this should be fine.
+        self.__targetDevice = DVTargetDevice(reader.read(targetDeviceSize))
+
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        ret = bytes(self.__clipFormat)
+        td = bytes(self.__targetDevice)
+        ret += st.ST_LE_UI32.pack(len(td))
+        ret += st.ST_LE_UI32.pack(self.__aspect)
+        ret += st.ST_LE_UI32.pack(self.__lindex)
+        ret += st.ST_LE_UI32.pack(self.__tymed)
+        ret += b'\x00' * 12
+        ret += st.ST_LE_UI32.pack(self.__advf)
+        ret += b'\x00' * 4
+        ret += td
+
+        return ret
+
+    @property
+    def advf(self) -> Union[int, ADVF]:
+        """
+        An implementation specific hint on how to render the presentation data
+        on screen. May be ignored on processing.
+        """
+        return self.__advf
+
+    @advf.setter
+    def advf(self, val: Union[int, ADVF]) -> None:
+        if not isinstance(val, int):
+            raise TypeError(':property advf: must be an int.')
+        if val < 0:
+            raise ValueError(':property advf: must be positive.')
+        if val > 0xFFFFFFFF:
+            raise ValueError(':property advf: cannot be greater than 0xFFFFFFFF.')
+
+        self.__advf = val
+
+    @property
+    def ansiClipboardFormat(self) -> ClipboardFormatOrAnsiString:
+        return self.__clipFormat
+
+    @property
+    def aspect(self) -> Union[int, DVAspect]:
+        """
+        An implementation specific hint on how to render the presentation data
+        on screen. May be ignored on processing.
+        """
+        return self.__aspect
+
+    @aspect.setter
+    def aspect(self, val: Union[int, DVAspect]) -> None:
+        if not isinstance(val, int):
+            raise TypeError(':property aspect: must be an int.')
+        if val < 0:
+            raise ValueError(':property aspect: must be positive.')
+        if val > 0xFFFFFFFF:
+            raise ValueError(':property aspect: cannot be greater than 0xFFFFFFFF.')
+
+        self.__aspect = val
+
+    @property
+    def lindex(self) -> int:
+        """
+        An implementation specific hint on how to render the presentation data
+        on screen. May be ignored on processing.
+        """
+        return self.__lindex
+
+    @lindex.setter
+    def lindex(self, val: int) -> None:
+        if not isinstance(val, int):
+            raise TypeError(':property lindex: must be an int.')
+        if val < 0:
+            raise ValueError(':property lindex: must be positive.')
+        if val > 0xFFFFFFFF:
+            raise ValueError(':property lindex: cannot be greater than 0xFFFFFFFF.')
+
+        self.__lindex = val
+
+    @property
+    def targetDevice(self) -> DVTargetDevice:
+        return self.__targetDevice
+
+    @property
+    def tymed(self) -> int:
+        return self.__tymed
+
+    @tymed.setter
+    def tymed(self, val: int) -> None:
+        if not isinstance(val, int):
+            raise TypeError(':property lindex: must be an int.')
+        if val < 0:
+            raise ValueError(':property lindex: must be positive.')
+        if val > 0xFFFFFFFF:
+            raise ValueError(':property lindex: cannot be greater than 0xFFFFFFFF.')
+
+        self.__tymed = val

extract_msg/structures/tz_rule.py

@@ -0,0 +1,148 @@
+__all__ = [
+    'TZRule',
+]
+
+
+import logging
+
+from struct import Struct
+from typing import Final, final, Optional
+
+from ..enums import TZFlag
+from ._helpers import BytesReader
+from .system_time import SystemTime
+
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+@final
+class TZRule:
+    """
+    A TZRule structure, as defined in [MS-OXOCAL].
+    """
+
+    __SIZE__: int = 66
+    __struct: Final[Struct] = Struct('4B2H14x3i16s16s')
+
+    def __init__(self, data: Optional[bytes] = None):
+        if not data:
+            self.__majorVersion = 2
+            self.__minorVersion = 1
+            self.__flags = TZFlag(0)
+            self.__year = 0
+            self.__bias = 0
+            self.__standardBias = 0
+            self.__daylightBias = 0
+            self.__standardDate = SystemTime()
+            self.__daylightDate = SystemTime()
+            return
+
+        reader = BytesReader(data)
+        self.__majorVersion = reader.readUnsignedByte()
+        self.__minorVersion = reader.readUnsignedByte()
+        reader.assertRead(b'\x3E\x00')
+        self.__flags = TZFlag(reader.readUnsignedShort())
+        self.__year = reader.readUnsignedShort()
+        # This *MUST* be null, however I've seen Outlook not follow that. Simply
+        # log a warning about it even though it's a violation.
+        if any(b := reader.read(14)):
+            logger.warning(f'Read TZRule with non-null X section (got {b}).')
+        self.__bias = reader.readInt()
+        self.__standardBias = reader.readInt()
+        self.__daylightBias = reader.readInt()
+        self.__standardDate = SystemTime(reader.read(16))
+        self.__daylightDate = SystemTime(reader.read(16))
+
+    def __bytes__(self) -> bytes:
+        return self.toBytes()
+
+    def toBytes(self) -> bytes:
+        return self.__struct.pack(self.__majorVersion,
+                                  self.__minorVersion,
+                                  62,
+                                  0,
+                                  self.__flags,
+                                  self.__year,
+                                  self.__bias,
+                                  self.__standardBias,
+                                  self.__daylightBias,
+                                  bytes(self.__standardDate),
+                                  bytes(self.__daylightDate))
+
+    @property
+    def bias(self) -> int:
+        """
+        The time zone's offset in minutes from UTC.
+        """
+        return self.__bias
+
+    @property
+    def daylightBias(self) -> int:
+        """
+        The offset in minutes from the value of the bias field during daylight
+        saving time.
+        """
+        return self.__daylightBias
+
+    @property
+    def daylightDate(self) -> SystemTime:
+        """
+        The date and local time that indicate when to begin using the value
+        specified in the daylightBias field. Uses the same format as
+        standardDate.
+        """
+        return self.__daylightDate
+
+    @property
+    def flags(self) -> TZFlag:
+        """
+        The flags for this rule.
+        """
+        return self.__flags
+
+    @property
+    def majorVersion(self) -> int:
+        """
+        The major version.
+        """
+        return self.__majorVersion
+
+    @property
+    def minorVersion(self) -> int:
+        """
+        The minor version.
+        """
+        return self.__minorVersion
+
+    @property
+    def standardBias(self) -> int:
+        """
+        The offset in minutes from the value of the bias field during standard
+        time.
+        """
+        return self.__standardBias
+
+    @property
+    def standardDate(self) -> SystemTime:
+        """
+        The date and local time that indicate when to begin using the value
+        specified in the standardBias field. If the time zone does not support
+        daylight's savings time, the month member must be 0. If the year is not
+        0, then it is an absolute date than only occurs once, otherwise it is a
+        relative date that occurs yearly.
+
+        See [MS-OXOCAL] for details.
+        """
+        return self.__standardDate
+
+    @property
+    def year(self) -> int:
+        """
+        The year this rule is scheduled to take place. A rule will remain in
+        effect from January 1 of it's year until January 1 of the next rule's
+        year field. If no rules exist for subsequent years, this rule will
+        remain in effect indefinately.
+        """
+        return self.__year