Coverage for functions \ flipdare \ wrapper \ issue \ restriction_wrapper.py: 79%

1#!/usr/bin/env python 

2# Copyright (c) 2026 Flipdare Pty Ltd. All rights reserved. 

3# 

4# This file is part of Flipdare's proprietary software and contains 

5# confidential and copyrighted material. Unauthorised copying, 

6# modification, distribution, or use of this file is strictly 

7# prohibited without prior written permission from Flipdare Pty Ltd. 

8# 

9# This software includes third-party components licensed under MIT, 

10# BSD, and Apache 2.0 licences. See THIRD_PARTY_NOTICES for details. 

11# 

12 

13from __future__ import annotations 

14 

15from flipdare.generated.model.internal.stopwatch_model import StopwatchModel 

16from flipdare.generated.model.issue.restriction_model import RestrictionKeys, RestrictionModel 

17from flipdare.generated.shared.model.core.stopwatch_duration import StopwatchDuration 

18from flipdare.generated.shared.model.issue.flag_type import FlagType 

19from flipdare.generated.shared.model.issue.issue_progress import IssueProgress 

20from flipdare.generated.shared.model.restriction.restriction_action import RestrictionAction 

21from flipdare.generated.shared.model.restriction.restriction_category import RestrictionCategory 

22from flipdare.generated.shared.model.restriction.restriction_status import RestrictionStatus 

23from flipdare.wrapper._persisted_wrapper import PersistedWrapper 

24 

25__all__ = ["RestrictionWrapper"] 

26 

27_K = RestrictionKeys 

28 

29 

30class RestrictionWrapper(PersistedWrapper[RestrictionModel]): 

31 MODEL_CLASS = RestrictionModel 

32 

33 def start_stopwatch(self) -> None: 

34 stopwatch = StopwatchModel.from_now(self.duration) 

35 self.update_field("stopwatch", stopwatch) 

36 

37 def equivalent(self, other: RestrictionWrapper) -> bool: 

38 return ( 

39 self.category == other.category 

40 and self.action == other.action 

41 and self.duration == other.duration 

42 ) 

43 

44 # <AUTO_GENERATED_CONTENT> - do not edit 

45 

46 @property 

47 def status(self) -> RestrictionStatus: 

48 return self._model.status 

49 

50 @status.setter 

51 def status(self, value: RestrictionStatus) -> None: 

52 self.update_field(_K.STATUS, value) 

53 

54 @property 

55 def in_danger(self) -> bool: 

56 return self._model.in_danger 

57 

58 @in_danger.setter 

59 def in_danger(self, value: bool) -> None: 

60 self.update_field(_K.IN_DANGER, value) 

61 

62 @property 

63 def category(self) -> RestrictionCategory: 

64 return self._model.category 

65 

66 @category.setter 

67 def category(self, value: RestrictionCategory) -> None: 

68 self.update_field(_K.CATEGORY, value) 

69 

70 @property 

71 def duration(self) -> StopwatchDuration: 

72 return self._model.duration 

73 

74 @duration.setter 

75 def duration(self, value: StopwatchDuration) -> None: 

76 self.update_field(_K.DURATION, value) 

77 

78 @property 

79 def action(self) -> RestrictionAction: 

80 return self._model.action 

81 

82 @action.setter 

83 def action(self, value: RestrictionAction) -> None: 

84 self.update_field(_K.ACTION, value) 

85 

86 @property 

87 def flag_id(self) -> str: 

88 return self._model.flag_id 

89 

90 @flag_id.setter 

91 def flag_id(self, value: str) -> None: 

92 self.update_field(_K.FLAG_ID, value) 

93 

94 @property 

95 def flag_progress(self) -> IssueProgress | None: 

96 return self._model.flag_progress 

97 

98 @flag_progress.setter 

99 def flag_progress(self, value: IssueProgress | None) -> None: 

100 self.update_field(_K.FLAG_PROGRESS, value) 

101 

102 @property 

103 def flag_type(self) -> FlagType: 

104 return self._model.flag_type 

105 

106 @flag_type.setter 

107 def flag_type(self, value: FlagType) -> None: 

108 self.update_field(_K.FLAG_TYPE, value) 

109 

110 @property 

111 def uid(self) -> str: 

112 return self._model.uid 

113 

114 @uid.setter 

115 def uid(self, value: str) -> None: 

116 self.update_field(_K.UID, value) 

117 

118 @property 

119 def reason(self) -> str: 

120 return self._model.reason 

121 

122 @reason.setter 

123 def reason(self, value: str) -> None: 

124 self.update_field(_K.REASON, value) 

125 

126 @property 

127 def stopwatch(self) -> StopwatchModel | None: 

128 return self._model.stopwatch 

129 

130 @stopwatch.setter 

131 def stopwatch(self, value: StopwatchModel | None) -> None: 

132 self.update_field(_K.STOPWATCH, value) 

133 

134 # base internal fields 

135 @property 

136 def version(self) -> int: 

137 return self._model.version 

138 

139 @version.setter 

140 def version(self, value: int) -> None: 

141 self.update_field(_K.VERSION, value) 

142 

143 @property 

144 def processed(self) -> bool: 

145 return self._model.processed 

146 

147 @processed.setter 

148 def processed(self, value: bool) -> None: 

149 self.update_field(_K.PROCESSED, value) 

150 

151 @property 

152 def error_count(self) -> int: 

153 return self._model.error_count 

154 

155 @error_count.setter 

156 def error_count(self, value: int) -> None: 

157 self.update_field(_K.ERROR_COUNT, value) 

158 

159 # </AUTO_GENERATED_CONTENT> - do not edit