23def get_brightness(
-24 display: Optional[DisplayIdentifier] = None,
-25 method: Optional[str] = None,
-26 verbose_error: bool = False
-27) -> List[IntPercentage]:
-28 '''
-29 Returns the current brightness of one or more displays
-30
-31 Args:
-32 display (types.DisplayIdentifier): the specific display to query
-33 method: the method to use to get the brightness. See `get_methods` for
-34 more info on available methods
-35 verbose_error: controls the level of detail in the error messages
-36
-37 Returns:
-38 A list of `IntPercentage` values, each being the brightness of an
-39 individual display. Invalid displays may return None.
-40
-41 Example:
-42 ```python
-43 import screen_brightness_control as sbc
-44
-45 # get the current screen brightness (for all detected displays)
-46 current_brightness = sbc.get_brightness()
-47
-48 # get the brightness of the primary display
-49 primary_brightness = sbc.get_brightness(display=0)
-50
-51 # get the brightness of the secondary display (if connected)
-52 secondary_brightness = sbc.get_brightness(display=1)
-53 ```
-54 '''
-55 return __brightness(display=display, method=method, meta_method='get', verbose_error=verbose_error)
+ 24def get_brightness(
+25 display: Optional[DisplayIdentifier] = None,
+26 method: Optional[str] = None,
+27 verbose_error: bool = False
+28) -> List[Union[IntPercentage, None]]:
+29 '''
+30 Returns the current brightness of one or more displays
+31
+32 Args:
+33 display (.types.DisplayIdentifier): the specific display to query
+34 method: the method to use to get the brightness. See `get_methods` for
+35 more info on available methods
+36 verbose_error: controls the level of detail in the error messages
+37
+38 Returns:
+39 A list of `IntPercentage` values, each being the brightness of an
+40 individual display. Invalid displays may return None.
+41
+42 Example:
+43 ```python
+44 import screen_brightness_control as sbc
+45
+46 # get the current screen brightness (for all detected displays)
+47 current_brightness = sbc.get_brightness()
+48
+49 # get the brightness of the primary display
+50 primary_brightness = sbc.get_brightness(display=0)
+51
+52 # get the brightness of the secondary display (if connected)
+53 secondary_brightness = sbc.get_brightness(display=1)
+54 ```
+55 '''
+56 result = __brightness(display=display, method=method, meta_method='get', verbose_error=verbose_error)
+57 # __brightness can return None depending on the `no_return` kwarg. That obviously would never happen here
+58 # but the type checker doesn't see it that way.
+59 return [] if result is None else result
Arguments:
-- display (types.DisplayIdentifier): the specific display to query
+- display (screen_brightness_control.types.DisplayIdentifier): the specific display to query
- method: the method to use to get the brightness. See
get_methods for
more info on available methods
- verbose_error: controls the level of detail in the error messages
@@ -1165,92 +1182,102 @@ Example:
def
- set_brightness( value: Union[int, str], display: Union[str, int, NoneType] = None, method: Optional[str] = None, force: bool = False, verbose_error: bool = False, no_return: bool = True) -> Optional[List[int]]:
+ set_brightness( value: Union[int, str], display: Union[str, int, NoneType] = None, method: Optional[str] = None, force: bool = False, verbose_error: bool = False, no_return: bool = True) -> Optional[List[Optional[int]]]:
- 58def set_brightness(
- 59 value: Percentage,
- 60 display: Optional[DisplayIdentifier] = None,
- 61 method: Optional[str] = None,
- 62 force: bool = False,
- 63 verbose_error: bool = False,
- 64 no_return: bool = True
- 65) -> Optional[List[IntPercentage]]:
- 66 '''
- 67 Sets the brightness level of one or more displays to a given value.
- 68
- 69 Args:
- 70 value (types.Percentage): the new brightness level
- 71 display (types.DisplayIdentifier): the specific display to adjust
- 72 method: the method to use to set the brightness. See `get_methods` for
- 73 more info on available methods
- 74 force: [*Linux Only*] if False the brightness will never be set lower than 1.
- 75 This is because on most displays a brightness of 0 will turn off the backlight.
- 76 If True, this check is bypassed
- 77 verbose_error: boolean value controls the amount of detail error messages will contain
- 78 no_return: don't return the new brightness level(s)
- 79
- 80 Returns:
- 81 If `no_return` is set to `True` (the default) then this function returns nothing.
- 82 Otherwise, a list of `types.IntPercentage` is returned, each item being the new
- 83 brightness of each adjusted display (invalid displays may return None)
- 84
- 85 Example:
- 86 ```python
- 87 import screen_brightness_control as sbc
+ 62def set_brightness(
+ 63 value: Percentage,
+ 64 display: Optional[DisplayIdentifier] = None,
+ 65 method: Optional[str] = None,
+ 66 force: bool = False,
+ 67 verbose_error: bool = False,
+ 68 no_return: bool = True
+ 69) -> Optional[List[Union[IntPercentage, None]]]:
+ 70 '''
+ 71 Sets the brightness level of one or more displays to a given value.
+ 72
+ 73 Args:
+ 74 value (.types.Percentage): the new brightness level
+ 75 display (.types.DisplayIdentifier): the specific display to adjust
+ 76 method: the method to use to set the brightness. See `get_methods` for
+ 77 more info on available methods
+ 78 force: [*Linux Only*] if False the brightness will never be set lower than 1.
+ 79 This is because on most displays a brightness of 0 will turn off the backlight.
+ 80 If True, this check is bypassed
+ 81 verbose_error: boolean value controls the amount of detail error messages will contain
+ 82 no_return: don't return the new brightness level(s)
+ 83
+ 84 Returns:
+ 85 If `no_return` is set to `True` (the default) then this function returns nothing.
+ 86 Otherwise, a list of `.types.IntPercentage` is returned, each item being the new
+ 87 brightness of each adjusted display (invalid displays may return None)
88
- 89 # set brightness to 50%
- 90 sbc.set_brightness(50)
- 91
- 92 # set brightness to 0%
- 93 sbc.set_brightness(0, force=True)
- 94
- 95 # increase brightness by 25%
- 96 sbc.set_brightness('+25')
- 97
- 98 # decrease brightness by 30%
- 99 sbc.set_brightness('-30')
-100
-101 # set the brightness of display 0 to 50%
-102 sbc.set_brightness(50, display=0)
-103 ```
-104 '''
-105 if isinstance(value, str) and ('+' in value or '-' in value):
-106 output = []
-107 for monitor in filter_monitors(display=display, method=method):
-108 identifier = Monitor.get_identifier(monitor)[1]
-109 current_value = get_brightness(display=identifier)[0]
-110 result = set_brightness(
-111 # don't need to calculate lower bound here because it will be
-112 # done by the other path in `set_brightness`
-113 percentage(value, current=current_value),
-114 display=identifier,
-115 force=force,
-116 verbose_error=verbose_error,
-117 no_return=no_return
-118 )
-119 if result is None:
-120 output.append(result)
-121 else:
-122 output += result
+ 89 Example:
+ 90 ```python
+ 91 import screen_brightness_control as sbc
+ 92
+ 93 # set brightness to 50%
+ 94 sbc.set_brightness(50)
+ 95
+ 96 # set brightness to 0%
+ 97 sbc.set_brightness(0, force=True)
+ 98
+ 99 # increase brightness by 25%
+100 sbc.set_brightness('+25')
+101
+102 # decrease brightness by 30%
+103 sbc.set_brightness('-30')
+104
+105 # set the brightness of display 0 to 50%
+106 sbc.set_brightness(50, display=0)
+107 ```
+108 '''
+109 if isinstance(value, str) and ('+' in value or '-' in value):
+110 output: List[Union[IntPercentage, None]] = []
+111 for monitor in filter_monitors(display=display, method=method):
+112 identifier = Display.from_dict(monitor).get_identifier()[1]
+113
+114 current_value = get_brightness(display=identifier)[0]
+115 if current_value is None:
+116 # invalid displays can return None. In this case, assume
+117 # the brightness to be 100, which is what many displays default to.
+118 logging.warning(
+119 'set_brightness: unable to get current brightness level for display with identifier'
+120 f' {identifier}. Assume value to be 100'
+121 )
+122 current_value = 100
123
-124 return output
-125
-126 if platform.system() == 'Linux' and not force:
-127 lower_bound = 1
-128 else:
-129 lower_bound = 0
-130
-131 value = percentage(value, lower_bound=lower_bound)
-132
-133 return __brightness(
-134 value, display=display, method=method,
-135 meta_method='set', no_return=no_return,
-136 verbose_error=verbose_error
-137 )
+124 result = set_brightness(
+125 # don't need to calculate lower bound here because it will be
+126 # done by the other path in `set_brightness`
+127 percentage(value, current=current_value),
+128 display=identifier,
+129 force=force,
+130 verbose_error=verbose_error,
+131 no_return=no_return
+132 )
+133 if result is None:
+134 output.append(result)
+135 else:
+136 output += result
+137
+138 return output
+139
+140 if platform.system() == 'Linux' and not force:
+141 lower_bound = 1
+142 else:
+143 lower_bound = 0
+144
+145 value = percentage(value, lower_bound=lower_bound)
+146
+147 return __brightness(
+148 value, display=display, method=method,
+149 meta_method='set', no_return=no_return,
+150 verbose_error=verbose_error
+151 )
Example:
Arguments:
-- value (types.Percentage): the new brightness level
-- display (types.DisplayIdentifier): the specific display to adjust
+- value (screen_brightness_control.types.Percentage): the new brightness level
+- display (screen_brightness_control.types.DisplayIdentifier): the specific display to adjust
- method: the method to use to set the brightness. See
get_methods for
more info on available methods
- force: [Linux Only] if False the brightness will never be set lower than 1.
@@ -1274,7 +1301,7 @@
Returns:
If no_return is set to True (the default) then this function returns nothing.
- Otherwise, a list of types.IntPercentage is returned, each item being the new
+ Otherwise, a list of screen_brightness_control.types.IntPercentage is returned, each item being the new
brightness of each adjusted display (invalid displays may return None)
@@ -1310,88 +1337,94 @@ Example:
def
- fade_brightness( finish: Union[int, str], start: Union[str, int, NoneType] = None, interval: float = 0.01, increment: int = 1, blocking: bool = True, force: bool = False, logarithmic: bool = True, **kwargs) -> Union[List[threading.Thread], List[int]]:
+ fade_brightness( finish: Union[int, str], start: Union[str, int, NoneType] = None, interval: float = 0.01, increment: int = 1, blocking: bool = True, force: bool = False, logarithmic: bool = True, **kwargs) -> Union[List[threading.Thread], List[Optional[int]]]:
- 140def fade_brightness(
-141 finish: Percentage,
-142 start: Optional[Percentage] = None,
-143 interval: float = 0.01,
-144 increment: int = 1,
-145 blocking: bool = True,
-146 force: bool = False,
-147 logarithmic: bool = True,
-148 **kwargs
-149) -> Union[List[threading.Thread], List[IntPercentage]]:
-150 '''
-151 Gradually change the brightness of one or more displays
-152
-153 Args:
-154 finish (types.Percentage): fade to this brightness level
-155 start (types.Percentage): where the brightness should fade from.
-156 If this arg is not specified, the fade will be started from the
-157 current brightness.
-158 interval: the time delay between each step in brightness
-159 increment: the amount to change the brightness by per step
-160 blocking: whether this should occur in the main thread (`True`) or a new daemonic thread (`False`)
-161 force: [*Linux Only*] if False the brightness will never be set lower than 1.
-162 This is because on most displays a brightness of 0 will turn off the backlight.
-163 If True, this check is bypassed
-164 logarithmic: follow a logarithmic brightness curve when adjusting the brightness
-165 **kwargs: passed through to `filter_monitors` for display selection.
-166 Will also be passed to `get_brightness` if `blocking is True`
-167
-168 Returns:
-169 By default, this function calls `get_brightness()` to return the new
-170 brightness of any adjusted displays.
-171
-172 If the `blocking` is set to `False`, then a list of threads are
-173 returned, one for each display being faded.
-174
-175 Example:
-176 ```python
-177 import screen_brightness_control as sbc
-178
-179 # fade brightness from the current brightness to 50%
-180 sbc.fade_brightness(50)
+ 154def fade_brightness(
+155 finish: Percentage,
+156 start: Optional[Percentage] = None,
+157 interval: float = 0.01,
+158 increment: int = 1,
+159 blocking: bool = True,
+160 force: bool = False,
+161 logarithmic: bool = True,
+162 **kwargs
+163) -> Union[List[threading.Thread], List[Union[IntPercentage, None]]]:
+164 '''
+165 Gradually change the brightness of one or more displays
+166
+167 Args:
+168 finish (.types.Percentage): fade to this brightness level
+169 start (.types.Percentage): where the brightness should fade from.
+170 If this arg is not specified, the fade will be started from the
+171 current brightness.
+172 interval: the time delay between each step in brightness
+173 increment: the amount to change the brightness by per step
+174 blocking: whether this should occur in the main thread (`True`) or a new daemonic thread (`False`)
+175 force: [*Linux Only*] if False the brightness will never be set lower than 1.
+176 This is because on most displays a brightness of 0 will turn off the backlight.
+177 If True, this check is bypassed
+178 logarithmic: follow a logarithmic brightness curve when adjusting the brightness
+179 **kwargs: passed through to `filter_monitors` for display selection.
+180 Will also be passed to `get_brightness` if `blocking is True`
181
-182 # fade the brightness from 25% to 75%
-183 sbc.fade_brightness(75, start=25)
-184
-185 # fade the brightness from the current value to 100% in steps of 10%
-186 sbc.fade_brightness(100, increment=10)
-187
-188 # fade the brightness from 100% to 90% with time intervals of 0.1 seconds
-189 sbc.fade_brightness(90, start=100, interval=0.1)
-190
-191 # fade the brightness to 100% in a new thread
-192 sbc.fade_brightness(100, blocking=False)
-193 ```
-194 '''
-195 # make sure only compatible kwargs are passed to filter_monitors
-196 available_monitors = filter_monitors(
-197 **{k: v for k, v in kwargs.items() if k in (
-198 'display', 'haystack', 'method', 'include'
-199 )}
-200 )
+182 Returns:
+183 By default, this function calls `get_brightness()` to return the new
+184 brightness of any adjusted displays.
+185
+186 If the `blocking` is set to `False`, then a list of threads are
+187 returned, one for each display being faded.
+188
+189 Example:
+190 ```python
+191 import screen_brightness_control as sbc
+192
+193 # fade brightness from the current brightness to 50%
+194 sbc.fade_brightness(50)
+195
+196 # fade the brightness from 25% to 75%
+197 sbc.fade_brightness(75, start=25)
+198
+199 # fade the brightness from the current value to 100% in steps of 10%
+200 sbc.fade_brightness(100, increment=10)
201
-202 threads = []
-203 for i in available_monitors:
-204 monitor = Monitor(i)
-205
-206 t1 = monitor.fade_brightness(finish, start=start, interval=interval, increment=increment,
-207 force=force, logarithmic=logarithmic, blocking=False)
-208 threads.append(t1)
-209
-210 if not blocking:
-211 return threads
-212
-213 for t in threads:
-214 t.join()
-215 return get_brightness(**kwargs)
+202 # fade the brightness from 100% to 90% with time intervals of 0.1 seconds
+203 sbc.fade_brightness(90, start=100, interval=0.1)
+204
+205 # fade the brightness to 100% in a new thread
+206 sbc.fade_brightness(100, blocking=False)
+207 ```
+208 '''
+209 # make sure only compatible kwargs are passed to filter_monitors
+210 available_monitors = filter_monitors(
+211 **{k: v for k, v in kwargs.items() if k in (
+212 'display', 'haystack', 'method', 'include'
+213 )}
+214 )
+215
+216 threads = []
+217 for i in available_monitors:
+218 display = Display.from_dict(i)
+219
+220 thread = threading.Thread(target=display.fade_brightness, args=(finish,), kwargs={
+221 'start': start,
+222 'interval': interval,
+223 'increment': increment,
+224 'force': force,
+225 'logarithmic': logarithmic
+226 })
+227 thread.start()
+228 threads.append(thread)
+229
+230 if not blocking:
+231 return threads
+232
+233 for t in threads:
+234 t.join()
+235 return get_brightness(**kwargs)
Example:
Arguments:
218def list_monitors_info(
-219 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
-220) -> List[dict]:
-221 '''
-222 List detailed information about all displays that are controllable by this library
-223
-224 Args:
-225 method: the method to use to list the available displays. See `get_methods` for
-226 more info on available methods
-227 allow_duplicates: whether to filter out duplicate displays or not
-228 unsupported: include detected displays that are invalid or unsupported
-229
-230 Returns:
-231 list: list of dictionaries containing information about the detected displays
-232
-233 Example:
-234 ```python
-235 import screen_brightness_control as sbc
-236 displays = sbc.list_monitors_info()
-237 for display in displays:
-238 print('=======================')
-239 # the manufacturer name plus the model
-240 print('Name:', display['name'])
-241 # the general model of the display
-242 print('Model:', display['model'])
-243 # the serial of the display
-244 print('Serial:', display['serial'])
-245 # the name of the brand of the display
-246 print('Manufacturer:', display['manufacturer'])
-247 # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ
-248 print('Manufacturer ID:', display['manufacturer_id'])
-249 # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES
-250 print('Index:', display['index'])
-251 # the method this display can be addressed by
-252 print('Method:', display['method'])
-253 # the EDID string associated with that display
-254 print('EDID:', display['edid'])
-255 ```
-256 '''
-257 return _OS_MODULE.list_monitors_info(
-258 method=method, allow_duplicates=allow_duplicates, unsupported=unsupported
-259 )
+ 238def list_monitors_info(
+239 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+240) -> List[dict]:
+241 '''
+242 List detailed information about all displays that are controllable by this library
+243
+244 Args:
+245 method: the method to use to list the available displays. See `get_methods` for
+246 more info on available methods
+247 allow_duplicates: whether to filter out duplicate displays or not
+248 unsupported: include detected displays that are invalid or unsupported
+249
+250 Returns:
+251 list: list of dictionaries containing information about the detected displays
+252
+253 Example:
+254 ```python
+255 import screen_brightness_control as sbc
+256 displays = sbc.list_monitors_info()
+257 for display in displays:
+258 print('=======================')
+259 # the manufacturer name plus the model
+260 print('Name:', display['name'])
+261 # the general model of the display
+262 print('Model:', display['model'])
+263 # the serial of the display
+264 print('Serial:', display['serial'])
+265 # the name of the brand of the display
+266 print('Manufacturer:', display['manufacturer'])
+267 # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ
+268 print('Manufacturer ID:', display['manufacturer_id'])
+269 # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES
+270 print('Index:', display['index'])
+271 # the method this display can be addressed by
+272 print('Method:', display['method'])
+273 # the EDID string associated with that display
+274 print('EDID:', display['edid'])
+275 ```
+276 '''
+277 return _OS_MODULE.list_monitors_info(
+278 method=method, allow_duplicates=allow_duplicates, unsupported=unsupported
+279 )
Example:
262def list_monitors(method: Optional[str] = None) -> List[str]:
-263 '''
-264 List the names of all detected displays
-265
-266 Args:
-267 method: the method to use to list the available displays. See `get_methods` for
-268 more info on available methods
-269
-270 Example:
-271 ```python
-272 import screen_brightness_control as sbc
-273 display_names = sbc.list_monitors()
-274 # eg: ['BenQ GL2450H', 'Dell U2211H']
-275 ```
-276 '''
-277 return [i['name'] for i in list_monitors_info(method=method)]
+ 282def list_monitors(method: Optional[str] = None) -> List[str]:
+283 '''
+284 List the names of all detected displays
+285
+286 Args:
+287 method: the method to use to list the available displays. See `get_methods` for
+288 more info on available methods
+289
+290 Example:
+291 ```python
+292 import screen_brightness_control as sbc
+293 display_names = sbc.list_monitors()
+294 # eg: ['BenQ GL2450H', 'Dell U2211H']
+295 ```
+296 '''
+297 return [i['name'] for i in list_monitors_info(method=method)]
Example:
- 280def get_methods(name: str = None) -> Dict[str, BrightnessMethod]:
-281 '''
-282 Returns all available brightness method names and their associated classes.
-283
-284 Args:
-285 name: if specified, return the method corresponding to this name
-286
-287 Raises:
-288 ValueError: if the given name is incorrect
-289
-290 Example:
-291 ```python
-292 import screen_brightness_control as sbc
-293
-294 all_methods = sbc.get_methods()
-295
-296 for method_name, method_class in all_methods.items():
-297 print('Method:', method_name)
-298 print('Class:', method_class)
-299 print('Associated monitors:', sbc.list_monitors(method=method_name))
-300 ```
-301 '''
-302 methods = {i.__name__.lower(): i for i in _OS_METHODS}
+ 300def get_methods(name: Optional[str] = None) -> Dict[str, Type[BrightnessMethod]]:
+301 '''
+302 Returns all available brightness method names and their associated classes.
303
-304 if name is None:
-305 return methods
+304 Args:
+305 name: if specified, return the method corresponding to this name
306
-307 if not isinstance(name, str):
-308 raise TypeError(f'name must be of type str, not {type(name)!r}')
+307 Raises:
+308 ValueError: if the given name is incorrect
309
-310 name = name.lower()
-311 if name in methods:
-312 return {name: methods[name]}
+310 Example:
+311 ```python
+312 import screen_brightness_control as sbc
313
-314 logger.debug(f'requested method {name!r} invalid')
-315 raise ValueError(
-316 f'invalid method {name!r}, must be one of: {list(methods)}')
+314 all_methods = sbc.get_methods()
+315
+316 for method_name, method_class in all_methods.items():
+317 print('Method:', method_name)
+318 print('Class:', method_class)
+319 print('Associated monitors:', sbc.list_monitors(method=method_name))
+320 ```
+321 '''
+322 methods = {i.__name__.lower(): i for i in _OS_METHODS}
+323
+324 if name is None:
+325 return methods
+326
+327 if not isinstance(name, str):
+328 raise TypeError(f'name must be of type str, not {type(name)!r}')
+329
+330 name = name.lower()
+331 if name in methods:
+332 return {name: methods[name]}
+333
+334 _logger.debug(f'requested method {name!r} invalid')
+335 raise ValueError(
+336 f'invalid method {name!r}, must be one of: {list(methods)}')
Example:
319@dataclass
-320class Display():
-321 '''
-322 Represents a single connected display.
-323 '''
-324 index: int
-325 '''The index of the display relative to the method it uses.
-326 So if the index is 0 and the method is `windows.VCP`, then this is the 1st
-327 display reported by `windows.VCP`, not the first display overall.'''
-328 method: BrightnessMethod
-329 '''The method by which this monitor can be addressed.
-330 This will be a class from either the windows or linux sub-module'''
-331
-332 edid: str = None
-333 '''A 256 character hex string containing information about a display and its capabilities'''
-334 manufacturer: str = None
-335 '''Name of the display's manufacturer'''
-336 manufacturer_id: str = None
-337 '''3 letter code corresponding to the manufacturer name'''
-338 model: str = None
-339 '''Model name of the display'''
-340 name: str = None
-341 '''The name of the display, often the manufacturer name plus the model name'''
-342 serial: str = None
-343 '''The serial number of the display or (if serial is not available) an ID assigned by the OS'''
-344
-345 _logger: logging.Logger = field(init=False)
-346
-347 def __post_init__(self):
-348 self._logger = logger.getChild(self.__class__.__name__).getChild(
-349 str(self.get_identifier()[1])[:20])
-350
-351 def fade_brightness(
-352 self,
-353 finish: Percentage,
-354 start: Optional[Percentage] = None,
-355 interval: float = 0.01,
-356 increment: int = 1,
-357 force: bool = False,
-358 logarithmic: bool = True
-359 ) -> IntPercentage:
-360 '''
-361 Gradually change the brightness of this display to a set value.
-362 This works by incrementally changing the brightness until the desired
-363 value is reached.
+ 339@dataclass
+340class Display():
+341 '''
+342 Represents a single connected display.
+343 '''
+344 index: int
+345 '''The index of the display relative to the method it uses.
+346 So if the index is 0 and the method is `windows.VCP`, then this is the 1st
+347 display reported by `windows.VCP`, not the first display overall.'''
+348 method: Type[BrightnessMethod]
+349 '''The method by which this monitor can be addressed.
+350 This will be a class from either the windows or linux sub-module'''
+351
+352 edid: Optional[str] = None
+353 '''A 256 character hex string containing information about a display and its capabilities'''
+354 manufacturer: Optional[str] = None
+355 '''Name of the display's manufacturer'''
+356 manufacturer_id: Optional[str] = None
+357 '''3 letter code corresponding to the manufacturer name'''
+358 model: Optional[str] = None
+359 '''Model name of the display'''
+360 name: Optional[str] = None
+361 '''The name of the display, often the manufacturer name plus the model name'''
+362 serial: Optional[str] = None
+363 '''The serial number of the display or (if serial is not available) an ID assigned by the OS'''
364
-365 Args:
-366 finish (types.Percentage): the brightness level to end up on
-367 start (types.Percentage): where the fade should start from. Defaults
-368 to whatever the current brightness level for the display is
-369 interval: time delay between each change in brightness
-370 increment: amount to change the brightness by each time (as a percentage)
-371 force: [*Linux only*] allow the brightness to be set to 0. By default,
-372 brightness values will never be set lower than 1, since setting them to 0
-373 often turns off the backlight
-374 logarithmic: follow a logarithmic curve when setting brightness values.
-375 See `logarithmic_range` for rationale
-376
-377 Returns:
-378 The brightness of the display after the fade is complete.
-379 See `types.IntPercentage`
-380 '''
-381 # minimum brightness value
-382 if platform.system() == 'Linux' and not force:
-383 lower_bound = 1
-384 else:
-385 lower_bound = 0
-386
-387 current = self.get_brightness()
-388
-389 finish = percentage(finish, current, lower_bound)
-390 start = percentage(
-391 current if start is None else start, current, lower_bound)
-392
-393 range_func = logarithmic_range if logarithmic else range
-394 increment = abs(increment)
-395 if start > finish:
-396 increment = -increment
-397
-398 self._logger.debug(
-399 f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+365 _logger: logging.Logger = field(init=False)
+366
+367 def __post_init__(self):
+368 self._logger = _logger.getChild(self.__class__.__name__).getChild(
+369 str(self.get_identifier()[1])[:20])
+370
+371 def fade_brightness(
+372 self,
+373 finish: Percentage,
+374 start: Optional[Percentage] = None,
+375 interval: float = 0.01,
+376 increment: int = 1,
+377 force: bool = False,
+378 logarithmic: bool = True
+379 ) -> IntPercentage:
+380 '''
+381 Gradually change the brightness of this display to a set value.
+382 This works by incrementally changing the brightness until the desired
+383 value is reached.
+384
+385 Args:
+386 finish (.types.Percentage): the brightness level to end up on
+387 start (.types.Percentage): where the fade should start from. Defaults
+388 to whatever the current brightness level for the display is
+389 interval: time delay between each change in brightness
+390 increment: amount to change the brightness by each time (as a percentage)
+391 force: [*Linux only*] allow the brightness to be set to 0. By default,
+392 brightness values will never be set lower than 1, since setting them to 0
+393 often turns off the backlight
+394 logarithmic: follow a logarithmic curve when setting brightness values.
+395 See `logarithmic_range` for rationale
+396
+397 Returns:
+398 The brightness of the display after the fade is complete.
+399 See `.types.IntPercentage`
400
-401 for value in range_func(start, finish, increment):
-402 self.set_brightness(value)
-403 time.sleep(interval)
-404
-405 if self.get_brightness() != finish:
-406 self.set_brightness(finish, no_return=True)
-407
-408 return self.get_brightness()
+401 .. warning:: Deprecated
+402 This function will return `None` in v0.23.0 and later.
+403 '''
+404 # minimum brightness value
+405 if platform.system() == 'Linux' and not force:
+406 lower_bound = 1
+407 else:
+408 lower_bound = 0
409
-410 @classmethod
-411 def from_dict(cls, display: dict) -> 'Display':
-412 '''
-413 Initialise an instance of the class from a dictionary, ignoring
-414 any unwanted keys
-415 '''
-416 return cls(
-417 index=display['index'],
-418 method=display['method'],
-419 edid=display['edid'],
-420 manufacturer=display['manufacturer'],
-421 manufacturer_id=display['manufacturer_id'],
-422 model=display['model'],
-423 name=display['name'],
-424 serial=display['serial']
-425 )
-426
-427 def get_brightness(self) -> IntPercentage:
-428 '''
-429 Returns the brightness of this display.
-430
-431 Returns:
-432 The brightness value of the display, as a percentage.
-433 See `types.IntPercentage`
-434 '''
-435 return self.method.get_brightness(display=self.index)[0]
-436
-437 def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
-438 '''
-439 Returns the `types.DisplayIdentifier` for this display.
-440 Will iterate through the EDID, serial, name and index and return the first
-441 value that is not equal to None
-442
-443 Returns:
-444 The name of the property returned and the value of said property.
-445 EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
-446 '''
-447 for key in ('edid', 'serial', 'name', 'index'):
-448 value = getattr(self, key, None)
-449 if value is not None:
-450 return key, value
-451
-452 def is_active(self) -> bool:
-453 '''
-454 Attempts to retrieve the brightness for this display. If it works the display is deemed active
-455 '''
-456 try:
-457 self.get_brightness()
-458 return True
-459 except Exception as e:
-460 self._logger.error(
-461 f'Monitor.is_active: {self.get_identifier()} failed get_brightness call'
-462 f' - {format_exc(e)}'
-463 )
-464 return False
-465
-466 def set_brightness(self, value: Percentage, force: bool = False):
-467 '''
-468 Sets the brightness for this display. See `set_brightness` for the full docs
-469
-470 Args:
-471 value (types.Percentage): the brightness percentage to set the display to
-472 force: allow the brightness to be set to 0 on Linux. This is disabled by default
-473 because setting the brightness of 0 will often turn off the backlight
-474 '''
-475 # convert brightness value to percentage
-476 if platform.system() == 'Linux' and not force:
-477 lower_bound = 1
-478 else:
-479 lower_bound = 0
-480
-481 value = percentage(
-482 value,
-483 current=lambda: self.method.get_brightness(display=self.index)[0],
-484 lower_bound=lower_bound
-485 )
-486
-487 self.method.set_brightness(value, display=self.index)
+410 current = self.get_brightness()
+411
+412 finish = percentage(finish, current, lower_bound)
+413 start = percentage(
+414 current if start is None else start, current, lower_bound)
+415
+416 # mypy says "object is not callable" but range is. Ignore this
+417 range_func: Callable = logarithmic_range if logarithmic else range # type: ignore[assignment]
+418 increment = abs(increment)
+419 if start > finish:
+420 increment = -increment
+421
+422 self._logger.debug(
+423 f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+424
+425 for value in range_func(start, finish, increment):
+426 self.set_brightness(value)
+427 time.sleep(interval)
+428
+429 if self.get_brightness() != finish:
+430 self.set_brightness(finish)
+431
+432 return self.get_brightness()
+433
+434 @classmethod
+435 def from_dict(cls, display: dict) -> 'Display':
+436 '''
+437 Initialise an instance of the class from a dictionary, ignoring
+438 any unwanted keys
+439 '''
+440 return cls(
+441 index=display['index'],
+442 method=display['method'],
+443 edid=display['edid'],
+444 manufacturer=display['manufacturer'],
+445 manufacturer_id=display['manufacturer_id'],
+446 model=display['model'],
+447 name=display['name'],
+448 serial=display['serial']
+449 )
+450
+451 def get_brightness(self) -> IntPercentage:
+452 '''
+453 Returns the brightness of this display.
+454
+455 Returns:
+456 The brightness value of the display, as a percentage.
+457 See `.types.IntPercentage`
+458 '''
+459 return self.method.get_brightness(display=self.index)[0]
+460
+461 def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+462 '''
+463 Returns the `.types.DisplayIdentifier` for this display.
+464 Will iterate through the EDID, serial, name and index and return the first
+465 value that is not equal to None
+466
+467 Returns:
+468 The name of the property returned and the value of said property.
+469 EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+470 '''
+471 for key in ('edid', 'serial', 'name'):
+472 value = getattr(self, key, None)
+473 if value is not None:
+474 return key, value
+475 # the index should surely never be `None`
+476 return 'index', self.index
+477
+478 def is_active(self) -> bool:
+479 '''
+480 Attempts to retrieve the brightness for this display. If it works the display is deemed active
+481 '''
+482 try:
+483 self.get_brightness()
+484 return True
+485 except Exception as e:
+486 self._logger.error(
+487 f'Monitor.is_active: {self.get_identifier()} failed get_brightness call'
+488 f' - {format_exc(e)}'
+489 )
+490 return False
+491
+492 def set_brightness(self, value: Percentage, force: bool = False):
+493 '''
+494 Sets the brightness for this display. See `set_brightness` for the full docs
+495
+496 Args:
+497 value (.types.Percentage): the brightness percentage to set the display to
+498 force: allow the brightness to be set to 0 on Linux. This is disabled by default
+499 because setting the brightness of 0 will often turn off the backlight
+500 '''
+501 # convert brightness value to percentage
+502 if platform.system() == 'Linux' and not force:
+503 lower_bound = 1
+504 else:
+505 lower_bound = 0
+506
+507 value = percentage(
+508 value,
+509 current=lambda: self.method.get_brightness(display=self.index)[0],
+510 lower_bound=lower_bound
+511 )
+512
+513 self.method.set_brightness(value, display=self.index)
Example:
-
Display( index: int, method: screen_brightness_control.helpers.BrightnessMethod, edid: str = None, manufacturer: str = None, manufacturer_id: str = None, model: str = None, name: str = None, serial: str = None)
+
Display( index: int, method: Type[screen_brightness_control.helpers.BrightnessMethod], edid: Optional[str] = None, manufacturer: Optional[str] = None, manufacturer_id: Optional[str] = None, model: Optional[str] = None, name: Optional[str] = None, serial: Optional[str] = None)
@@ -1902,15 +1941,15 @@
Example:
The index of the display relative to the method it uses.
-So if the index is 0 and the method is windows.VCP, then this is the 1st
-display reported by windows.VCP, not the first display overall.
+So if the index is 0 and the method is
windows.VCP, then this is the 1st
+display reported by
windows.VCP, not the first display overall.
@@ -1924,7 +1963,7 @@
Example:
- edid: str =
+ edid: Optional[str] =
None
@@ -1938,7 +1977,7 @@
Example:
- manufacturer: str =
+ manufacturer: Optional[str] =
None
@@ -1952,7 +1991,7 @@
Example:
- manufacturer_id: str =
+ manufacturer_id: Optional[str] =
None
@@ -1966,7 +2005,7 @@
Example:
- model: str =
+ model: Optional[str] =
None
@@ -1980,7 +2019,7 @@
Example:
- name: str =
+ name: Optional[str] =
None
@@ -1994,7 +2033,7 @@
Example:
- serial: str =
+ serial: Optional[str] =
None
@@ -2017,64 +2056,68 @@
Example:
-
351 def fade_brightness(
-352 self,
-353 finish: Percentage,
-354 start: Optional[Percentage] = None,
-355 interval: float = 0.01,
-356 increment: int = 1,
-357 force: bool = False,
-358 logarithmic: bool = True
-359 ) -> IntPercentage:
-360 '''
-361 Gradually change the brightness of this display to a set value.
-362 This works by incrementally changing the brightness until the desired
-363 value is reached.
-364
-365 Args:
-366 finish (types.Percentage): the brightness level to end up on
-367 start (types.Percentage): where the fade should start from. Defaults
-368 to whatever the current brightness level for the display is
-369 interval: time delay between each change in brightness
-370 increment: amount to change the brightness by each time (as a percentage)
-371 force: [*Linux only*] allow the brightness to be set to 0. By default,
-372 brightness values will never be set lower than 1, since setting them to 0
-373 often turns off the backlight
-374 logarithmic: follow a logarithmic curve when setting brightness values.
-375 See `logarithmic_range` for rationale
-376
-377 Returns:
-378 The brightness of the display after the fade is complete.
-379 See `types.IntPercentage`
-380 '''
-381 # minimum brightness value
-382 if platform.system() == 'Linux' and not force:
-383 lower_bound = 1
-384 else:
-385 lower_bound = 0
-386
-387 current = self.get_brightness()
-388
-389 finish = percentage(finish, current, lower_bound)
-390 start = percentage(
-391 current if start is None else start, current, lower_bound)
-392
-393 range_func = logarithmic_range if logarithmic else range
-394 increment = abs(increment)
-395 if start > finish:
-396 increment = -increment
-397
-398 self._logger.debug(
-399 f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+ 371 def fade_brightness(
+372 self,
+373 finish: Percentage,
+374 start: Optional[Percentage] = None,
+375 interval: float = 0.01,
+376 increment: int = 1,
+377 force: bool = False,
+378 logarithmic: bool = True
+379 ) -> IntPercentage:
+380 '''
+381 Gradually change the brightness of this display to a set value.
+382 This works by incrementally changing the brightness until the desired
+383 value is reached.
+384
+385 Args:
+386 finish (.types.Percentage): the brightness level to end up on
+387 start (.types.Percentage): where the fade should start from. Defaults
+388 to whatever the current brightness level for the display is
+389 interval: time delay between each change in brightness
+390 increment: amount to change the brightness by each time (as a percentage)
+391 force: [*Linux only*] allow the brightness to be set to 0. By default,
+392 brightness values will never be set lower than 1, since setting them to 0
+393 often turns off the backlight
+394 logarithmic: follow a logarithmic curve when setting brightness values.
+395 See `logarithmic_range` for rationale
+396
+397 Returns:
+398 The brightness of the display after the fade is complete.
+399 See `.types.IntPercentage`
400
-401 for value in range_func(start, finish, increment):
-402 self.set_brightness(value)
-403 time.sleep(interval)
-404
-405 if self.get_brightness() != finish:
-406 self.set_brightness(finish, no_return=True)
-407
-408 return self.get_brightness()
+401 .. warning:: Deprecated
+402 This function will return `None` in v0.23.0 and later.
+403 '''
+404 # minimum brightness value
+405 if platform.system() == 'Linux' and not force:
+406 lower_bound = 1
+407 else:
+408 lower_bound = 0
+409
+410 current = self.get_brightness()
+411
+412 finish = percentage(finish, current, lower_bound)
+413 start = percentage(
+414 current if start is None else start, current, lower_bound)
+415
+416 # mypy says "object is not callable" but range is. Ignore this
+417 range_func: Callable = logarithmic_range if logarithmic else range # type: ignore[assignment]
+418 increment = abs(increment)
+419 if start > finish:
+420 increment = -increment
+421
+422 self._logger.debug(
+423 f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+424
+425 for value in range_func(start, finish, increment):
+426 self.set_brightness(value)
+427 time.sleep(interval)
+428
+429 if self.get_brightness() != finish:
+430 self.set_brightness(finish)
+431
+432 return self.get_brightness()
Example:
Arguments:
@@ -2113,28 +2164,28 @@
Returns:
@classmethod
def
-
from_dict(cls, display: dict) -> screen_brightness_control.Display:
+
from_dict(cls, display: dict) -> Display:
-
410 @classmethod
-411 def from_dict(cls, display: dict) -> 'Display':
-412 '''
-413 Initialise an instance of the class from a dictionary, ignoring
-414 any unwanted keys
-415 '''
-416 return cls(
-417 index=display['index'],
-418 method=display['method'],
-419 edid=display['edid'],
-420 manufacturer=display['manufacturer'],
-421 manufacturer_id=display['manufacturer_id'],
-422 model=display['model'],
-423 name=display['name'],
-424 serial=display['serial']
-425 )
+ 434 @classmethod
+435 def from_dict(cls, display: dict) -> 'Display':
+436 '''
+437 Initialise an instance of the class from a dictionary, ignoring
+438 any unwanted keys
+439 '''
+440 return cls(
+441 index=display['index'],
+442 method=display['method'],
+443 edid=display['edid'],
+444 manufacturer=display['manufacturer'],
+445 manufacturer_id=display['manufacturer_id'],
+446 model=display['model'],
+447 name=display['name'],
+448 serial=display['serial']
+449 )
Returns:
-
427 def get_brightness(self) -> IntPercentage:
-428 '''
-429 Returns the brightness of this display.
-430
-431 Returns:
-432 The brightness value of the display, as a percentage.
-433 See `types.IntPercentage`
-434 '''
-435 return self.method.get_brightness(display=self.index)[0]
+ 451 def get_brightness(self) -> IntPercentage:
+452 '''
+453 Returns the brightness of this display.
+454
+455 Returns:
+456 The brightness value of the display, as a percentage.
+457 See `.types.IntPercentage`
+458 '''
+459 return self.method.get_brightness(display=self.index)[0]
Returns:
The brightness value of the display, as a percentage.
- See types.IntPercentage
+ See screen_brightness_control.types.IntPercentage
@@ -2190,24 +2241,26 @@
Returns:
-
437 def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
-438 '''
-439 Returns the `types.DisplayIdentifier` for this display.
-440 Will iterate through the EDID, serial, name and index and return the first
-441 value that is not equal to None
-442
-443 Returns:
-444 The name of the property returned and the value of said property.
-445 EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
-446 '''
-447 for key in ('edid', 'serial', 'name', 'index'):
-448 value = getattr(self, key, None)
-449 if value is not None:
-450 return key, value
+ 461 def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+462 '''
+463 Returns the `.types.DisplayIdentifier` for this display.
+464 Will iterate through the EDID, serial, name and index and return the first
+465 value that is not equal to None
+466
+467 Returns:
+468 The name of the property returned and the value of said property.
+469 EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+470 '''
+471 for key in ('edid', 'serial', 'name'):
+472 value = getattr(self, key, None)
+473 if value is not None:
+474 return key, value
+475 # the index should surely never be `None`
+476 return 'index', self.index
Returns the types.DisplayIdentifier for this display.
+
-
452 def is_active(self) -> bool:
-453 '''
-454 Attempts to retrieve the brightness for this display. If it works the display is deemed active
-455 '''
-456 try:
-457 self.get_brightness()
-458 return True
-459 except Exception as e:
-460 self._logger.error(
-461 f'Monitor.is_active: {self.get_identifier()} failed get_brightness call'
-462 f' - {format_exc(e)}'
-463 )
-464 return False
+ 478 def is_active(self) -> bool:
+479 '''
+480 Attempts to retrieve the brightness for this display. If it works the display is deemed active
+481 '''
+482 try:
+483 self.get_brightness()
+484 return True
+485 except Exception as e:
+486 self._logger.error(
+487 f'Monitor.is_active: {self.get_identifier()} failed get_brightness call'
+488 f' - {format_exc(e)}'
+489 )
+490 return False
Returns:
-
466 def set_brightness(self, value: Percentage, force: bool = False):
-467 '''
-468 Sets the brightness for this display. See `set_brightness` for the full docs
-469
-470 Args:
-471 value (types.Percentage): the brightness percentage to set the display to
-472 force: allow the brightness to be set to 0 on Linux. This is disabled by default
-473 because setting the brightness of 0 will often turn off the backlight
-474 '''
-475 # convert brightness value to percentage
-476 if platform.system() == 'Linux' and not force:
-477 lower_bound = 1
-478 else:
-479 lower_bound = 0
-480
-481 value = percentage(
-482 value,
-483 current=lambda: self.method.get_brightness(display=self.index)[0],
-484 lower_bound=lower_bound
-485 )
-486
-487 self.method.set_brightness(value, display=self.index)
+ 492 def set_brightness(self, value: Percentage, force: bool = False):
+493 '''
+494 Sets the brightness for this display. See `set_brightness` for the full docs
+495
+496 Args:
+497 value (.types.Percentage): the brightness percentage to set the display to
+498 force: allow the brightness to be set to 0 on Linux. This is disabled by default
+499 because setting the brightness of 0 will often turn off the backlight
+500 '''
+501 # convert brightness value to percentage
+502 if platform.system() == 'Linux' and not force:
+503 lower_bound = 1
+504 else:
+505 lower_bound = 0
+506
+507 value = percentage(
+508 value,
+509 current=lambda: self.method.get_brightness(display=self.index)[0],
+510 lower_bound=lower_bound
+511 )
+512
+513 self.method.set_brightness(value, display=self.index)
Returns:
Arguments:
-- value (types.Percentage): the brightness percentage to set the display to
+- value (screen_brightness_control.types.Percentage): the brightness percentage to set the display to
- force: allow the brightness to be set to 0 on Linux. This is disabled by default
because setting the brightness of 0 will often turn off the backlight
@@ -2314,212 +2367,198 @@ Arguments:
-
490class Monitor(Display):
-491 '''
-492 Legacy class for managing displays.
-493
-494 .. warning:: Deprecated
-495 Deprecated for removal in v0.23.0. Please use the new `Display` class instead
-496 '''
-497
-498 def __init__(self, display: Union[int, str, dict]):
-499 '''
-500 Args:
-501 display (types.DisplayIdentifier or dict): the display you
-502 wish to control. Is passed to `filter_monitors`
-503 to decide which display to use.
-504
-505 Example:
-506 ```python
-507 import screen_brightness_control as sbc
-508
-509 # create a class for the primary display and then a specifically named monitor
-510 primary = sbc.Monitor(0)
-511 benq_monitor = sbc.Monitor('BenQ GL2450H')
-512
-513 # check if the benq monitor is the primary one
-514 if primary.serial == benq_monitor.serial:
-515 print('BenQ GL2450H is the primary display')
-516 else:
-517 print('The primary display is', primary.name)
-518
-519 # DEPRECATED BEHAVIOUR
-520 # Will be removed in v0.22.0
-521 print(primary['name'])
-522 print(benq_monitor['name'])
-523 ```
-524 '''
-525 warnings.warn(
-526 (
-527 '`Monitor` is deprecated for removal in v0.23.0.'
-528 ' Please use the new `Display` class instead'
-529 ),
-530 DeprecationWarning
-531 )
-532
-533 monitors_info = list_monitors_info(allow_duplicates=True)
-534 if isinstance(display, dict):
-535 if display in monitors_info:
-536 info = display
-537 else:
-538 info = filter_monitors(
-539 display=self.get_identifier(display),
-540 haystack=monitors_info
-541 )[0]
-542 else:
-543 info = filter_monitors(display=display, haystack=monitors_info)[0]
-544
-545 # make a copy so that we don't alter the dict in-place
-546 info = info.copy()
-547
-548 kw = [i.name for i in fields(Display) if i.init]
-549 super().__init__(**{k: v for k, v in info.items() if k in kw})
-550
-551 # this assigns any extra info that is returned to this class
-552 # eg: the 'interface' key in XRandr monitors on Linux
-553 for key, value in info.items():
-554 if key not in kw and value is not None:
-555 setattr(self, key, value)
-556
-557 def __getitem__(self, item: Any) -> Any:
-558 '''
-559 .. warning:: Deprecated
-560 This behaviour is deprecated and will be removed in v0.22.0
-561 '''
-562 warnings.warn(
-563 '`Monitor.__getitem__` is deprecated for removal in v0.22.0',
-564 DeprecationWarning
-565 )
-566 return getattr(self, item)
-567
-568 def get_identifier(self, monitor: dict = None) -> Tuple[str, DisplayIdentifier]:
-569 '''
-570 Returns the `types.DisplayIdentifier` for this display.
-571 Will iterate through the EDID, serial, name and index and return the first
-572 value that is not equal to None
-573
-574 Args:
-575 monitor: extract an identifier from this dict instead of the monitor class
-576
-577 Returns:
-578 A tuple containing the name of the property returned and the value of said
-579 property. EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
-580
-581 Example:
-582 ```python
-583 import screen_brightness_control as sbc
-584 primary = sbc.Monitor(0)
-585 print(primary.get_identifier()) # eg: ('serial', '123abc...')
+ 516class Monitor(Display):
+517 '''
+518 Legacy class for managing displays.
+519
+520 .. warning:: Deprecated
+521 Deprecated for removal in v0.23.0. Please use the new `Display` class instead
+522 '''
+523
+524 def __init__(self, display: Union[int, str, dict]):
+525 '''
+526 Args:
+527 display (.types.DisplayIdentifier or dict): the display you
+528 wish to control. Is passed to `filter_monitors`
+529 to decide which display to use.
+530
+531 Example:
+532 ```python
+533 import screen_brightness_control as sbc
+534
+535 # create a class for the primary display and then a specifically named monitor
+536 primary = sbc.Monitor(0)
+537 benq_monitor = sbc.Monitor('BenQ GL2450H')
+538
+539 # check if the benq monitor is the primary one
+540 if primary.serial == benq_monitor.serial:
+541 print('BenQ GL2450H is the primary display')
+542 else:
+543 print('The primary display is', primary.name)
+544 ```
+545 '''
+546 warnings.warn(
+547 (
+548 '`Monitor` is deprecated for removal in v0.23.0.'
+549 ' Please use the new `Display` class instead'
+550 ),
+551 DeprecationWarning
+552 )
+553
+554 monitors_info = list_monitors_info(allow_duplicates=True)
+555 if isinstance(display, dict):
+556 if display in monitors_info:
+557 info = display
+558 else:
+559 info = filter_monitors(
+560 display=self.get_identifier(display)[1],
+561 haystack=monitors_info
+562 )[0]
+563 else:
+564 info = filter_monitors(display=display, haystack=monitors_info)[0]
+565
+566 # make a copy so that we don't alter the dict in-place
+567 info = info.copy()
+568
+569 kw = [i.name for i in fields(Display) if i.init]
+570 super().__init__(**{k: v for k, v in info.items() if k in kw})
+571
+572 # this assigns any extra info that is returned to this class
+573 # eg: the 'interface' key in XRandr monitors on Linux
+574 for key, value in info.items():
+575 if key not in kw and value is not None:
+576 setattr(self, key, value)
+577
+578 def get_identifier(self, monitor: Optional[dict] = None) -> Tuple[str, DisplayIdentifier]:
+579 '''
+580 Returns the `.types.DisplayIdentifier` for this display.
+581 Will iterate through the EDID, serial, name and index and return the first
+582 value that is not equal to None
+583
+584 Args:
+585 monitor: extract an identifier from this dict instead of the monitor class
586
-587 secondary = sbc.list_monitors_info()[1]
-588 print(primary.get_identifier(monitor=secondary)) # eg: ('serial', '456def...')
-589
-590 # you can also use the class uninitialized
-591 print(sbc.Monitor.get_identifier(secondary)) # eg: ('serial', '456def...')
-592 ```
-593 '''
-594 if monitor is None:
-595 if isinstance(self, dict):
-596 monitor = self
-597 else:
-598 return super().get_identifier()
+587 Returns:
+588 A tuple containing the name of the property returned and the value of said
+589 property. EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+590
+591 Example:
+592 ```python
+593 import screen_brightness_control as sbc
+594 primary = sbc.Monitor(0)
+595 print(primary.get_identifier()) # eg: ('serial', '123abc...')
+596
+597 secondary = sbc.list_monitors_info()[1]
+598 print(primary.get_identifier(monitor=secondary)) # eg: ('serial', '456def...')
599
-600 for key in ('edid', 'serial', 'name', 'index'):
-601 value = monitor[key]
-602 if value is not None:
-603 return key, value
-604
-605 def set_brightness(
-606 self,
-607 value: Percentage,
-608 no_return: bool = True,
-609 force: bool = False
-610 ) -> Optional[IntPercentage]:
-611 '''
-612 Wrapper for `Display.set_brightness`
-613
-614 Args:
-615 value: see `Display.set_brightness`
-616 no_return: do not return the new brightness after it has been set
-617 force: see `Display.set_brightness`
-618 '''
-619 # refresh display info, in case another display has been unplugged or something
-620 # which would change the index of this display
-621 self.get_info()
-622 super().set_brightness(value, force)
-623 if not no_return:
-624 return self.get_brightness()
-625
-626 def get_brightness(self) -> IntPercentage:
-627 # refresh display info, in case another display has been unplugged or something
-628 # which would change the index of this display
-629 self.get_info()
-630 return super().get_brightness()
-631
-632 def fade_brightness(
-633 self,
-634 *args,
-635 blocking: bool = True,
-636 **kwargs
-637 ) -> Union[threading.Thread, IntPercentage]:
-638 '''
-639 Wrapper for `Display.fade_brightness`
-640
-641 Args:
-642 *args: see `Display.fade_brightness`
-643 blocking: run this function in the current thread and block until
-644 it completes. If `False`, the fade will be run in a new daemonic
-645 thread, which will be started and returned
-646 **kwargs: see `Display.fade_brightness`
-647 '''
-648 if not blocking:
-649 result = threading.Thread(
-650 target=super().fade_brightness, args=args, kwargs=kwargs, daemon=True)
-651 result.start()
-652 else:
-653 result = super().fade_brightness(*args, **kwargs)
-654
-655 return result
-656
-657 @classmethod
-658 def from_dict(cls, display) -> 'Monitor':
-659 return cls(display)
-660
-661 def get_info(self, refresh: bool = True) -> dict:
-662 '''
-663 Returns all known information about this monitor instance
-664
-665 Args:
-666 refresh: whether to refresh the information
-667 or to return the cached version
+600 # you can also use the class uninitialized
+601 print(sbc.Monitor.get_identifier(secondary)) # eg: ('serial', '456def...')
+602 ```
+603 '''
+604 if monitor is None:
+605 if isinstance(self, dict):
+606 monitor = self
+607 else:
+608 return super().get_identifier()
+609
+610 for key in ('edid', 'serial', 'name'):
+611 value = monitor[key]
+612 if value is not None:
+613 return key, value
+614 return 'index', self.index
+615
+616 def set_brightness(
+617 self,
+618 value: Percentage,
+619 no_return: bool = True,
+620 force: bool = False
+621 ) -> Optional[IntPercentage]:
+622 '''
+623 Wrapper for `Display.set_brightness`
+624
+625 Args:
+626 value: see `Display.set_brightness`
+627 no_return: do not return the new brightness after it has been set
+628 force: see `Display.set_brightness`
+629 '''
+630 # refresh display info, in case another display has been unplugged or something
+631 # which would change the index of this display
+632 self.get_info()
+633 super().set_brightness(value, force)
+634 if no_return:
+635 return None
+636 return self.get_brightness()
+637
+638 def get_brightness(self) -> IntPercentage:
+639 # refresh display info, in case another display has been unplugged or something
+640 # which would change the index of this display
+641 self.get_info()
+642 return super().get_brightness()
+643
+644 def fade_brightness(
+645 self,
+646 *args,
+647 blocking: bool = True,
+648 **kwargs
+649 ) -> Union[threading.Thread, IntPercentage]:
+650 '''
+651 Wrapper for `Display.fade_brightness`
+652
+653 Args:
+654 *args: see `Display.fade_brightness`
+655 blocking: run this function in the current thread and block until
+656 it completes. If `False`, the fade will be run in a new daemonic
+657 thread, which will be started and returned
+658 **kwargs: see `Display.fade_brightness`
+659 '''
+660 if blocking:
+661 super().fade_brightness(*args, **kwargs)
+662 return self.get_brightness()
+663
+664 thread = threading.Thread(
+665 target=super().fade_brightness, args=args, kwargs=kwargs, daemon=True)
+666 thread.start()
+667 return thread
668
-669 Example:
-670 ```python
-671 import screen_brightness_control as sbc
+669 @classmethod
+670 def from_dict(cls, display) -> 'Monitor':
+671 return cls(display)
672
-673 # initialize class for primary display
-674 primary = sbc.Monitor(0)
-675 # get the info
-676 info = primary.get_info()
-677 ```
-678 '''
-679 def vars_self():
-680 return {k: v for k, v in vars(self).items() if not k.startswith('_')}
-681
-682 if not refresh:
-683 return vars_self()
+673 def get_info(self, refresh: bool = True) -> dict:
+674 '''
+675 Returns all known information about this monitor instance
+676
+677 Args:
+678 refresh: whether to refresh the information
+679 or to return the cached version
+680
+681 Example:
+682 ```python
+683 import screen_brightness_control as sbc
684
-685 identifier = self.get_identifier()
-686
-687 if identifier is not None:
-688 # refresh the info we have on this monitor
-689 info = filter_monitors(
-690 display=identifier[1], method=self.method.__name__)[0]
-691 for key, value in info.items():
-692 if value is not None:
-693 setattr(self, key, value)
-694
-695 return vars_self()
+685 # initialize class for primary display
+686 primary = sbc.Monitor(0)
+687 # get the info
+688 info = primary.get_info()
+689 ```
+690 '''
+691 def vars_self():
+692 return {k: v for k, v in vars(self).items() if not k.startswith('_')}
+693
+694 if not refresh:
+695 return vars_self()
+696
+697 identifier = self.get_identifier()
+698
+699 if identifier is not None:
+700 # refresh the info we have on this monitor
+701 info = filter_monitors(
+702 display=identifier[1], method=self.method.__name__)[0]
+703 for key, value in info.items():
+704 if value is not None:
+705 setattr(self, key, value)
+706
+707 return vars_self()
Deprecated
-
498 def __init__(self, display: Union[int, str, dict]):
-499 '''
-500 Args:
-501 display (types.DisplayIdentifier or dict): the display you
-502 wish to control. Is passed to `filter_monitors`
-503 to decide which display to use.
-504
-505 Example:
-506 ```python
-507 import screen_brightness_control as sbc
-508
-509 # create a class for the primary display and then a specifically named monitor
-510 primary = sbc.Monitor(0)
-511 benq_monitor = sbc.Monitor('BenQ GL2450H')
-512
-513 # check if the benq monitor is the primary one
-514 if primary.serial == benq_monitor.serial:
-515 print('BenQ GL2450H is the primary display')
-516 else:
-517 print('The primary display is', primary.name)
-518
-519 # DEPRECATED BEHAVIOUR
-520 # Will be removed in v0.22.0
-521 print(primary['name'])
-522 print(benq_monitor['name'])
-523 ```
-524 '''
-525 warnings.warn(
-526 (
-527 '`Monitor` is deprecated for removal in v0.23.0.'
-528 ' Please use the new `Display` class instead'
-529 ),
-530 DeprecationWarning
-531 )
-532
-533 monitors_info = list_monitors_info(allow_duplicates=True)
-534 if isinstance(display, dict):
-535 if display in monitors_info:
-536 info = display
-537 else:
-538 info = filter_monitors(
-539 display=self.get_identifier(display),
-540 haystack=monitors_info
-541 )[0]
-542 else:
-543 info = filter_monitors(display=display, haystack=monitors_info)[0]
-544
-545 # make a copy so that we don't alter the dict in-place
-546 info = info.copy()
-547
-548 kw = [i.name for i in fields(Display) if i.init]
-549 super().__init__(**{k: v for k, v in info.items() if k in kw})
-550
-551 # this assigns any extra info that is returned to this class
-552 # eg: the 'interface' key in XRandr monitors on Linux
-553 for key, value in info.items():
-554 if key not in kw and value is not None:
-555 setattr(self, key, value)
+ 524 def __init__(self, display: Union[int, str, dict]):
+525 '''
+526 Args:
+527 display (.types.DisplayIdentifier or dict): the display you
+528 wish to control. Is passed to `filter_monitors`
+529 to decide which display to use.
+530
+531 Example:
+532 ```python
+533 import screen_brightness_control as sbc
+534
+535 # create a class for the primary display and then a specifically named monitor
+536 primary = sbc.Monitor(0)
+537 benq_monitor = sbc.Monitor('BenQ GL2450H')
+538
+539 # check if the benq monitor is the primary one
+540 if primary.serial == benq_monitor.serial:
+541 print('BenQ GL2450H is the primary display')
+542 else:
+543 print('The primary display is', primary.name)
+544 ```
+545 '''
+546 warnings.warn(
+547 (
+548 '`Monitor` is deprecated for removal in v0.23.0.'
+549 ' Please use the new `Display` class instead'
+550 ),
+551 DeprecationWarning
+552 )
+553
+554 monitors_info = list_monitors_info(allow_duplicates=True)
+555 if isinstance(display, dict):
+556 if display in monitors_info:
+557 info = display
+558 else:
+559 info = filter_monitors(
+560 display=self.get_identifier(display)[1],
+561 haystack=monitors_info
+562 )[0]
+563 else:
+564 info = filter_monitors(display=display, haystack=monitors_info)[0]
+565
+566 # make a copy so that we don't alter the dict in-place
+567 info = info.copy()
+568
+569 kw = [i.name for i in fields(Display) if i.init]
+570 super().__init__(**{k: v for k, v in info.items() if k in kw})
+571
+572 # this assigns any extra info that is returned to this class
+573 # eg: the 'interface' key in XRandr monitors on Linux
+574 for key, value in info.items():
+575 if key not in kw and value is not None:
+576 setattr(self, key, value)
Arguments:
@@ -2629,11 +2663,6 @@
Example:
print('BenQ GL2450H is the primary display')
else:
print('The primary display is', primary.name)
-
-
# DEPRECATED BEHAVIOUR
-
# Will be removed in v0.22.0
-
print(primary['name'])
-
print(benq_monitor['name'])
Example:
def
- get_identifier(self, monitor: dict = None) -> Tuple[str, Union[int, str]]:
+ get_identifier(self, monitor: Optional[dict] = None) -> Tuple[str, Union[int, str]]:
- 568 def get_identifier(self, monitor: dict = None) -> Tuple[str, DisplayIdentifier]:
-569 '''
-570 Returns the `types.DisplayIdentifier` for this display.
-571 Will iterate through the EDID, serial, name and index and return the first
-572 value that is not equal to None
-573
-574 Args:
-575 monitor: extract an identifier from this dict instead of the monitor class
-576
-577 Returns:
-578 A tuple containing the name of the property returned and the value of said
-579 property. EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
-580
-581 Example:
-582 ```python
-583 import screen_brightness_control as sbc
-584 primary = sbc.Monitor(0)
-585 print(primary.get_identifier()) # eg: ('serial', '123abc...')
+ 578 def get_identifier(self, monitor: Optional[dict] = None) -> Tuple[str, DisplayIdentifier]:
+579 '''
+580 Returns the `.types.DisplayIdentifier` for this display.
+581 Will iterate through the EDID, serial, name and index and return the first
+582 value that is not equal to None
+583
+584 Args:
+585 monitor: extract an identifier from this dict instead of the monitor class
586
-587 secondary = sbc.list_monitors_info()[1]
-588 print(primary.get_identifier(monitor=secondary)) # eg: ('serial', '456def...')
-589
-590 # you can also use the class uninitialized
-591 print(sbc.Monitor.get_identifier(secondary)) # eg: ('serial', '456def...')
-592 ```
-593 '''
-594 if monitor is None:
-595 if isinstance(self, dict):
-596 monitor = self
-597 else:
-598 return super().get_identifier()
+587 Returns:
+588 A tuple containing the name of the property returned and the value of said
+589 property. EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+590
+591 Example:
+592 ```python
+593 import screen_brightness_control as sbc
+594 primary = sbc.Monitor(0)
+595 print(primary.get_identifier()) # eg: ('serial', '123abc...')
+596
+597 secondary = sbc.list_monitors_info()[1]
+598 print(primary.get_identifier(monitor=secondary)) # eg: ('serial', '456def...')
599
-600 for key in ('edid', 'serial', 'name', 'index'):
-601 value = monitor[key]
-602 if value is not None:
-603 return key, value
+600 # you can also use the class uninitialized
+601 print(sbc.Monitor.get_identifier(secondary)) # eg: ('serial', '456def...')
+602 ```
+603 '''
+604 if monitor is None:
+605 if isinstance(self, dict):
+606 monitor = self
+607 else:
+608 return super().get_identifier()
+609
+610 for key in ('edid', 'serial', 'name'):
+611 value = monitor[key]
+612 if value is not None:
+613 return key, value
+614 return 'index', self.index
Returns the types.DisplayIdentifier for this display.
+
-
605 def set_brightness(
-606 self,
-607 value: Percentage,
-608 no_return: bool = True,
-609 force: bool = False
-610 ) -> Optional[IntPercentage]:
-611 '''
-612 Wrapper for `Display.set_brightness`
-613
-614 Args:
-615 value: see `Display.set_brightness`
-616 no_return: do not return the new brightness after it has been set
-617 force: see `Display.set_brightness`
-618 '''
-619 # refresh display info, in case another display has been unplugged or something
-620 # which would change the index of this display
-621 self.get_info()
-622 super().set_brightness(value, force)
-623 if not no_return:
-624 return self.get_brightness()
+ 616 def set_brightness(
+617 self,
+618 value: Percentage,
+619 no_return: bool = True,
+620 force: bool = False
+621 ) -> Optional[IntPercentage]:
+622 '''
+623 Wrapper for `Display.set_brightness`
+624
+625 Args:
+626 value: see `Display.set_brightness`
+627 no_return: do not return the new brightness after it has been set
+628 force: see `Display.set_brightness`
+629 '''
+630 # refresh display info, in case another display has been unplugged or something
+631 # which would change the index of this display
+632 self.get_info()
+633 super().set_brightness(value, force)
+634 if no_return:
+635 return None
+636 return self.get_brightness()
Arguments:
-
626 def get_brightness(self) -> IntPercentage:
-627 # refresh display info, in case another display has been unplugged or something
-628 # which would change the index of this display
-629 self.get_info()
-630 return super().get_brightness()
+ 638 def get_brightness(self) -> IntPercentage:
+639 # refresh display info, in case another display has been unplugged or something
+640 # which would change the index of this display
+641 self.get_info()
+642 return super().get_brightness()
Returns:
The brightness value of the display, as a percentage.
- See types.IntPercentage
+ See screen_brightness_control.types.IntPercentage
@@ -2817,30 +2848,30 @@
Returns:
632 def fade_brightness(
-633 self,
-634 *args,
-635 blocking: bool = True,
-636 **kwargs
-637 ) -> Union[threading.Thread, IntPercentage]:
-638 '''
-639 Wrapper for `Display.fade_brightness`
-640
-641 Args:
-642 *args: see `Display.fade_brightness`
-643 blocking: run this function in the current thread and block until
-644 it completes. If `False`, the fade will be run in a new daemonic
-645 thread, which will be started and returned
-646 **kwargs: see `Display.fade_brightness`
-647 '''
-648 if not blocking:
-649 result = threading.Thread(
-650 target=super().fade_brightness, args=args, kwargs=kwargs, daemon=True)
-651 result.start()
-652 else:
-653 result = super().fade_brightness(*args, **kwargs)
-654
-655 return result
+ 644 def fade_brightness(
+645 self,
+646 *args,
+647 blocking: bool = True,
+648 **kwargs
+649 ) -> Union[threading.Thread, IntPercentage]:
+650 '''
+651 Wrapper for `Display.fade_brightness`
+652
+653 Args:
+654 *args: see `Display.fade_brightness`
+655 blocking: run this function in the current thread and block until
+656 it completes. If `False`, the fade will be run in a new daemonic
+657 thread, which will be started and returned
+658 **kwargs: see `Display.fade_brightness`
+659 '''
+660 if blocking:
+661 super().fade_brightness(*args, **kwargs)
+662 return self.get_brightness()
+663
+664 thread = threading.Thread(
+665 target=super().fade_brightness, args=args, kwargs=kwargs, daemon=True)
+666 thread.start()
+667 return thread
Arguments:
@classmethod
def
- from_dict(cls, display) -> screen_brightness_control.Monitor:
+ from_dict(cls, display) -> Monitor:
657 @classmethod
-658 def from_dict(cls, display) -> 'Monitor':
-659 return cls(display)
+ 669 @classmethod
+670 def from_dict(cls, display) -> 'Monitor':
+671 return cls(display)
Arguments:
661 def get_info(self, refresh: bool = True) -> dict:
-662 '''
-663 Returns all known information about this monitor instance
-664
-665 Args:
-666 refresh: whether to refresh the information
-667 or to return the cached version
-668
-669 Example:
-670 ```python
-671 import screen_brightness_control as sbc
-672
-673 # initialize class for primary display
-674 primary = sbc.Monitor(0)
-675 # get the info
-676 info = primary.get_info()
-677 ```
-678 '''
-679 def vars_self():
-680 return {k: v for k, v in vars(self).items() if not k.startswith('_')}
-681
-682 if not refresh:
-683 return vars_self()
+ 673 def get_info(self, refresh: bool = True) -> dict:
+674 '''
+675 Returns all known information about this monitor instance
+676
+677 Args:
+678 refresh: whether to refresh the information
+679 or to return the cached version
+680
+681 Example:
+682 ```python
+683 import screen_brightness_control as sbc
684
-685 identifier = self.get_identifier()
-686
-687 if identifier is not None:
-688 # refresh the info we have on this monitor
-689 info = filter_monitors(
-690 display=identifier[1], method=self.method.__name__)[0]
-691 for key, value in info.items():
-692 if value is not None:
-693 setattr(self, key, value)
-694
-695 return vars_self()
+685 # initialize class for primary display
+686 primary = sbc.Monitor(0)
+687 # get the info
+688 info = primary.get_info()
+689 ```
+690 '''
+691 def vars_self():
+692 return {k: v for k, v in vars(self).items() if not k.startswith('_')}
+693
+694 if not refresh:
+695 return vars_self()
+696
+697 identifier = self.get_identifier()
+698
+699 if identifier is not None:
+700 # refresh the info we have on this monitor
+701 info = filter_monitors(
+702 display=identifier[1], method=self.method.__name__)[0]
+703 for key, value in info.items():
+704 if value is not None:
+705 setattr(self, key, value)
+706
+707 return vars_self()
Inherited Members
698def filter_monitors(
-699 display: Optional[DisplayIdentifier] = None,
-700 haystack: Optional[List[dict]] = None,
-701 method: Optional[str] = None,
-702 include: List[str] = []
-703) -> List[dict]:
-704 '''
-705 Searches through the information for all detected displays
-706 and attempts to return the info matching the value given.
-707 Will attempt to match against index, name, model, edid, method and serial
-708
-709 Args:
-710 display (types.DisplayIdentifier): the display you are searching for
-711 haystack: the information to filter from.
-712 If this isn't set it defaults to the return of `list_monitors_info`
-713 method: the method the monitors use. See `get_methods` for
-714 more info on available methods
-715 include: extra fields of information to sort by
-716
-717 Raises:
-718 NoValidDisplayError: if the display does not have a match
-719
-720 Example:
-721 ```python
-722 import screen_brightness_control as sbc
-723
-724 search = 'GL2450H'
-725 match = sbc.filter_displays(search)
-726 print(match)
-727 # EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]
-728 ```
-729 '''
-730 if display is not None and type(display) not in (str, int):
-731 raise TypeError(
-732 f'display kwarg must be int or str, not "{type(display).__name__}"')
-733
-734 def get_monitor_list():
-735 # if we have been provided with a list of monitors to sift through then use that
-736 # otherwise, get the info ourselves
-737 if haystack is not None:
-738 monitors_with_duplicates = haystack
-739 if method is not None:
-740 method_class = next(get_methods(method).values())
-741 monitors_with_duplicates = [
-742 i for i in haystack if i['method'] == method_class]
-743 else:
-744 monitors_with_duplicates = list_monitors_info(
-745 method=method, allow_duplicates=True)
-746
-747 return monitors_with_duplicates
-748
-749 def filter_monitor_list(to_filter):
-750 # This loop does two things:
-751 # 1. Filters out duplicate monitors
-752 # 2. Matches the display kwarg (if applicable)
-753 filtered_displays = {}
-754 for monitor in to_filter:
-755 # find a valid identifier for a monitor, excluding any which are equal to None
-756 added = False
-757 for identifier in ['edid', 'serial', 'name', 'model'] + include:
-758 # check we haven't already added the monitor
-759 if monitor.get(identifier, None) is None:
-760 continue
-761
-762 m_id = monitor[identifier]
-763 if m_id in filtered_displays:
-764 break
-765
-766 if isinstance(display, str) and m_id != display:
-767 continue
-768
-769 if not added:
-770 filtered_displays[m_id] = monitor
-771 added = True
-772
-773 # if the display kwarg is an integer and we are currently at that index
-774 if isinstance(display, int) and len(filtered_displays) - 1 == display:
-775 return [monitor]
-776
-777 if added:
-778 break
-779 return list(filtered_displays.values())
+ 710def filter_monitors(
+711 display: Optional[DisplayIdentifier] = None,
+712 haystack: Optional[List[dict]] = None,
+713 method: Optional[str] = None,
+714 include: List[str] = []
+715) -> List[dict]:
+716 '''
+717 Searches through the information for all detected displays
+718 and attempts to return the info matching the value given.
+719 Will attempt to match against index, name, edid, method and serial
+720
+721 Args:
+722 display (.types.DisplayIdentifier): the display you are searching for
+723 haystack: the information to filter from.
+724 If this isn't set it defaults to the return of `list_monitors_info`
+725 method: the method the monitors use. See `get_methods` for
+726 more info on available methods
+727 include: extra fields of information to sort by
+728
+729 Raises:
+730 NoValidDisplayError: if the display does not have a match
+731
+732 Example:
+733 ```python
+734 import screen_brightness_control as sbc
+735
+736 search = 'GL2450H'
+737 match = sbc.filter_displays(search)
+738 print(match)
+739 # EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]
+740 ```
+741 '''
+742 if display is not None and type(display) not in (str, int):
+743 raise TypeError(
+744 f'display kwarg must be int or str, not "{type(display).__name__}"')
+745
+746 def get_monitor_list():
+747 # if we have been provided with a list of monitors to sift through then use that
+748 # otherwise, get the info ourselves
+749 if haystack is not None:
+750 monitors_with_duplicates = haystack
+751 if method is not None:
+752 method_class = next(iter(get_methods(method).values()))
+753 monitors_with_duplicates = [
+754 i for i in haystack if i['method'] == method_class]
+755 else:
+756 monitors_with_duplicates = list_monitors_info(
+757 method=method, allow_duplicates=True)
+758
+759 return monitors_with_duplicates
+760
+761 def filter_monitor_list(to_filter):
+762 # This loop does two things:
+763 # 1. Filters out duplicate monitors
+764 # 2. Matches the display kwarg (if applicable)
+765 filtered_displays = {}
+766 for monitor in to_filter:
+767 # find a valid identifier for a monitor, excluding any which are equal to None
+768 added = False
+769 for identifier in ['edid', 'serial', 'name'] + include:
+770 # check we haven't already added the monitor
+771 if monitor.get(identifier, None) is None:
+772 continue
+773
+774 m_id = monitor[identifier]
+775 if m_id in filtered_displays:
+776 break
+777
+778 if isinstance(display, str) and m_id != display:
+779 continue
780
-781 duplicates = []
-782 for _ in range(3):
-783 duplicates = get_monitor_list()
-784 if duplicates:
-785 break
-786 time.sleep(0.4)
-787 else:
-788 msg = 'no displays detected'
-789 if method is not None:
-790 msg += f' with method: {method!r}'
-791 raise NoValidDisplayError(msg)
+781 if not added:
+782 filtered_displays[m_id] = monitor
+783 added = True
+784
+785 # if the display kwarg is an integer and we are currently at that index
+786 if isinstance(display, int) and len(filtered_displays) - 1 == display:
+787 return [monitor]
+788
+789 if added:
+790 break
+791 return list(filtered_displays.values())
792
-793 monitors = filter_monitor_list(duplicates)
-794 if not monitors:
-795 # if no displays matched the query
-796 msg = 'no displays found'
-797 if display is not None:
-798 msg += f' with name/serial/model/edid/index of {display!r}'
-799 if method is not None:
-800 msg += f' with method of {method!r}'
-801 raise NoValidDisplayError(msg)
-802
-803 return monitors
+793 duplicates = []
+794 for _ in range(3):
+795 duplicates = get_monitor_list()
+796 if duplicates:
+797 break
+798 time.sleep(0.4)
+799 else:
+800 msg = 'no displays detected'
+801 if method is not None:
+802 msg += f' with method: {method!r}'
+803 raise NoValidDisplayError(msg)
+804
+805 monitors = filter_monitor_list(duplicates)
+806 if not monitors:
+807 # if no displays matched the query
+808 msg = 'no displays found'
+809 if display is not None:
+810 msg += f' with name/serial/edid/index of {display!r}'
+811 if method is not None:
+812 msg += f' with method of {method!r}'
+813 raise NoValidDisplayError(msg)
+814
+815 return monitors
Searches through the information for all detected displays
and attempts to return the info matching the value given.
-Will attempt to match against index, name, model, edid, method and serial
+Will attempt to match against index, name, edid, method and serial
Arguments:
-- display (types.DisplayIdentifier): the display you are searching for
+- display (screen_brightness_control.types.DisplayIdentifier): the display you are searching for
- haystack: the information to filter from.
If this isn't set it defaults to the return of
list_monitors_info
- method: the method the monitors use. See
get_methods for
diff --git a/docs/0.21.0/screen_brightness_control/exceptions.html b/docs/0.21.0/screen_brightness_control/exceptions.html
index 116b527..5a8444f 100644
--- a/docs/0.21.0/screen_brightness_control/exceptions.html
+++ b/docs/0.21.0/screen_brightness_control/exceptions.html
@@ -3,7 +3,7 @@
-
+
screen_brightness_control.exceptions API documentation
@@ -15,8 +15,8 @@
-
-
+
+
-
@@ -184,11 +191,11 @@
- 9class ScreenBrightnessError(Exception):
-10 '''
-11 Generic error class designed to make catching errors under one umbrella easy.
-12 '''
-13 ...
+ 10class ScreenBrightnessError(Exception):
+11 '''
+12 Generic error class designed to make catching errors under one umbrella easy.
+13 '''
+14 ...
Inherited Members
- builtins.BaseException
- with_traceback
- add_note
+ - args
@@ -222,12 +230,13 @@ Inherited Members
16class EDIDParseError(ScreenBrightnessError):
-17 ...
+ 17class EDIDParseError(ScreenBrightnessError):
+18 '''Unparsable/invalid EDID'''
+19 ...
Generic error class designed to make catching errors under one umbrella easy.
+
@@ -241,6 +250,7 @@
Inherited Members
- builtins.BaseException
- with_traceback
- add_note
+ - args
@@ -257,12 +267,13 @@
Inherited Members
20class NoValidDisplayError(ScreenBrightnessError, LookupError):
-21 ...
+ 22class NoValidDisplayError(ScreenBrightnessError, LookupError):
+23 '''Could not find a valid display'''
+24 ...
Generic error class designed to make catching errors under one umbrella easy.
+
Could not find a valid display
@@ -276,6 +287,7 @@
Inherited Members
- builtins.BaseException
- with_traceback
- add_note
+ - args
@@ -292,12 +304,13 @@
Inherited Members
24class I2CValidationError(ScreenBrightnessError):
-25 ...
+ 27class I2CValidationError(ScreenBrightnessError):
+28 '''I2C data validation failed'''
+29 ...
Generic error class designed to make catching errors under one umbrella easy.
+
I2C data validation failed
@@ -311,6 +324,7 @@
Inherited Members
- builtins.BaseException
- with_traceback
- add_note
+ - args
@@ -327,26 +341,92 @@
Inherited Members
28class MaxRetriesExceededError(ScreenBrightnessError, subprocess.CalledProcessError):
-29 ...
+ 32class MaxRetriesExceededError(ScreenBrightnessError, subprocess.CalledProcessError):
+33 '''
+34 The command has been retried too many times.
+35
+36 Example:
+37 ```python
+38 try:
+39 subprocess.check_output(['exit', '1'])
+40 except subprocess.CalledProcessError as e:
+41 raise MaxRetriesExceededError('failed after 1 try', e)
+42 ```
+43 '''
+44 def __init__(self, message: str, exc: subprocess.CalledProcessError):
+45 self.message: str = message
+46 ScreenBrightnessError.__init__(self, message)
+47 super().__init__(exc.returncode, exc.cmd, exc.stdout, exc.stderr)
+48
+49 def __str__(self):
+50 string = super().__str__()
+51 string += f'\n\t-> {self.message}'
+52 return string
Generic error class designed to make catching errors under one umbrella easy.
+
The command has been retried too many times.
+
+
Example:
+
+
+
+
try:
+ subprocess.check_output(['exit', '1'])
+except subprocess.CalledProcessError as e:
+ raise MaxRetriesExceededError('failed after 1 try', e)
+
+
+
+
+
+
+ MaxRetriesExceededError(message: str, exc: subprocess.CalledProcessError)
+
+
+
+
+
+
44 def __init__(self, message: str, exc: subprocess.CalledProcessError):
+45 self.message: str = message
+46 ScreenBrightnessError.__init__(self, message)
+47 super().__init__(exc.returncode, exc.cmd, exc.stdout, exc.stderr)
+
+
+
+
+
+
+
+
+ message: str
+
+
+
+
+
+
+
+
Inherited Members
- subprocess.CalledProcessError
- - CalledProcessError
+ - returncode
+ - cmd
+ - output
+ - stderr
- stdout
- builtins.BaseException
- with_traceback
- add_note
+ - args
diff --git a/docs/0.21.0/screen_brightness_control/helpers.html b/docs/0.21.0/screen_brightness_control/helpers.html
index 2f3e90c..10e211b 100644
--- a/docs/0.21.0/screen_brightness_control/helpers.html
+++ b/docs/0.21.0/screen_brightness_control/helpers.html
@@ -3,7 +3,7 @@
-
+
screen_brightness_control.helpers API documentation
@@ -15,8 +15,8 @@
-
-
+
+
+
+
+ MONITOR_MANUFACTURER_CODES =
+
+ {'AAC': 'AcerView', 'ACI': 'Asus (ASUSTeK Computer Inc.)', 'ACR': 'Acer', 'ACT': 'Targa', 'ADI': 'ADI Corporation', 'AIC': 'AG Neovo', 'ALX': 'Anrecson', 'AMW': 'AMW', 'AOC': 'AOC', 'API': 'Acer America Corp.', 'APP': 'Apple Computer', 'ART': 'ArtMedia', 'AST': 'AST Research', 'AUO': 'Asus', 'BMM': 'BMM', 'BNQ': 'BenQ', 'BOE': 'BOE Display Technology', 'CMO': 'Acer', 'CPL': 'Compal', 'CPQ': 'Compaq', 'CPT': 'Chunghwa Pciture Tubes, Ltd.', 'CTX': 'CTX', 'DEC': 'DEC', 'DEL': 'Dell', 'DPC': 'Delta', 'DWE': 'Daewoo', 'ECS': 'ELITEGROUP Computer Systems', 'EIZ': 'EIZO', 'ELS': 'ELSA', 'ENC': 'EIZO', 'EPI': 'Envision', 'FCM': 'Funai', 'FUJ': 'Fujitsu', 'FUS': 'Fujitsu-Siemens', 'GSM': 'LG Electronics', 'GWY': 'Gateway 2000', 'GBT': 'Gigabyte', 'HEI': 'Hyundai', 'HIQ': 'Hyundai ImageQuest', 'HIT': 'Hyundai', 'HPN': 'HP', 'HSD': 'Hannspree Inc', 'HSL': 'Hansol', 'HTC': 'Hitachi/Nissei', 'HWP': 'HP', 'IBM': 'IBM', 'ICL': 'Fujitsu ICL', 'IFS': 'InFocus', 'IQT': 'Hyundai', 'IVM': 'Iiyama', 'KDS': 'Korea Data Systems', 'KFC': 'KFC Computek', 'LEN': 'Lenovo', 'LGD': 'Asus', 'LKM': 'ADLAS / AZALEA', 'LNK': 'LINK Technologies, Inc.', 'LPL': 'Fujitsu', 'LTN': 'Lite-On', 'MAG': 'MAG InnoVision', 'MAX': 'Belinea', 'MEI': 'Panasonic', 'MEL': 'Mitsubishi Electronics', 'MIR': 'miro Computer Products AG', 'MSI': 'MSI', 'MS_': 'Panasonic', 'MTC': 'MITAC', 'NAN': 'Nanao', 'NEC': 'NEC', 'NOK': 'Nokia Data', 'NVD': 'Fujitsu', 'OPT': 'Optoma', 'OQI': 'OPTIQUEST', 'PBN': 'Packard Bell', 'PCK': 'Daewoo', 'PDC': 'Polaroid', 'PGS': 'Princeton Graphic Systems', 'PHL': 'Philips', 'PRT': 'Princeton', 'REL': 'Relisys', 'SAM': 'Samsung', 'SAN': 'Samsung', 'SBI': 'Smarttech', 'SEC': 'Hewlett-Packard', 'SGI': 'SGI', 'SMC': 'Samtron', 'SMI': 'Smile', 'SNI': 'Siemens Nixdorf', 'SNY': 'Sony', 'SPT': 'Sceptre', 'SRC': 'Shamrock', 'STN': 'Samtron', 'STP': 'Sceptre', 'SUN': 'Sun Microsystems', 'TAT': 'Tatung', 'TOS': 'Toshiba', 'TRL': 'Royal Information Company', 'TSB': 'Toshiba', 'UNK': 'Unknown', 'UNM': 'Unisys Corporation', 'VSC': 'ViewSonic', 'WTC': 'Wen Technology', 'ZCM': 'Zenith', '_YV': 'Fujitsu'}
+
+
+
+
+
+
+
+
@@ -649,51 +687,54 @@
128class BrightnessMethod(ABC):
-129 @abstractclassmethod
-130 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-131 '''
-132 Return information about detected displays.
-133
-134 Args:
-135 display (types.DisplayIdentifier): the specific display to return
-136 information about. This parameter is passed to `filter_monitors`
-137
-138 Returns:
-139 A list of dictionaries, each representing a detected display.
-140 Each returned dictionary will have the following keys:
-141 - name (`str`): the name of the display
-142 - model (`str`): the model of the display
-143 - manufacturer (`str`): the name of the display manufacturer
-144 - manufacturer_id (`str`): the three letter manufacturer code (see `MONITOR_MANUFACTURER_CODES`)
-145 - serial (`str`): the serial of the display OR some other unique identifier
-146 - edid (`str`): the EDID string for the display
-147 - method (`BrightnessMethod`): the brightness method associated with this display
-148 - index (`int`): the index of the display, relative to the brightness method
-149 '''
-150 ...
-151
-152 @abstractclassmethod
-153 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-154 '''
-155 Args:
-156 display: the index of the specific display to query.
-157 If unspecified, all detected displays are queried
-158
-159 Returns:
-160 A list of `types.IntPercentage` values, one for each
-161 queried display
-162 '''
-163 ...
-164
-165 @abstractclassmethod
-166 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-167 '''
-168 Args:
-169 value (types.IntPercentage): the new brightness value
-170 display: the index of the specific display to adjust.
-171 If unspecified, all detected displays are adjusted
-172 '''
-173 ...
+129 @classmethod
+130 @abstractmethod
+131 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+132 '''
+133 Return information about detected displays.
+134
+135 Args:
+136 display (.types.DisplayIdentifier): the specific display to return
+137 information about. This parameter is passed to `filter_monitors`
+138
+139 Returns:
+140 A list of dictionaries, each representing a detected display.
+141 Each returned dictionary will have the following keys:
+142 - name (`str`): the name of the display
+143 - model (`str`): the model of the display
+144 - manufacturer (`str`): the name of the display manufacturer
+145 - manufacturer_id (`str`): the three letter manufacturer code (see `MONITOR_MANUFACTURER_CODES`)
+146 - serial (`str`): the serial of the display OR some other unique identifier
+147 - edid (`str`): the EDID string for the display
+148 - method (`BrightnessMethod`): the brightness method associated with this display
+149 - index (`int`): the index of the display, relative to the brightness method
+150 '''
+151 ...
+152
+153 @classmethod
+154 @abstractmethod
+155 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+156 '''
+157 Args:
+158 display: the index of the specific display to query.
+159 If unspecified, all detected displays are queried
+160
+161 Returns:
+162 A list of `.types.IntPercentage` values, one for each
+163 queried display
+164 '''
+165 ...
+166
+167 @classmethod
+168 @abstractmethod
+169 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+170 '''
+171 Args:
+172 value (.types.IntPercentage): the new brightness value
+173 display: the index of the specific display to adjust.
+174 If unspecified, all detected displays are adjusted
+175 '''
+176 ...
-
@abstractclassmethod
+
@classmethod
+
@abstractmethod
def
get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]:
@@ -714,28 +756,29 @@
-
129 @abstractclassmethod
-130 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-131 '''
-132 Return information about detected displays.
-133
-134 Args:
-135 display (types.DisplayIdentifier): the specific display to return
-136 information about. This parameter is passed to `filter_monitors`
-137
-138 Returns:
-139 A list of dictionaries, each representing a detected display.
-140 Each returned dictionary will have the following keys:
-141 - name (`str`): the name of the display
-142 - model (`str`): the model of the display
-143 - manufacturer (`str`): the name of the display manufacturer
-144 - manufacturer_id (`str`): the three letter manufacturer code (see `MONITOR_MANUFACTURER_CODES`)
-145 - serial (`str`): the serial of the display OR some other unique identifier
-146 - edid (`str`): the EDID string for the display
-147 - method (`BrightnessMethod`): the brightness method associated with this display
-148 - index (`int`): the index of the display, relative to the brightness method
-149 '''
-150 ...
+ 129 @classmethod
+130 @abstractmethod
+131 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+132 '''
+133 Return information about detected displays.
+134
+135 Args:
+136 display (.types.DisplayIdentifier): the specific display to return
+137 information about. This parameter is passed to `filter_monitors`
+138
+139 Returns:
+140 A list of dictionaries, each representing a detected display.
+141 Each returned dictionary will have the following keys:
+142 - name (`str`): the name of the display
+143 - model (`str`): the model of the display
+144 - manufacturer (`str`): the name of the display manufacturer
+145 - manufacturer_id (`str`): the three letter manufacturer code (see `MONITOR_MANUFACTURER_CODES`)
+146 - serial (`str`): the serial of the display OR some other unique identifier
+147 - edid (`str`): the EDID string for the display
+148 - method (`BrightnessMethod`): the brightness method associated with this display
+149 - index (`int`): the index of the display, relative to the brightness method
+150 '''
+151 ...
Arguments:
Returns:
@@ -758,7 +801,7 @@ Returns:
- name (
str): the name of the display
- model (
str): the model of the display
- manufacturer (
str): the name of the display manufacturer
- - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES)
+ - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES)
- serial (
str): the serial of the display OR some other unique identifier
- edid (
str): the EDID string for the display
- method (
BrightnessMethod): the brightness method associated with this display
@@ -772,7 +815,8 @@ Returns:
-
@abstractclassmethod
+
@classmethod
+
@abstractmethod
def
get_brightness(cls, display: Optional[int] = None) -> List[int]:
@@ -781,18 +825,19 @@
Returns:
-
152 @abstractclassmethod
-153 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-154 '''
-155 Args:
-156 display: the index of the specific display to query.
-157 If unspecified, all detected displays are queried
-158
-159 Returns:
-160 A list of `types.IntPercentage` values, one for each
-161 queried display
-162 '''
-163 ...
+ 153 @classmethod
+154 @abstractmethod
+155 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+156 '''
+157 Args:
+158 display: the index of the specific display to query.
+159 If unspecified, all detected displays are queried
+160
+161 Returns:
+162 A list of `.types.IntPercentage` values, one for each
+163 queried display
+164 '''
+165 ...
Returns:
Returns:
- A list of types.IntPercentage values, one for each
+
A list of screen_brightness_control.types.IntPercentage values, one for each
queried display
@@ -816,7 +861,8 @@
Returns:
-
@abstractclassmethod
+
@classmethod
+
@abstractmethod
def
set_brightness(cls, value: int, display: Optional[int] = None):
@@ -825,22 +871,23 @@
Returns:
-
165 @abstractclassmethod
-166 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-167 '''
-168 Args:
-169 value (types.IntPercentage): the new brightness value
-170 display: the index of the specific display to adjust.
-171 If unspecified, all detected displays are adjusted
-172 '''
-173 ...
+ 167 @classmethod
+168 @abstractmethod
+169 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+170 '''
+171 Args:
+172 value (.types.IntPercentage): the new brightness value
+173 display: the index of the specific display to adjust.
+174 If unspecified, all detected displays are adjusted
+175 '''
+176 ...
Arguments:
@@ -860,15 +907,16 @@
Returns:
176class BrightnessMethodAdv(BrightnessMethod):
-177 @abstractclassmethod
-178 def _gdi(cls) -> List[dict]:
-179 '''
-180 Similar to `BrightnessMethod.get_display_info` except this method will also
-181 return unsupported displays, indicated by an `unsupported: bool` property
-182 in the returned dict
-183 '''
-184 ...
+ 179class BrightnessMethodAdv(BrightnessMethod):
+180 @classmethod
+181 @abstractmethod
+182 def _gdi(cls) -> List[dict]:
+183 '''
+184 Similar to `BrightnessMethod.get_display_info` except this method will also
+185 return unsupported displays, indicated by an `unsupported: bool` property
+186 in the returned dict
+187 '''
+188 ...
Inherited Members
228class EDID:
-229 '''
-230 Simple structure and method to extract display serial and name from an EDID string.
-231
-232 The EDID parsing was created with inspiration from the [pyedid library](https://github.com/jojonas/pyedid)
-233 '''
-234 EDID_FORMAT: str = (
-235 ">" # big-endian
-236 "8s" # constant header (8 bytes)
-237 "H" # manufacturer id (2 bytes)
-238 "H" # product id (2 bytes)
-239 "I" # serial number (4 bytes)
-240 "B" # manufactoring week (1 byte)
-241 "B" # manufactoring year (1 byte)
-242 "B" # edid version (1 byte)
-243 "B" # edid revision (1 byte)
-244 "B" # video input type (1 byte)
-245 "B" # horizontal size in cm (1 byte)
-246 "B" # vertical size in cm (1 byte)
-247 "B" # display gamma (1 byte)
-248 "B" # supported features (1 byte)
-249 "10s" # color characteristics (10 bytes)
-250 "H" # supported timings (2 bytes)
-251 "B" # reserved timing (1 byte)
-252 "16s" # EDID supported timings (16 bytes)
-253 "18s" # timing / display descriptor block 1 (18 bytes)
-254 "18s" # timing / display descriptor block 2 (18 bytes)
-255 "18s" # timing / display descriptor block 3 (18 bytes)
-256 "18s" # timing / display descriptor block 4 (18 bytes)
-257 "B" # extension flag (1 byte)
-258 "B" # checksum (1 byte)
-259 )
-260 '''The byte structure for EDID strings'''
-261 SERIAL_DESCRIPTOR = bytes.fromhex('00 00 00 ff 00')
-262 NAME_DESCRIPTOR = bytes.fromhex('00 00 00 fc 00')
-263
-264 @classmethod
-265 def parse(cls, edid: Union[bytes, str]) -> Tuple[Union[str, None], ...]:
-266 '''
-267 Takes an EDID string and parses some relevant information from it according to the
-268 [EDID 1.4](https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format)
-269 specification on Wikipedia.
-270
-271 Args:
-272 edid (bytes or str): the EDID, can either be raw bytes or
-273 a hex formatted string (00 ff ff ff ff...)
-274
-275 Returns:
-276 tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID,
-277 manufacturer, model, name, serial in that order.
-278 If any of these values are unable to be determined, they will be None.
-279 Otherwise, expect a string
-280
-281 Raises:
-282 EDIDParseError
-283
-284 Example:
-285 ```python
-286 import screen_brightness_control as sbc
-287
-288 edid = sbc.list_monitors_info()[0]['edid']
-289 manufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)
+ 242class EDID:
+243 '''
+244 Simple structure and method to extract display serial and name from an EDID string.
+245 '''
+246 EDID_FORMAT: str = (
+247 ">" # big-endian
+248 "8s" # constant header (8 bytes)
+249 "H" # manufacturer id (2 bytes)
+250 "H" # product id (2 bytes)
+251 "I" # serial number (4 bytes)
+252 "B" # manufactoring week (1 byte)
+253 "B" # manufactoring year (1 byte)
+254 "B" # edid version (1 byte)
+255 "B" # edid revision (1 byte)
+256 "B" # video input type (1 byte)
+257 "B" # horizontal size in cm (1 byte)
+258 "B" # vertical size in cm (1 byte)
+259 "B" # display gamma (1 byte)
+260 "B" # supported features (1 byte)
+261 "10s" # color characteristics (10 bytes)
+262 "H" # supported timings (2 bytes)
+263 "B" # reserved timing (1 byte)
+264 "16s" # EDID supported timings (16 bytes)
+265 "18s" # timing / display descriptor block 1 (18 bytes)
+266 "18s" # timing / display descriptor block 2 (18 bytes)
+267 "18s" # timing / display descriptor block 3 (18 bytes)
+268 "18s" # timing / display descriptor block 4 (18 bytes)
+269 "B" # extension flag (1 byte)
+270 "B" # checksum (1 byte)
+271 )
+272 '''
+273 The byte structure for EDID strings, taken from
+274 [pyedid](https://github.com/jojonas/pyedid/blob/2382910d968b2fa8de1fab495fbbdfebcdb39f19/pyedid/edid.py#L21),
+275 [Copyright 2019-2020 Jonas Lieb, Davydov Denis](https://github.com/jojonas/pyedid/blob/master/LICENSE).
+276 '''
+277 SERIAL_DESCRIPTOR = bytes.fromhex('00 00 00 ff 00')
+278 NAME_DESCRIPTOR = bytes.fromhex('00 00 00 fc 00')
+279
+280 @classmethod
+281 def parse(cls, edid: Union[bytes, str]) -> Tuple[Union[str, None], ...]:
+282 '''
+283 Takes an EDID string and parses some relevant information from it according to the
+284 [EDID 1.4](https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format)
+285 specification on Wikipedia.
+286
+287 Args:
+288 edid (bytes or str): the EDID, can either be raw bytes or
+289 a hex formatted string (00 ff ff ff ff...)
290
-291 print('Manufacturer:', manufacturer_id or 'Unknown')
-292 print('Model:', model or 'Unknown')
-293 print('Name:', name or 'Unknown')
-294 ```
-295 '''
-296 # see https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format
-297 if not isinstance(edid, bytes):
-298 edid = bytes.fromhex(edid)
+291 Returns:
+292 tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID,
+293 manufacturer, model, name, serial in that order.
+294 If any of these values are unable to be determined, they will be None.
+295 Otherwise, expect a string
+296
+297 Raises:
+298 EDIDParseError
299
-300 try:
-301 blocks = struct.unpack(cls.EDID_FORMAT, edid)
-302 except struct.error as e:
-303 raise EDIDParseError('cannot unpack edid') from e
-304
-305 mfg_id_block = blocks[1]
-306 # split mfg_id (2 bytes) into 3 letters, 5 bits each (ignoring reserved bit)
-307 mfg_id = (
-308 mfg_id_block >> 10, # First 6 bits (reserved bit at start is always 0)
-309 (mfg_id_block >> 5) & 0b11111, # isolate next 5 bits from first 11 using bitwise AND
-310 mfg_id_block & 0b11111 # Last five bits
-311 )
-312 # turn numbers into ascii
-313 mfg_id = ''.join(chr(i + 64) for i in mfg_id)
-314
-315 # now grab the manufacturer name
-316 mfg_lookup = _monitor_brand_lookup(mfg_id)
-317 if mfg_lookup is not None:
-318 manufacturer = mfg_lookup[1]
-319 else:
-320 manufacturer = None
-321
-322 serial = None
-323 name = None
-324 for descriptor_block in blocks[17:21]:
-325 # decode the serial
-326 if descriptor_block.startswith(cls.SERIAL_DESCRIPTOR):
-327 # strip descriptor bytes and trailing whitespace
-328 serial_bytes = descriptor_block[len(cls.SERIAL_DESCRIPTOR):].rstrip()
-329 serial = serial_bytes.decode()
-330
-331 # decode the monitor name
-332 elif descriptor_block.startswith(cls.NAME_DESCRIPTOR):
-333 # strip descriptor bytes and trailing whitespace
-334 name_bytes = descriptor_block[len(cls.NAME_DESCRIPTOR):].rstrip()
-335 name = name_bytes.decode()
+300 Example:
+301 ```python
+302 import screen_brightness_control as sbc
+303
+304 edid = sbc.list_monitors_info()[0]['edid']
+305 manufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)
+306
+307 print('Manufacturer:', manufacturer_id or 'Unknown')
+308 print('Model:', model or 'Unknown')
+309 print('Name:', name or 'Unknown')
+310 ```
+311 '''
+312 # see https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format
+313 if not isinstance(edid, bytes):
+314 edid = bytes.fromhex(edid)
+315
+316 try:
+317 blocks = struct.unpack(cls.EDID_FORMAT, edid)
+318 except struct.error as e:
+319 raise EDIDParseError('cannot unpack edid') from e
+320
+321 # split mfg_id (2 bytes) into 3 letters, 5 bits each (ignoring reserved bit)
+322 mfg_id_chars = (
+323 blocks[1] >> 10, # First 6 bits (reserved bit at start is always 0)
+324 (blocks[1] >> 5) & 0b11111, # isolate next 5 bits from first 11 using bitwise AND
+325 blocks[1] & 0b11111 # Last five bits
+326 )
+327 # turn numbers into ascii
+328 mfg_id = ''.join(chr(i + 64) for i in mfg_id_chars)
+329
+330 # now grab the manufacturer name
+331 mfg_lookup = _monitor_brand_lookup(mfg_id)
+332 if mfg_lookup is not None:
+333 manufacturer = mfg_lookup[1]
+334 else:
+335 manufacturer = None
336
-337 # now try to figure out what model the display is
-338 model = None
-339 if name is not None:
-340 if manufacturer is not None and name.startswith(manufacturer):
-341 # eg: 'BenQ GL2450H' -> ['BenQ', 'GL2450H']
-342 model = name.replace(manufacturer, '', 1).strip()
-343
-344 # if previous method did not work, try taking last word of name
-345 if not model:
-346 try:
-347 model = name.strip().rsplit(' ', 1)[1]
-348 except IndexError:
-349 # If the name does not include model information then
-350 # give it something generic
-351 model = 'Generic Monitor'
-352
-353 return mfg_id, manufacturer, model, name, serial
-354
-355 @staticmethod
-356 def hexdump(file: str) -> str:
-357 '''
-358 Returns a hexadecimal string of binary data from a file
-359
-360 Args:
-361 file (str): the file to read
-362
-363 Returns:
-364 str: one long hex string
-365
-366 Example:
-367 ```python
-368 from screen_brightness_control import EDID
+337 serial = None
+338 name = None
+339 for descriptor_block in blocks[17:21]:
+340 # decode the serial
+341 if descriptor_block.startswith(cls.SERIAL_DESCRIPTOR):
+342 # strip descriptor bytes and trailing whitespace
+343 serial_bytes = descriptor_block[len(cls.SERIAL_DESCRIPTOR):].rstrip()
+344 serial = serial_bytes.decode()
+345
+346 # decode the monitor name
+347 elif descriptor_block.startswith(cls.NAME_DESCRIPTOR):
+348 # strip descriptor bytes and trailing whitespace
+349 name_bytes = descriptor_block[len(cls.NAME_DESCRIPTOR):].rstrip()
+350 name = name_bytes.decode()
+351
+352 # now try to figure out what model the display is
+353 model = None
+354 if name is not None:
+355 if manufacturer is not None and name.startswith(manufacturer):
+356 # eg: 'BenQ GL2450H' -> ['BenQ', 'GL2450H']
+357 model = name.replace(manufacturer, '', 1).strip()
+358
+359 # if previous method did not work, try taking last word of name
+360 if not model:
+361 try:
+362 model = name.strip().rsplit(' ', 1)[1]
+363 except IndexError:
+364 # If the name does not include model information then
+365 # give it something generic
+366 model = 'Generic Monitor'
+367
+368 return mfg_id, manufacturer, model, name, serial
369
-370 print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
-371 # '00ffffffffffff00...'
-372 ```
-373 '''
-374 with open(file, 'rb') as f:
-375 hex_str = ''.join(f'{char:02x}' for char in f.read())
-376
-377 return hex_str
+370 @staticmethod
+371 def hexdump(file: str) -> str:
+372 '''
+373 Returns a hexadecimal string of binary data from a file
+374
+375 Args:
+376 file (str): the file to read
+377
+378 Returns:
+379 str: one long hex string
+380
+381 Example:
+382 ```python
+383 from screen_brightness_control import EDID
+384
+385 print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
+386 # '00ffffffffffff00...'
+387 ```
+388 '''
+389 with open(file, 'rb') as f:
+390 hex_str = ''.join(f'{char:02x}' for char in f.read())
+391
+392 return hex_str
Simple structure and method to extract display serial and name from an EDID string.
-
-
The EDID parsing was created with inspiration from the pyedid library
Inherited Members
The byte structure for EDID strings
+
+
+
+ SERIAL_DESCRIPTOR =
+b'\x00\x00\x00\xff\x00'
+
+
+
+
+
+
+
+
+
+ NAME_DESCRIPTOR =
+b'\x00\x00\x00\xfc\x00'
+
+
+
+
+
+
+
@@ -1085,96 +1158,95 @@
Inherited Members
- 264 @classmethod
-265 def parse(cls, edid: Union[bytes, str]) -> Tuple[Union[str, None], ...]:
-266 '''
-267 Takes an EDID string and parses some relevant information from it according to the
-268 [EDID 1.4](https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format)
-269 specification on Wikipedia.
-270
-271 Args:
-272 edid (bytes or str): the EDID, can either be raw bytes or
-273 a hex formatted string (00 ff ff ff ff...)
-274
-275 Returns:
-276 tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID,
-277 manufacturer, model, name, serial in that order.
-278 If any of these values are unable to be determined, they will be None.
-279 Otherwise, expect a string
-280
-281 Raises:
-282 EDIDParseError
-283
-284 Example:
-285 ```python
-286 import screen_brightness_control as sbc
-287
-288 edid = sbc.list_monitors_info()[0]['edid']
-289 manufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)
+ 280 @classmethod
+281 def parse(cls, edid: Union[bytes, str]) -> Tuple[Union[str, None], ...]:
+282 '''
+283 Takes an EDID string and parses some relevant information from it according to the
+284 [EDID 1.4](https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format)
+285 specification on Wikipedia.
+286
+287 Args:
+288 edid (bytes or str): the EDID, can either be raw bytes or
+289 a hex formatted string (00 ff ff ff ff...)
290
-291 print('Manufacturer:', manufacturer_id or 'Unknown')
-292 print('Model:', model or 'Unknown')
-293 print('Name:', name or 'Unknown')
-294 ```
-295 '''
-296 # see https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format
-297 if not isinstance(edid, bytes):
-298 edid = bytes.fromhex(edid)
+291 Returns:
+292 tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID,
+293 manufacturer, model, name, serial in that order.
+294 If any of these values are unable to be determined, they will be None.
+295 Otherwise, expect a string
+296
+297 Raises:
+298 EDIDParseError
299
-300 try:
-301 blocks = struct.unpack(cls.EDID_FORMAT, edid)
-302 except struct.error as e:
-303 raise EDIDParseError('cannot unpack edid') from e
-304
-305 mfg_id_block = blocks[1]
-306 # split mfg_id (2 bytes) into 3 letters, 5 bits each (ignoring reserved bit)
-307 mfg_id = (
-308 mfg_id_block >> 10, # First 6 bits (reserved bit at start is always 0)
-309 (mfg_id_block >> 5) & 0b11111, # isolate next 5 bits from first 11 using bitwise AND
-310 mfg_id_block & 0b11111 # Last five bits
-311 )
-312 # turn numbers into ascii
-313 mfg_id = ''.join(chr(i + 64) for i in mfg_id)
-314
-315 # now grab the manufacturer name
-316 mfg_lookup = _monitor_brand_lookup(mfg_id)
-317 if mfg_lookup is not None:
-318 manufacturer = mfg_lookup[1]
-319 else:
-320 manufacturer = None
-321
-322 serial = None
-323 name = None
-324 for descriptor_block in blocks[17:21]:
-325 # decode the serial
-326 if descriptor_block.startswith(cls.SERIAL_DESCRIPTOR):
-327 # strip descriptor bytes and trailing whitespace
-328 serial_bytes = descriptor_block[len(cls.SERIAL_DESCRIPTOR):].rstrip()
-329 serial = serial_bytes.decode()
-330
-331 # decode the monitor name
-332 elif descriptor_block.startswith(cls.NAME_DESCRIPTOR):
-333 # strip descriptor bytes and trailing whitespace
-334 name_bytes = descriptor_block[len(cls.NAME_DESCRIPTOR):].rstrip()
-335 name = name_bytes.decode()
+300 Example:
+301 ```python
+302 import screen_brightness_control as sbc
+303
+304 edid = sbc.list_monitors_info()[0]['edid']
+305 manufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)
+306
+307 print('Manufacturer:', manufacturer_id or 'Unknown')
+308 print('Model:', model or 'Unknown')
+309 print('Name:', name or 'Unknown')
+310 ```
+311 '''
+312 # see https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format
+313 if not isinstance(edid, bytes):
+314 edid = bytes.fromhex(edid)
+315
+316 try:
+317 blocks = struct.unpack(cls.EDID_FORMAT, edid)
+318 except struct.error as e:
+319 raise EDIDParseError('cannot unpack edid') from e
+320
+321 # split mfg_id (2 bytes) into 3 letters, 5 bits each (ignoring reserved bit)
+322 mfg_id_chars = (
+323 blocks[1] >> 10, # First 6 bits (reserved bit at start is always 0)
+324 (blocks[1] >> 5) & 0b11111, # isolate next 5 bits from first 11 using bitwise AND
+325 blocks[1] & 0b11111 # Last five bits
+326 )
+327 # turn numbers into ascii
+328 mfg_id = ''.join(chr(i + 64) for i in mfg_id_chars)
+329
+330 # now grab the manufacturer name
+331 mfg_lookup = _monitor_brand_lookup(mfg_id)
+332 if mfg_lookup is not None:
+333 manufacturer = mfg_lookup[1]
+334 else:
+335 manufacturer = None
336
-337 # now try to figure out what model the display is
-338 model = None
-339 if name is not None:
-340 if manufacturer is not None and name.startswith(manufacturer):
-341 # eg: 'BenQ GL2450H' -> ['BenQ', 'GL2450H']
-342 model = name.replace(manufacturer, '', 1).strip()
-343
-344 # if previous method did not work, try taking last word of name
-345 if not model:
-346 try:
-347 model = name.strip().rsplit(' ', 1)[1]
-348 except IndexError:
-349 # If the name does not include model information then
-350 # give it something generic
-351 model = 'Generic Monitor'
-352
-353 return mfg_id, manufacturer, model, name, serial
+337 serial = None
+338 name = None
+339 for descriptor_block in blocks[17:21]:
+340 # decode the serial
+341 if descriptor_block.startswith(cls.SERIAL_DESCRIPTOR):
+342 # strip descriptor bytes and trailing whitespace
+343 serial_bytes = descriptor_block[len(cls.SERIAL_DESCRIPTOR):].rstrip()
+344 serial = serial_bytes.decode()
+345
+346 # decode the monitor name
+347 elif descriptor_block.startswith(cls.NAME_DESCRIPTOR):
+348 # strip descriptor bytes and trailing whitespace
+349 name_bytes = descriptor_block[len(cls.NAME_DESCRIPTOR):].rstrip()
+350 name = name_bytes.decode()
+351
+352 # now try to figure out what model the display is
+353 model = None
+354 if name is not None:
+355 if manufacturer is not None and name.startswith(manufacturer):
+356 # eg: 'BenQ GL2450H' -> ['BenQ', 'GL2450H']
+357 model = name.replace(manufacturer, '', 1).strip()
+358
+359 # if previous method did not work, try taking last word of name
+360 if not model:
+361 try:
+362 model = name.strip().rsplit(' ', 1)[1]
+363 except IndexError:
+364 # If the name does not include model information then
+365 # give it something generic
+366 model = 'Generic Monitor'
+367
+368 return mfg_id, manufacturer, model, name, serial
Example:
355 @staticmethod
-356 def hexdump(file: str) -> str:
-357 '''
-358 Returns a hexadecimal string of binary data from a file
-359
-360 Args:
-361 file (str): the file to read
-362
-363 Returns:
-364 str: one long hex string
-365
-366 Example:
-367 ```python
-368 from screen_brightness_control import EDID
-369
-370 print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
-371 # '00ffffffffffff00...'
-372 ```
-373 '''
-374 with open(file, 'rb') as f:
-375 hex_str = ''.join(f'{char:02x}' for char in f.read())
-376
-377 return hex_str
+ 370 @staticmethod
+371 def hexdump(file: str) -> str:
+372 '''
+373 Returns a hexadecimal string of binary data from a file
+374
+375 Args:
+376 file (str): the file to read
+377
+378 Returns:
+379 str: one long hex string
+380
+381 Example:
+382 ```python
+383 from screen_brightness_control import EDID
+384
+385 print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
+386 # '00ffffffffffff00...'
+387 ```
+388 '''
+389 with open(file, 'rb') as f:
+390 hex_str = ''.join(f'{char:02x}' for char in f.read())
+391
+392 return hex_str
Example:
380def check_output(command: List[str], max_tries: int = 1) -> bytes:
-381 '''
-382 Run a command with retry management built in.
-383
-384 Args:
-385 command: the command to run
-386 max_tries: the maximum number of retries to allow before raising an error
-387
-388 Returns:
-389 The output from the command
-390 '''
-391 tries = 1
-392 while True:
-393 try:
-394 output = subprocess.check_output(command, stderr=subprocess.PIPE)
-395 except subprocess.CalledProcessError as e:
-396 if tries >= max_tries:
-397 raise MaxRetriesExceededError(f'process failed after {tries} tries') from e
-398 tries += 1
-399 time.sleep(0.04 if tries < 5 else 0.5)
-400 else:
-401 if tries > 1:
-402 logger.debug(f'command {command} took {tries}/{max_tries} tries')
-403 return output
+ 395def check_output(command: List[str], max_tries: int = 1) -> bytes:
+396 '''
+397 Run a command with retry management built in.
+398
+399 Args:
+400 command: the command to run
+401 max_tries: the maximum number of retries to allow before raising an error
+402
+403 Returns:
+404 The output from the command
+405 '''
+406 tries = 1
+407 while True:
+408 try:
+409 output = subprocess.check_output(command, stderr=subprocess.PIPE)
+410 except subprocess.CalledProcessError as e:
+411 if tries >= max_tries:
+412 raise MaxRetriesExceededError(f'process failed after {tries} tries', e) from e
+413 tries += 1
+414 time.sleep(0.04 if tries < 5 else 0.5)
+415 else:
+416 if tries > 1:
+417 _logger.debug(f'command {command} took {tries}/{max_tries} tries')
+418 return output
Returns:
406def logarithmic_range(start: int, stop: int, step: int = 1) -> Generator[int, None, None]:
-407 '''
-408 A `range`-like function that yields a sequence of integers following
-409 a logarithmic curve (`y = 10 ^ (x / 50)`) from `start` (inclusive) to
-410 `stop` (inclusive).
-411
-412 This is useful because it skips many of the higher percentages in the
-413 sequence where single percent brightness changes are hard to notice.
-414
-415 This function is designed to deal with brightness percentages, and so
-416 will never return a value less than 0 or greater than 100.
-417
-418 Args:
-419 start: the start of your percentage range
-420 stop: the end of your percentage range
-421 step: the increment per iteration through the sequence
-422
-423 Yields:
-424 int
-425 '''
-426 start = int(max(0, start))
-427 stop = int(min(100, stop))
-428
-429 if start == stop or abs(stop - start) <= 1:
-430 yield start
-431 else:
-432 value_range = stop - start
-433
-434 def direction(x):
-435 return x if step > 0 else 100 - x
-436
-437 last_yielded = None
-438 for x in range(start, stop + 1, step):
-439 # get difference from base point
-440 x -= start
-441 # calculate progress through our range as a percentage
-442 x = (x / value_range) * 100
-443 # convert along logarithmic curve (inverse of y = 50log(x)) to another percentage
-444 x = 10 ** (direction(x) / 50)
-445 # apply this percentage to our range and add back starting offset
-446 x = int(((direction(x) / 100) * value_range) + start)
-447
-448 if x == last_yielded:
-449 continue
-450 yield x
-451 last_yielded = x
+ 421def logarithmic_range(start: int, stop: int, step: int = 1) -> Generator[int, None, None]:
+422 '''
+423 A `range`-like function that yields a sequence of integers following
+424 a logarithmic curve (`y = 10 ^ (x / 50)`) from `start` (inclusive) to
+425 `stop` (inclusive).
+426
+427 This is useful because it skips many of the higher percentages in the
+428 sequence where single percent brightness changes are hard to notice.
+429
+430 This function is designed to deal with brightness percentages, and so
+431 will never return a value less than 0 or greater than 100.
+432
+433 Args:
+434 start: the start of your percentage range
+435 stop: the end of your percentage range
+436 step: the increment per iteration through the sequence
+437
+438 Yields:
+439 int
+440 '''
+441 start = int(max(0, start))
+442 stop = int(min(100, stop))
+443
+444 if start == stop or abs(stop - start) <= 1:
+445 yield start
+446 else:
+447 value_range = stop - start
+448
+449 def direction(x):
+450 return x if step > 0 else 100 - x
+451
+452 last_yielded = None
+453 x: float
+454 for x in range(start, stop + 1, step):
+455 # get difference from base point
+456 x -= start
+457 # calculate progress through our range as a percentage
+458 x = (x / value_range) * 100
+459 # convert along logarithmic curve (inverse of y = 50log(x)) to another percentage
+460 x = 10 ** (direction(x) / 50)
+461 # apply this percentage to our range and add back starting offset
+462 x = int(((direction(x) / 100) * value_range) + start)
+463
+464 if x == last_yielded:
+465 continue
+466 yield x
+467 last_yielded = x
Yields:
def
- percentage( value: Union[int, str], current: Union[int, Callable[[], int]] = None, lower_bound: int = 0) -> int:
+ percentage( value: Union[int, str], current: Union[int, Callable[[], int], NoneType] = None, lower_bound: int = 0) -> int:
- 473def percentage(
-474 value: Percentage,
-475 current: Union[int, Callable[[], int]] = None,
-476 lower_bound: int = 0
-477) -> IntPercentage:
-478 '''
-479 Convenience function to convert a brightness value into a percentage. Can handle
-480 integers, floats and strings. Also can handle relative strings (eg: `'+10'` or `'-10'`)
-481
-482 Args:
-483 value: the brightness value to convert
-484 current: the current brightness value or a function that returns the current brightness
-485 value. Used when dealing with relative brightness values
-486 lower_bound: the minimum value the brightness can be set to
-487
-488 Returns:
-489 The new brightness percentage, between `lower_bound` and 100
-490 '''
-491 if isinstance(value, str) and ('+' in value or '-' in value):
-492 if callable(current):
-493 current = current()
-494 value = int(float(value)) + int(float(str(current)))
-495 else:
-496 value = int(float(str(value)))
+ 489def percentage(
+490 value: Percentage,
+491 current: Optional[Union[int, Callable[[], int]]] = None,
+492 lower_bound: int = 0
+493) -> IntPercentage:
+494 '''
+495 Convenience function to convert a brightness value into a percentage. Can handle
+496 integers, floats and strings. Also can handle relative strings (eg: `'+10'` or `'-10'`)
497
-498 return min(100, max(lower_bound, value))
+498 Args:
+499 value: the brightness value to convert
+500 current: the current brightness value or a function that returns the current brightness
+501 value. Used when dealing with relative brightness values
+502 lower_bound: the minimum value the brightness can be set to
+503
+504 Returns:
+505 The new brightness percentage, between `lower_bound` and 100
+506 '''
+507 if isinstance(value, str) and ('+' in value or '-' in value):
+508 if callable(current):
+509 current = current()
+510 value = int(float(value)) + int(float(str(current)))
+511 else:
+512 value = int(float(str(value)))
+513
+514 return min(100, max(lower_bound, value))
30 `/sys/class/backlight/*/brightness` or you will need to run the program
31 as root.
32 '''
- 33 logger = logger.getChild('SysFiles')
+ 33 _logger = _logger.getChild('SysFiles')
34
35 @classmethod
36 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
@@ -284,12 +296,12 @@
39 if os.path.isdir(f'/sys/class/backlight/{folder}/subsystem'):
40 subsystems.add(tuple(os.listdir(f'/sys/class/backlight/{folder}/subsystem')))
41
- 42 all_displays = {}
+ 42 displays_by_edid = {}
43 index = 0
44
45 for subsystem in subsystems:
46
- 47 device = {
+ 47 device: dict = {
48 'name': subsystem[0],
49 'path': f'/sys/class/backlight/{subsystem[0]}',
50 'method': cls,
@@ -315,7 +327,7 @@
70 device['path'] = f'/sys/class/backlight/{folder}'
71 device['scale'] = scale
72 except (FileNotFoundError, TypeError) as e:
- 73 cls.logger.error(
+ 73 cls._logger.error(
74 f'error getting highest resolution scale for {folder}'
75 f' - {format_exc(e)}'
76 )
@@ -332,10 +344,10 @@
87 continue
88 device[key] = value
89
- 90 all_displays[device['edid']] = device
+ 90 displays_by_edid[device['edid']] = device
91 index += 1
92
- 93 all_displays = list(all_displays.values())
+ 93 all_displays = list(displays_by_edid.values())
94 if display is not None:
95 all_displays = filter_monitors(
96 display=display, haystack=all_displays, include=['path'])
@@ -385,7 +397,7 @@
140 * [ddcci.py](https://github.com/siemer/ddcci)
141 * [DDCCI Spec](https://milek7.pl/ddcbacklight/ddcci.pdf)
142 '''
-143 logger = logger.getChild('I2C')
+143 _logger = _logger.getChild('I2C')
144
145 # vcp commands
146 GET_VCP_CMD = 0x01
@@ -466,7 +478,7 @@
221 Args:
222 i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
223 '''
-224 self.logger = logger.getChild(
+224 self.logger = _logger.getChild(
225 self.__class__.__name__).getChild(i2c_path)
226 super().__init__(i2c_path, I2C.DDCCI_ADDR)
227
@@ -584,7 +596,7 @@
339 # read some 512 bytes from the device
340 data = device.read(512)
341 except IOError as e:
-342 cls.logger.error(
+342 cls._logger.error(
343 f'IOError reading from device {i2c_path}: {e}')
344 continue
345
@@ -596,491 +608,494 @@
351 # grab 128 bytes of the edid
352 edid = data[start: start + 128]
353 # parse the EDID
-354 manufacturer_id, manufacturer, model, name, serial = EDID.parse(
-355 edid)
-356 # convert edid to hex string
-357 edid = ''.join(f'{i:02x}' for i in edid)
-358
-359 all_displays.append(
-360 {
-361 'name': name,
-362 'model': model,
-363 'manufacturer': manufacturer,
-364 'manufacturer_id': manufacturer_id,
-365 'serial': serial,
-366 'method': cls,
-367 'index': index,
-368 'edid': edid,
-369 'i2c_bus': i2c_path
-370 }
-371 )
-372 index += 1
-373
-374 if all_displays:
-375 __cache__.store('i2c_display_info', all_displays, expires=2)
-376
-377 if display is not None:
-378 return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
-379 return all_displays
+354 (
+355 manufacturer_id,
+356 manufacturer,
+357 model,
+358 name,
+359 serial
+360 ) = EDID.parse(edid)
+361
+362 all_displays.append(
+363 {
+364 'name': name,
+365 'model': model,
+366 'manufacturer': manufacturer,
+367 'manufacturer_id': manufacturer_id,
+368 'serial': serial,
+369 'method': cls,
+370 'index': index,
+371 # convert edid to hex string
+372 'edid': ''.join(f'{i:02x}' for i in edid),
+373 'i2c_bus': i2c_path
+374 }
+375 )
+376 index += 1
+377
+378 if all_displays:
+379 __cache__.store('i2c_display_info', all_displays, expires=2)
380
-381 @classmethod
-382 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-383 all_displays = cls.get_display_info()
-384 if display is not None:
-385 all_displays = [all_displays[display]]
-386
-387 results = []
-388 for device in all_displays:
-389 interface = cls.DDCInterface(device['i2c_bus'])
-390 value, max_value = interface.getvcp(0x10)
-391
-392 # make sure display's max brighness is cached
-393 cache_ident = '%s-%s-%s' % (device['name'],
-394 device['model'], device['serial'])
-395 if cache_ident not in cls._max_brightness_cache:
-396 cls._max_brightness_cache[cache_ident] = max_value
-397 cls.logger.info(
-398 f'{cache_ident} max brightness:{max_value} (current: {value})')
-399
-400 if max_value != 100:
-401 # if max value is not 100 then we have to adjust the scale to be
-402 # a percentage
-403 value = int((value / max_value) * 100)
-404
-405 results.append(value)
-406
-407 return results
+381 if display is not None:
+382 return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+383 return all_displays
+384
+385 @classmethod
+386 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+387 all_displays = cls.get_display_info()
+388 if display is not None:
+389 all_displays = [all_displays[display]]
+390
+391 results = []
+392 for device in all_displays:
+393 interface = cls.DDCInterface(device['i2c_bus'])
+394 value, max_value = interface.getvcp(0x10)
+395
+396 # make sure display's max brighness is cached
+397 cache_ident = '%s-%s-%s' % (device['name'],
+398 device['model'], device['serial'])
+399 if cache_ident not in cls._max_brightness_cache:
+400 cls._max_brightness_cache[cache_ident] = max_value
+401 cls._logger.info(
+402 f'{cache_ident} max brightness:{max_value} (current: {value})')
+403
+404 if max_value != 100:
+405 # if max value is not 100 then we have to adjust the scale to be
+406 # a percentage
+407 value = int((value / max_value) * 100)
408
-409 @classmethod
-410 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-411 all_displays = cls.get_display_info()
-412 if display is not None:
-413 all_displays = [all_displays[display]]
-414
-415 for device in all_displays:
-416 # make sure display brightness max value is cached
-417 cache_ident = '%s-%s-%s' % (device['name'],
-418 device['model'], device['serial'])
-419 if cache_ident not in cls._max_brightness_cache:
-420 cls.get_brightness(display=device['index'])
-421
-422 # scale the brightness value according to the max brightness
-423 max_value = cls._max_brightness_cache[cache_ident]
-424 if max_value != 100:
-425 value = int((value / 100) * max_value)
-426
-427 interface = cls.DDCInterface(device['i2c_bus'])
-428 interface.setvcp(0x10, value)
-429
+409 results.append(value)
+410
+411 return results
+412
+413 @classmethod
+414 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+415 all_displays = cls.get_display_info()
+416 if display is not None:
+417 all_displays = [all_displays[display]]
+418
+419 for device in all_displays:
+420 # make sure display brightness max value is cached
+421 cache_ident = '%s-%s-%s' % (device['name'],
+422 device['model'], device['serial'])
+423 if cache_ident not in cls._max_brightness_cache:
+424 cls.get_brightness(display=device['index'])
+425
+426 # scale the brightness value according to the max brightness
+427 max_value = cls._max_brightness_cache[cache_ident]
+428 if max_value != 100:
+429 value = int((value / 100) * max_value)
430
-431class Light(BrightnessMethod):
-432 '''
-433 Wraps around [light](https://github.com/haikarainen/light), an external
-434 3rd party tool that can control brightness levels for e-DP displays.
-435
-436 .. warning::
-437 As of April 2nd 2023, the official repository for the light project has
-438 [been archived](https://github.com/haikarainen/light/issues/147) and
-439 will no longer receive any updates unless another maintainer picks it
-440 up.
-441 '''
-442
-443 executable: str = 'light'
-444 '''the light executable to be called'''
-445
-446 @classmethod
-447 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-448 '''
-449 Implements `BrightnessMethod.get_display_info`.
-450
-451 Works by taking the output of `SysFiles.get_display_info` and
-452 filtering out any displays that aren't supported by Light
-453 '''
-454 light_output = check_output([cls.executable, '-L']).decode()
-455 displays = []
-456 index = 0
-457 for device in SysFiles.get_display_info():
-458 # SysFiles scrapes info from the same place that Light used to
-459 # so it makes sense to use that output
-460 if device['path'].replace('/sys/class', 'sysfs') in light_output:
-461 del device['scale']
-462 device['light_path'] = device['path'].replace(
-463 '/sys/class', 'sysfs')
-464 device['method'] = cls
-465 device['index'] = index
-466
-467 displays.append(device)
-468 index += 1
-469
-470 if display is not None:
-471 displays = filter_monitors(display=display, haystack=displays, include=[
-472 'path', 'light_path'])
-473 return displays
-474
-475 @classmethod
-476 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-477 info = cls.get_display_info()
-478 if display is not None:
-479 info = [info[display]]
-480
-481 for i in info:
-482 check_output(
-483 f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
+431 interface = cls.DDCInterface(device['i2c_bus'])
+432 interface.setvcp(0x10, value)
+433
+434
+435class Light(BrightnessMethod):
+436 '''
+437 Wraps around [light](https://github.com/haikarainen/light), an external
+438 3rd party tool that can control brightness levels for e-DP displays.
+439
+440 .. warning::
+441 As of April 2nd 2023, the official repository for the light project has
+442 [been archived](https://github.com/haikarainen/light/issues/147) and
+443 will no longer receive any updates unless another maintainer picks it
+444 up.
+445 '''
+446
+447 executable: str = 'light'
+448 '''the light executable to be called'''
+449
+450 @classmethod
+451 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+452 '''
+453 Implements `BrightnessMethod.get_display_info`.
+454
+455 Works by taking the output of `SysFiles.get_display_info` and
+456 filtering out any displays that aren't supported by Light
+457 '''
+458 light_output = check_output([cls.executable, '-L']).decode()
+459 displays = []
+460 index = 0
+461 for device in SysFiles.get_display_info():
+462 # SysFiles scrapes info from the same place that Light used to
+463 # so it makes sense to use that output
+464 if device['path'].replace('/sys/class', 'sysfs') in light_output:
+465 del device['scale']
+466 device['light_path'] = device['path'].replace(
+467 '/sys/class', 'sysfs')
+468 device['method'] = cls
+469 device['index'] = index
+470
+471 displays.append(device)
+472 index += 1
+473
+474 if display is not None:
+475 displays = filter_monitors(display=display, haystack=displays, include=[
+476 'path', 'light_path'])
+477 return displays
+478
+479 @classmethod
+480 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+481 info = cls.get_display_info()
+482 if display is not None:
+483 info = [info[display]]
484
-485 @classmethod
-486 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-487 info = cls.get_display_info()
-488 if display is not None:
-489 info = [info[display]]
-490
-491 results = []
-492 for i in info:
-493 results.append(
-494 check_output([cls.executable, '-G', '-s', i['light_path']])
-495 )
-496 results = [int(round(float(i.decode()), 0)) for i in results]
-497 return results
-498
-499
-500class XRandr(BrightnessMethodAdv):
-501 '''collection of screen brightness related methods using the xrandr executable'''
+485 for i in info:
+486 check_output(
+487 f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
+488
+489 @classmethod
+490 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+491 info = cls.get_display_info()
+492 if display is not None:
+493 info = [info[display]]
+494
+495 results = []
+496 for i in info:
+497 results.append(
+498 check_output([cls.executable, '-G', '-s', i['light_path']])
+499 )
+500 return [int(round(float(i.decode()), 0)) for i in results]
+501
502
-503 executable: str = 'xrandr'
-504 '''the xrandr executable to be called'''
+503class XRandr(BrightnessMethodAdv):
+504 '''collection of screen brightness related methods using the xrandr executable'''
505
-506 @classmethod
-507 def _gdi(cls):
-508 '''
-509 .. warning:: Don't use this
-510 This function isn't final and I will probably make breaking changes to it.
-511 You have been warned
-512
-513 Gets all displays reported by XRandr even if they're not supported
-514 '''
-515 xrandr_output = check_output(
-516 [cls.executable, '--verbose']).decode().split('\n')
-517
-518 display_count = 0
-519 tmp_display = {}
+506 executable: str = 'xrandr'
+507 '''the xrandr executable to be called'''
+508
+509 @classmethod
+510 def _gdi(cls):
+511 '''
+512 .. warning:: Don't use this
+513 This function isn't final and I will probably make breaking changes to it.
+514 You have been warned
+515
+516 Gets all displays reported by XRandr even if they're not supported
+517 '''
+518 xrandr_output = check_output(
+519 [cls.executable, '--verbose']).decode().split('\n')
520
-521 for line_index, line in enumerate(xrandr_output):
-522 if line == '':
-523 continue
-524
-525 if not line.startswith((' ', '\t')) and 'connected' in line and 'disconnected' not in line:
-526 if tmp_display:
-527 yield tmp_display
-528
-529 tmp_display = {
-530 'name': line.split(' ')[0],
-531 'interface': line.split(' ')[0],
-532 'method': cls,
-533 'index': display_count,
-534 'model': None,
-535 'serial': None,
-536 'manufacturer': None,
-537 'manufacturer_id': None,
-538 'edid': None,
-539 'unsupported': line.startswith('XWAYLAND')
-540 }
-541 display_count += 1
-542
-543 elif 'EDID:' in line:
-544 # extract the edid from the chunk of the output that will contain the edid
-545 edid = ''.join(
-546 i.replace('\t', '') for i in xrandr_output[line_index + 1: line_index + 9]
-547 )
-548 tmp_display['edid'] = edid
-549
-550 for key, value in zip(
-551 ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
-552 EDID.parse(tmp_display['edid'])
-553 ):
-554 if value is None:
-555 continue
-556 tmp_display[key] = value
-557
-558 elif 'Brightness:' in line:
-559 tmp_display['brightness'] = int(
-560 float(line.replace('Brightness:', '')) * 100)
-561
-562 if tmp_display:
-563 yield tmp_display
+521 display_count = 0
+522 tmp_display: dict = {}
+523
+524 for line_index, line in enumerate(xrandr_output):
+525 if line == '':
+526 continue
+527
+528 if not line.startswith((' ', '\t')) and 'connected' in line and 'disconnected' not in line:
+529 if tmp_display:
+530 yield tmp_display
+531
+532 tmp_display = {
+533 'name': line.split(' ')[0],
+534 'interface': line.split(' ')[0],
+535 'method': cls,
+536 'index': display_count,
+537 'model': None,
+538 'serial': None,
+539 'manufacturer': None,
+540 'manufacturer_id': None,
+541 'edid': None,
+542 'unsupported': line.startswith('XWAYLAND')
+543 }
+544 display_count += 1
+545
+546 elif 'EDID:' in line:
+547 # extract the edid from the chunk of the output that will contain the edid
+548 edid = ''.join(
+549 i.replace('\t', '') for i in xrandr_output[line_index + 1: line_index + 9]
+550 )
+551 tmp_display['edid'] = edid
+552
+553 for key, value in zip(
+554 ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+555 EDID.parse(tmp_display['edid'])
+556 ):
+557 if value is None:
+558 continue
+559 tmp_display[key] = value
+560
+561 elif 'Brightness:' in line:
+562 tmp_display['brightness'] = int(
+563 float(line.replace('Brightness:', '')) * 100)
564
-565 @classmethod
-566 def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
-567 '''
-568 Implements `BrightnessMethod.get_display_info`.
-569
-570 Args:
-571 display: the index of the specific display to query.
-572 If unspecified, all detected displays are queried
-573 brightness: whether to include the current brightness
-574 in the returned info
-575 '''
-576 valid_displays = []
-577 for item in cls._gdi():
-578 if item['unsupported']:
-579 continue
-580 if not brightness:
-581 del item['brightness']
-582 del item['unsupported']
-583 valid_displays.append(item)
-584 if display is not None:
-585 valid_displays = filter_monitors(
-586 display=display, haystack=valid_displays, include=['interface'])
-587 return valid_displays
-588
-589 @classmethod
-590 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-591 monitors = cls.get_display_info(brightness=True)
-592 if display is not None:
-593 monitors = [monitors[display]]
-594 brightness = [i['brightness'] for i in monitors]
-595
-596 return brightness
-597
-598 @classmethod
-599 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-600 value = str(float(value) / 100)
-601 info = cls.get_display_info()
-602 if display is not None:
-603 info = [info[display]]
-604
-605 for i in info:
-606 check_output([cls.executable, '--output',
-607 i['interface'], '--brightness', value])
-608
-609
-610class DDCUtil(BrightnessMethodAdv):
-611 '''collection of screen brightness related methods using the ddcutil executable'''
-612 logger = logger.getChild('DDCUtil')
-613
-614 executable: str = 'ddcutil'
-615 '''the ddcutil executable to be called'''
-616 sleep_multiplier: float = 0.5
-617 '''how long ddcutil should sleep between each DDC request (lower is shorter).
-618 See [the ddcutil docs](https://www.ddcutil.com/performance_options/) for more info.'''
-619 cmd_max_tries: int = 10
-620 '''max number of retries when calling the ddcutil'''
-621 enable_async = True
-622 _max_brightness_cache: dict = {}
-623 '''Cache for displays and their maximum brightness values'''
-624
-625 @classmethod
-626 def _gdi(cls):
-627 '''
-628 .. warning:: Don't use this
-629 This function isn't final and I will probably make breaking changes to it.
-630 You have been warned
-631
-632 Gets all displays reported by DDCUtil even if they're not supported
-633 '''
-634 raw_ddcutil_output = str(
-635 check_output(
-636 [
-637 cls.executable, 'detect', '-v',
-638 f'--sleep-multiplier={cls.sleep_multiplier}'
-639 ] + ['--async'] if cls.enable_async else [], max_tries=cls.cmd_max_tries
-640 )
-641 )[2:-1].split('\\n')
-642 # Use -v to get EDID string but this means output cannot be decoded.
-643 # Or maybe it can. I don't know the encoding though, so let's assume it cannot be decoded.
-644 # Use str()[2:-1] workaround
-645
-646 # include "Invalid display" sections because they tell us where one displays metadata ends
-647 # and another begins. We filter out invalid displays later on
-648 ddcutil_output = [i for i in raw_ddcutil_output if i.startswith(
-649 ('Invalid display', 'Display', '\t', ' '))]
-650 tmp_display = {}
-651 display_count = 0
-652
-653 for line_index, line in enumerate(ddcutil_output):
-654 if not line.startswith(('\t', ' ')):
-655 if tmp_display:
-656 yield tmp_display
-657
-658 tmp_display = {
-659 'method': cls,
-660 'index': display_count,
-661 'model': None,
-662 'serial': None,
-663 'bin_serial': None,
-664 'manufacturer': None,
-665 'manufacturer_id': None,
-666 'edid': None,
-667 'unsupported': 'invalid display' in line.lower()
-668 }
-669 display_count += 1
-670
-671 elif 'I2C bus' in line:
-672 tmp_display['i2c_bus'] = line[line.index('/'):]
-673 tmp_display['bus_number'] = int(
-674 tmp_display['i2c_bus'].replace('/dev/i2c-', ''))
-675
-676 elif 'Mfg id' in line:
-677 # Recently ddcutil has started reporting manufacturer IDs like
-678 # 'BNQ - UNK' or 'MSI - Microstep' so we have to split the line
-679 # into chunks of alpha chars and check for a valid mfg id
-680 for code in re.split(r'[^A-Za-z]', line.replace('Mfg id:', '').replace(' ', '')):
-681 if len(code) != 3:
-682 # all mfg ids are 3 chars long
-683 continue
+565 if tmp_display:
+566 yield tmp_display
+567
+568 @classmethod
+569 def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+570 '''
+571 Implements `BrightnessMethod.get_display_info`.
+572
+573 Args:
+574 display: the index of the specific display to query.
+575 If unspecified, all detected displays are queried
+576 brightness: whether to include the current brightness
+577 in the returned info
+578 '''
+579 valid_displays = []
+580 for item in cls._gdi():
+581 if item['unsupported']:
+582 continue
+583 if not brightness:
+584 del item['brightness']
+585 del item['unsupported']
+586 valid_displays.append(item)
+587 if display is not None:
+588 valid_displays = filter_monitors(
+589 display=display, haystack=valid_displays, include=['interface'])
+590 return valid_displays
+591
+592 @classmethod
+593 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+594 monitors = cls.get_display_info(brightness=True)
+595 if display is not None:
+596 monitors = [monitors[display]]
+597 brightness = [i['brightness'] for i in monitors]
+598
+599 return brightness
+600
+601 @classmethod
+602 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+603 value_as_str = str(float(value) / 100)
+604 info = cls.get_display_info()
+605 if display is not None:
+606 info = [info[display]]
+607
+608 for i in info:
+609 check_output([cls.executable, '--output',
+610 i['interface'], '--brightness', value_as_str])
+611
+612
+613class DDCUtil(BrightnessMethodAdv):
+614 '''collection of screen brightness related methods using the ddcutil executable'''
+615 _logger = _logger.getChild('DDCUtil')
+616
+617 executable: str = 'ddcutil'
+618 '''The ddcutil executable to be called'''
+619 sleep_multiplier: float = 0.5
+620 '''
+621 How long ddcutil should sleep between each DDC request (lower is shorter).
+622 See [the ddcutil docs](https://www.ddcutil.com/performance_options/#option-sleep-multiplier).
+623 '''
+624 cmd_max_tries: int = 10
+625 '''Max number of retries when calling the ddcutil'''
+626 enable_async = True
+627 '''
+628 Use the `--async` flag when calling ddcutil.
+629 See [ddcutil docs](https://www.ddcutil.com/performance_options/#option-async)
+630 '''
+631 _max_brightness_cache: dict = {}
+632 '''Cache for displays and their maximum brightness values'''
+633
+634 @classmethod
+635 def _gdi(cls):
+636 '''
+637 .. warning:: Don't use this
+638 This function isn't final and I will probably make breaking changes to it.
+639 You have been warned
+640
+641 Gets all displays reported by DDCUtil even if they're not supported
+642 '''
+643 raw_ddcutil_output = str(
+644 check_output(
+645 [
+646 cls.executable, 'detect', '-v',
+647 f'--sleep-multiplier={cls.sleep_multiplier}'
+648 ] + ['--async'] if cls.enable_async else [], max_tries=cls.cmd_max_tries
+649 )
+650 )[2:-1].split('\\n')
+651 # Use -v to get EDID string but this means output cannot be decoded.
+652 # Or maybe it can. I don't know the encoding though, so let's assume it cannot be decoded.
+653 # Use str()[2:-1] workaround
+654
+655 # include "Invalid display" sections because they tell us where one displays metadata ends
+656 # and another begins. We filter out invalid displays later on
+657 ddcutil_output = [i for i in raw_ddcutil_output if i.startswith(
+658 ('Invalid display', 'Display', '\t', ' '))]
+659 tmp_display: dict = {}
+660 display_count = 0
+661
+662 for line_index, line in enumerate(ddcutil_output):
+663 if not line.startswith(('\t', ' ')):
+664 if tmp_display:
+665 yield tmp_display
+666
+667 tmp_display = {
+668 'method': cls,
+669 'index': display_count,
+670 'model': None,
+671 'serial': None,
+672 'bin_serial': None,
+673 'manufacturer': None,
+674 'manufacturer_id': None,
+675 'edid': None,
+676 'unsupported': 'invalid display' in line.lower()
+677 }
+678 display_count += 1
+679
+680 elif 'I2C bus' in line:
+681 tmp_display['i2c_bus'] = line[line.index('/'):]
+682 tmp_display['bus_number'] = int(
+683 tmp_display['i2c_bus'].replace('/dev/i2c-', ''))
684
-685 try:
-686 (
-687 tmp_display['manufacturer_id'],
-688 tmp_display['manufacturer']
-689 ) = _monitor_brand_lookup(code)
-690 except TypeError:
-691 continue
-692 else:
-693 break
-694
-695 elif 'Model' in line:
-696 # the split() removes extra spaces
-697 name = line.replace('Model:', '').split()
-698 try:
-699 tmp_display['model'] = name[1]
-700 except IndexError:
-701 pass
-702 tmp_display['name'] = ' '.join(name)
-703
-704 elif 'Serial number' in line:
-705 tmp_display['serial'] = line.replace(
-706 'Serial number:', '').replace(' ', '') or None
-707
-708 elif 'Binary serial number:' in line:
-709 tmp_display['bin_serial'] = line.split(' ')[-1][3:-1]
+685 elif 'Mfg id' in line:
+686 # Recently ddcutil has started reporting manufacturer IDs like
+687 # 'BNQ - UNK' or 'MSI - Microstep' so we have to split the line
+688 # into chunks of alpha chars and check for a valid mfg id
+689 for code in re.split(r'[^A-Za-z]', line.replace('Mfg id:', '').replace(' ', '')):
+690 if len(code) != 3:
+691 # all mfg ids are 3 chars long
+692 continue
+693
+694 if (brand := _monitor_brand_lookup(code)):
+695 tmp_display['manufacturer_id'], tmp_display['manufacturer'] = brand
+696 break
+697
+698 elif 'Model' in line:
+699 # the split() removes extra spaces
+700 name = line.replace('Model:', '').split()
+701 try:
+702 tmp_display['model'] = name[1]
+703 except IndexError:
+704 pass
+705 tmp_display['name'] = ' '.join(name)
+706
+707 elif 'Serial number' in line:
+708 tmp_display['serial'] = line.replace(
+709 'Serial number:', '').replace(' ', '') or None
710
-711 elif 'EDID hex dump:' in line:
-712 try:
-713 tmp_display['edid'] = ''.join(
-714 ''.join(i.split()[1:17]) for i in ddcutil_output[line_index + 2: line_index + 10]
-715 )
-716 except Exception:
-717 pass
-718
-719 if tmp_display:
-720 yield tmp_display
+711 elif 'Binary serial number:' in line:
+712 tmp_display['bin_serial'] = line.split(' ')[-1][3:-1]
+713
+714 elif 'EDID hex dump:' in line:
+715 try:
+716 tmp_display['edid'] = ''.join(
+717 ''.join(i.split()[1:17]) for i in ddcutil_output[line_index + 2: line_index + 10]
+718 )
+719 except Exception:
+720 pass
721
-722 @classmethod
-723 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-724 valid_displays = __cache__.get('ddcutil_monitors_info')
-725 if valid_displays is None:
-726 valid_displays = []
-727 for item in cls._gdi():
-728 if item['unsupported']:
-729 continue
-730 del item['unsupported']
-731 valid_displays.append(item)
-732
-733 if valid_displays:
-734 __cache__.store('ddcutil_monitors_info', valid_displays)
+722 if tmp_display:
+723 yield tmp_display
+724
+725 @classmethod
+726 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+727 valid_displays = __cache__.get('ddcutil_monitors_info')
+728 if valid_displays is None:
+729 valid_displays = []
+730 for item in cls._gdi():
+731 if item['unsupported']:
+732 continue
+733 del item['unsupported']
+734 valid_displays.append(item)
735
-736 if display is not None:
-737 valid_displays = filter_monitors(
-738 display=display, haystack=valid_displays, include=['i2c_bus'])
-739 return valid_displays
-740
-741 @classmethod
-742 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-743 monitors = cls.get_display_info()
-744 if display is not None:
-745 monitors = [monitors[display]]
-746
-747 res = []
-748 for monitor in monitors:
-749 value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
-750 if value is None:
-751 cmd_out = check_output(
-752 [
-753 cls.executable,
-754 'getvcp', '10', '-t',
-755 '-b', str(monitor['bus_number']),
-756 f'--sleep-multiplier={cls.sleep_multiplier}'
-757 ], max_tries=cls.cmd_max_tries
-758 ).decode().split(' ')
-759
-760 value = int(cmd_out[-2])
-761 max_value = int(cmd_out[-1])
-762 if max_value != 100:
-763 # if the max brightness is not 100 then the number is not a percentage
-764 # and will need to be scaled
-765 value = int((value / max_value) * 100)
-766
-767 # now make sure max brightness is recorded so set_brightness can use it
-768 cache_ident = '%s-%s-%s' % (monitor['name'],
-769 monitor['serial'], monitor['bin_serial'])
-770 if cache_ident not in cls._max_brightness_cache:
-771 cls._max_brightness_cache[cache_ident] = max_value
-772 cls.logger.debug(
-773 f'{cache_ident} max brightness:{max_value} (current: {value})')
-774
-775 __cache__.store(
-776 f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
-777 res.append(value)
-778 return res
-779
-780 @classmethod
-781 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-782 monitors = cls.get_display_info()
-783 if display is not None:
-784 monitors = [monitors[display]]
-785
-786 __cache__.expire(startswith='ddcutil_brightness_')
-787 for monitor in monitors:
-788 # check if monitor has a max brightness that requires us to scale this value
-789 cache_ident = '%s-%s-%s' % (monitor['name'],
-790 monitor['serial'], monitor['bin_serial'])
-791 if cache_ident not in cls._max_brightness_cache:
-792 cls.get_brightness(display=monitor['index'])
-793
-794 if cls._max_brightness_cache[cache_ident] != 100:
-795 value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+736 if valid_displays:
+737 __cache__.store('ddcutil_monitors_info', valid_displays)
+738
+739 if display is not None:
+740 valid_displays = filter_monitors(
+741 display=display, haystack=valid_displays, include=['i2c_bus'])
+742 return valid_displays
+743
+744 @classmethod
+745 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+746 monitors = cls.get_display_info()
+747 if display is not None:
+748 monitors = [monitors[display]]
+749
+750 res = []
+751 for monitor in monitors:
+752 value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+753 if value is None:
+754 cmd_out = check_output(
+755 [
+756 cls.executable,
+757 'getvcp', '10', '-t',
+758 '-b', str(monitor['bus_number']),
+759 f'--sleep-multiplier={cls.sleep_multiplier}'
+760 ], max_tries=cls.cmd_max_tries
+761 ).decode().split(' ')
+762
+763 value = int(cmd_out[-2])
+764 max_value = int(cmd_out[-1])
+765 if max_value != 100:
+766 # if the max brightness is not 100 then the number is not a percentage
+767 # and will need to be scaled
+768 value = int((value / max_value) * 100)
+769
+770 # now make sure max brightness is recorded so set_brightness can use it
+771 cache_ident = '%s-%s-%s' % (monitor['name'],
+772 monitor['serial'], monitor['bin_serial'])
+773 if cache_ident not in cls._max_brightness_cache:
+774 cls._max_brightness_cache[cache_ident] = max_value
+775 cls._logger.debug(
+776 f'{cache_ident} max brightness:{max_value} (current: {value})')
+777
+778 __cache__.store(
+779 f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+780 res.append(value)
+781 return res
+782
+783 @classmethod
+784 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+785 monitors = cls.get_display_info()
+786 if display is not None:
+787 monitors = [monitors[display]]
+788
+789 __cache__.expire(startswith='ddcutil_brightness_')
+790 for monitor in monitors:
+791 # check if monitor has a max brightness that requires us to scale this value
+792 cache_ident = '%s-%s-%s' % (monitor['name'],
+793 monitor['serial'], monitor['bin_serial'])
+794 if cache_ident not in cls._max_brightness_cache:
+795 cls.get_brightness(display=monitor['index'])
796
-797 check_output(
-798 [
-799 cls.executable, 'setvcp', '10', str(value),
-800 '-b', str(monitor['bus_number']),
-801 f'--sleep-multiplier={cls.sleep_multiplier}'
-802 ], max_tries=cls.cmd_max_tries
-803 )
-804
-805
-806def list_monitors_info(
-807 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
-808) -> List[dict]:
-809 '''
-810 Lists detailed information about all detected displays
-811
-812 Args:
-813 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
-814 for more info on available methods
-815 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
-816 unsupported: include detected displays that are invalid or unsupported
-817 '''
-818 all_methods = get_methods(method).values()
-819 haystack = []
-820 for method_class in all_methods:
-821 try:
-822 if unsupported and issubclass(method_class, BrightnessMethodAdv):
-823 haystack += method_class._gdi()
-824 else:
-825 haystack += method_class.get_display_info()
-826 except Exception as e:
-827 logger.warning(
-828 f'error grabbing display info from {method_class} - {format_exc(e)}')
-829 pass
-830
-831 if allow_duplicates:
-832 return haystack
+797 if cls._max_brightness_cache[cache_ident] != 100:
+798 value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+799
+800 check_output(
+801 [
+802 cls.executable, 'setvcp', '10', str(value),
+803 '-b', str(monitor['bus_number']),
+804 f'--sleep-multiplier={cls.sleep_multiplier}'
+805 ], max_tries=cls.cmd_max_tries
+806 )
+807
+808
+809def list_monitors_info(
+810 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+811) -> List[dict]:
+812 '''
+813 Lists detailed information about all detected displays
+814
+815 Args:
+816 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
+817 for more info on available methods
+818 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+819 unsupported: include detected displays that are invalid or unsupported
+820 '''
+821 all_methods = get_methods(method).values()
+822 haystack = []
+823 for method_class in all_methods:
+824 try:
+825 if unsupported and issubclass(method_class, BrightnessMethodAdv):
+826 haystack += method_class._gdi()
+827 else:
+828 haystack += method_class.get_display_info()
+829 except Exception as e:
+830 _logger.warning(
+831 f'error grabbing display info from {method_class} - {format_exc(e)}')
+832 pass
833
-834 try:
-835 # use filter_monitors to remove duplicates
-836 return filter_monitors(haystack=haystack)
-837 except NoValidDisplayError:
-838 return []
+834 if allow_duplicates:
+835 return haystack
+836
+837 try:
+838 # use filter_monitors to remove duplicates
+839 return filter_monitors(haystack=haystack)
+840 except NoValidDisplayError:
+841 return []
31 `/sys/class/backlight/*/brightness` or you will need to run the program
32 as root.
33 '''
- 34 logger = logger.getChild('SysFiles')
+ 34 _logger = _logger.getChild('SysFiles')
35
36 @classmethod
37 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
@@ -1119,12 +1134,12 @@
40 if os.path.isdir(f'/sys/class/backlight/{folder}/subsystem'):
41 subsystems.add(tuple(os.listdir(f'/sys/class/backlight/{folder}/subsystem')))
42
- 43 all_displays = {}
+ 43 displays_by_edid = {}
44 index = 0
45
46 for subsystem in subsystems:
47
- 48 device = {
+ 48 device: dict = {
49 'name': subsystem[0],
50 'path': f'/sys/class/backlight/{subsystem[0]}',
51 'method': cls,
@@ -1150,7 +1165,7 @@
71 device['path'] = f'/sys/class/backlight/{folder}'
72 device['scale'] = scale
73 except (FileNotFoundError, TypeError) as e:
- 74 cls.logger.error(
+ 74 cls._logger.error(
75 f'error getting highest resolution scale for {folder}'
76 f' - {format_exc(e)}'
77 )
@@ -1167,10 +1182,10 @@
88 continue
89 device[key] = value
90
- 91 all_displays[device['edid']] = device
+ 91 displays_by_edid[device['edid']] = device
92 index += 1
93
- 94 all_displays = list(all_displays.values())
+ 94 all_displays = list(displays_by_edid.values())
95 if display is not None:
96 all_displays = filter_monitors(
97 display=display, haystack=all_displays, include=['path'])
@@ -1233,12 +1248,12 @@
40 if os.path.isdir(f'/sys/class/backlight/{folder}/subsystem'):
41 subsystems.add(tuple(os.listdir(f'/sys/class/backlight/{folder}/subsystem')))
42
-43 all_displays = {}
+43 displays_by_edid = {}
44 index = 0
45
46 for subsystem in subsystems:
47
-48 device = {
+48 device: dict = {
49 'name': subsystem[0],
50 'path': f'/sys/class/backlight/{subsystem[0]}',
51 'method': cls,
@@ -1264,7 +1279,7 @@
71 device['path'] = f'/sys/class/backlight/{folder}'
72 device['scale'] = scale
73 except (FileNotFoundError, TypeError) as e:
-74 cls.logger.error(
+74 cls._logger.error(
75 f'error getting highest resolution scale for {folder}'
76 f' - {format_exc(e)}'
77 )
@@ -1281,10 +1296,10 @@
88 continue
89 device[key] = value
90
-91 all_displays[device['edid']] = device
+91 displays_by_edid[device['edid']] = device
92 index += 1
93
-94 all_displays = list(all_displays.values())
+94 all_displays = list(displays_by_edid.values())
95 if display is not None:
96 all_displays = filter_monitors(
97 display=display, haystack=all_displays, include=['path'])
@@ -1297,8 +1312,8 @@
Arguments:
Returns:
@@ -1360,7 +1375,7 @@ Returns:
Returns:
- A list of types.IntPercentage values, one for each
+
A list of screen_brightness_control.types.IntPercentage values, one for each
queried display
Returns:
Arguments:
@@ -1433,7 +1448,7 @@
Returns:
141 * [ddcci.py](https://github.com/siemer/ddcci)
142 * [DDCCI Spec](https://milek7.pl/ddcbacklight/ddcci.pdf)
143 '''
-144 logger = logger.getChild('I2C')
+144 _logger = _logger.getChild('I2C')
145
146 # vcp commands
147 GET_VCP_CMD = 0x01
@@ -1514,7 +1529,7 @@ Returns:
222 Args:
223 i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
224 '''
-225 self.logger = logger.getChild(
+225 self.logger = _logger.getChild(
226 self.__class__.__name__).getChild(i2c_path)
227 super().__init__(i2c_path, I2C.DDCCI_ADDR)
228
@@ -1632,7 +1647,7 @@ Returns:
340 # read some 512 bytes from the device
341 data = device.read(512)
342 except IOError as e:
-343 cls.logger.error(
+343 cls._logger.error(
344 f'IOError reading from device {i2c_path}: {e}')
345 continue
346
@@ -1644,81 +1659,85 @@ Returns:
352 # grab 128 bytes of the edid
353 edid = data[start: start + 128]
354 # parse the EDID
-355 manufacturer_id, manufacturer, model, name, serial = EDID.parse(
-356 edid)
-357 # convert edid to hex string
-358 edid = ''.join(f'{i:02x}' for i in edid)
-359
-360 all_displays.append(
-361 {
-362 'name': name,
-363 'model': model,
-364 'manufacturer': manufacturer,
-365 'manufacturer_id': manufacturer_id,
-366 'serial': serial,
-367 'method': cls,
-368 'index': index,
-369 'edid': edid,
-370 'i2c_bus': i2c_path
-371 }
-372 )
-373 index += 1
-374
-375 if all_displays:
-376 __cache__.store('i2c_display_info', all_displays, expires=2)
-377
-378 if display is not None:
-379 return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
-380 return all_displays
+355 (
+356 manufacturer_id,
+357 manufacturer,
+358 model,
+359 name,
+360 serial
+361 ) = EDID.parse(edid)
+362
+363 all_displays.append(
+364 {
+365 'name': name,
+366 'model': model,
+367 'manufacturer': manufacturer,
+368 'manufacturer_id': manufacturer_id,
+369 'serial': serial,
+370 'method': cls,
+371 'index': index,
+372 # convert edid to hex string
+373 'edid': ''.join(f'{i:02x}' for i in edid),
+374 'i2c_bus': i2c_path
+375 }
+376 )
+377 index += 1
+378
+379 if all_displays:
+380 __cache__.store('i2c_display_info', all_displays, expires=2)
381
-382 @classmethod
-383 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-384 all_displays = cls.get_display_info()
-385 if display is not None:
-386 all_displays = [all_displays[display]]
-387
-388 results = []
-389 for device in all_displays:
-390 interface = cls.DDCInterface(device['i2c_bus'])
-391 value, max_value = interface.getvcp(0x10)
-392
-393 # make sure display's max brighness is cached
-394 cache_ident = '%s-%s-%s' % (device['name'],
-395 device['model'], device['serial'])
-396 if cache_ident not in cls._max_brightness_cache:
-397 cls._max_brightness_cache[cache_ident] = max_value
-398 cls.logger.info(
-399 f'{cache_ident} max brightness:{max_value} (current: {value})')
-400
-401 if max_value != 100:
-402 # if max value is not 100 then we have to adjust the scale to be
-403 # a percentage
-404 value = int((value / max_value) * 100)
-405
-406 results.append(value)
-407
-408 return results
+382 if display is not None:
+383 return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+384 return all_displays
+385
+386 @classmethod
+387 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+388 all_displays = cls.get_display_info()
+389 if display is not None:
+390 all_displays = [all_displays[display]]
+391
+392 results = []
+393 for device in all_displays:
+394 interface = cls.DDCInterface(device['i2c_bus'])
+395 value, max_value = interface.getvcp(0x10)
+396
+397 # make sure display's max brighness is cached
+398 cache_ident = '%s-%s-%s' % (device['name'],
+399 device['model'], device['serial'])
+400 if cache_ident not in cls._max_brightness_cache:
+401 cls._max_brightness_cache[cache_ident] = max_value
+402 cls._logger.info(
+403 f'{cache_ident} max brightness:{max_value} (current: {value})')
+404
+405 if max_value != 100:
+406 # if max value is not 100 then we have to adjust the scale to be
+407 # a percentage
+408 value = int((value / max_value) * 100)
409
-410 @classmethod
-411 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-412 all_displays = cls.get_display_info()
-413 if display is not None:
-414 all_displays = [all_displays[display]]
-415
-416 for device in all_displays:
-417 # make sure display brightness max value is cached
-418 cache_ident = '%s-%s-%s' % (device['name'],
-419 device['model'], device['serial'])
-420 if cache_ident not in cls._max_brightness_cache:
-421 cls.get_brightness(display=device['index'])
-422
-423 # scale the brightness value according to the max brightness
-424 max_value = cls._max_brightness_cache[cache_ident]
-425 if max_value != 100:
-426 value = int((value / 100) * max_value)
-427
-428 interface = cls.DDCInterface(device['i2c_bus'])
-429 interface.setvcp(0x10, value)
+410 results.append(value)
+411
+412 return results
+413
+414 @classmethod
+415 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+416 all_displays = cls.get_display_info()
+417 if display is not None:
+418 all_displays = [all_displays[display]]
+419
+420 for device in all_displays:
+421 # make sure display brightness max value is cached
+422 cache_ident = '%s-%s-%s' % (device['name'],
+423 device['model'], device['serial'])
+424 if cache_ident not in cls._max_brightness_cache:
+425 cls.get_brightness(display=device['index'])
+426
+427 # scale the brightness value according to the max brightness
+428 max_value = cls._max_brightness_cache[cache_ident]
+429 if max_value != 100:
+430 value = int((value / 100) * max_value)
+431
+432 interface = cls.DDCInterface(device['i2c_bus'])
+433 interface.setvcp(0x10, value)
References:
340 # read some 512 bytes from the device
341 data = device.read(512)
342 except IOError as e:
-343 cls.logger.error(
+343 cls._logger.error(
344 f'IOError reading from device {i2c_path}: {e}')
345 continue
346
@@ -1913,32 +1932,36 @@ References:
352 # grab 128 bytes of the edid
353 edid = data[start: start + 128]
354 # parse the EDID
-355 manufacturer_id, manufacturer, model, name, serial = EDID.parse(
-356 edid)
-357 # convert edid to hex string
-358 edid = ''.join(f'{i:02x}' for i in edid)
-359
-360 all_displays.append(
-361 {
-362 'name': name,
-363 'model': model,
-364 'manufacturer': manufacturer,
-365 'manufacturer_id': manufacturer_id,
-366 'serial': serial,
-367 'method': cls,
-368 'index': index,
-369 'edid': edid,
-370 'i2c_bus': i2c_path
-371 }
-372 )
-373 index += 1
-374
-375 if all_displays:
-376 __cache__.store('i2c_display_info', all_displays, expires=2)
-377
-378 if display is not None:
-379 return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
-380 return all_displays
+355 (
+356 manufacturer_id,
+357 manufacturer,
+358 model,
+359 name,
+360 serial
+361 ) = EDID.parse(edid)
+362
+363 all_displays.append(
+364 {
+365 'name': name,
+366 'model': model,
+367 'manufacturer': manufacturer,
+368 'manufacturer_id': manufacturer_id,
+369 'serial': serial,
+370 'method': cls,
+371 'index': index,
+372 # convert edid to hex string
+373 'edid': ''.join(f'{i:02x}' for i in edid),
+374 'i2c_bus': i2c_path
+375 }
+376 )
+377 index += 1
+378
+379 if all_displays:
+380 __cache__.store('i2c_display_info', all_displays, expires=2)
+381
+382 if display is not None:
+383 return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+384 return all_displays
@@ -1947,8 +1970,8 @@
References:
Arguments:
Returns:
@@ -1984,33 +2007,33 @@
Returns:
-
382 @classmethod
-383 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-384 all_displays = cls.get_display_info()
-385 if display is not None:
-386 all_displays = [all_displays[display]]
-387
-388 results = []
-389 for device in all_displays:
-390 interface = cls.DDCInterface(device['i2c_bus'])
-391 value, max_value = interface.getvcp(0x10)
-392
-393 # make sure display's max brighness is cached
-394 cache_ident = '%s-%s-%s' % (device['name'],
-395 device['model'], device['serial'])
-396 if cache_ident not in cls._max_brightness_cache:
-397 cls._max_brightness_cache[cache_ident] = max_value
-398 cls.logger.info(
-399 f'{cache_ident} max brightness:{max_value} (current: {value})')
-400
-401 if max_value != 100:
-402 # if max value is not 100 then we have to adjust the scale to be
-403 # a percentage
-404 value = int((value / max_value) * 100)
-405
-406 results.append(value)
-407
-408 return results
+ 386 @classmethod
+387 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+388 all_displays = cls.get_display_info()
+389 if display is not None:
+390 all_displays = [all_displays[display]]
+391
+392 results = []
+393 for device in all_displays:
+394 interface = cls.DDCInterface(device['i2c_bus'])
+395 value, max_value = interface.getvcp(0x10)
+396
+397 # make sure display's max brighness is cached
+398 cache_ident = '%s-%s-%s' % (device['name'],
+399 device['model'], device['serial'])
+400 if cache_ident not in cls._max_brightness_cache:
+401 cls._max_brightness_cache[cache_ident] = max_value
+402 cls._logger.info(
+403 f'{cache_ident} max brightness:{max_value} (current: {value})')
+404
+405 if max_value != 100:
+406 # if max value is not 100 then we have to adjust the scale to be
+407 # a percentage
+408 value = int((value / max_value) * 100)
+409
+410 results.append(value)
+411
+412 return results
Returns:
Returns:
- A list of types.IntPercentage values, one for each
+
A list of screen_brightness_control.types.IntPercentage values, one for each
queried display
@@ -2043,33 +2066,33 @@
Returns:
- 410 @classmethod
-411 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-412 all_displays = cls.get_display_info()
-413 if display is not None:
-414 all_displays = [all_displays[display]]
-415
-416 for device in all_displays:
-417 # make sure display brightness max value is cached
-418 cache_ident = '%s-%s-%s' % (device['name'],
-419 device['model'], device['serial'])
-420 if cache_ident not in cls._max_brightness_cache:
-421 cls.get_brightness(display=device['index'])
-422
-423 # scale the brightness value according to the max brightness
-424 max_value = cls._max_brightness_cache[cache_ident]
-425 if max_value != 100:
-426 value = int((value / 100) * max_value)
-427
-428 interface = cls.DDCInterface(device['i2c_bus'])
-429 interface.setvcp(0x10, value)
+ 414 @classmethod
+415 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+416 all_displays = cls.get_display_info()
+417 if display is not None:
+418 all_displays = [all_displays[display]]
+419
+420 for device in all_displays:
+421 # make sure display brightness max value is cached
+422 cache_ident = '%s-%s-%s' % (device['name'],
+423 device['model'], device['serial'])
+424 if cache_ident not in cls._max_brightness_cache:
+425 cls.get_brightness(display=device['index'])
+426
+427 # scale the brightness value according to the max brightness
+428 max_value = cls._max_brightness_cache[cache_ident]
+429 if max_value != 100:
+430 value = int((value / 100) * max_value)
+431
+432 interface = cls.DDCInterface(device['i2c_bus'])
+433 interface.setvcp(0x10, value)
Arguments:
@@ -2167,6 +2190,17 @@
Returns:
Returns:
+
+
+
+ PROTOCOL_FLAG =
+128
+
+
+
+
+
+
+
+
@@ -2647,6 +2704,15 @@
Raises:
+
+
Inherited Members
+
+
+
+
432class Light(BrightnessMethod):
-433 '''
-434 Wraps around [light](https://github.com/haikarainen/light), an external
-435 3rd party tool that can control brightness levels for e-DP displays.
-436
-437 .. warning::
-438 As of April 2nd 2023, the official repository for the light project has
-439 [been archived](https://github.com/haikarainen/light/issues/147) and
-440 will no longer receive any updates unless another maintainer picks it
-441 up.
-442 '''
-443
-444 executable: str = 'light'
-445 '''the light executable to be called'''
-446
-447 @classmethod
-448 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-449 '''
-450 Implements `BrightnessMethod.get_display_info`.
-451
-452 Works by taking the output of `SysFiles.get_display_info` and
-453 filtering out any displays that aren't supported by Light
-454 '''
-455 light_output = check_output([cls.executable, '-L']).decode()
-456 displays = []
-457 index = 0
-458 for device in SysFiles.get_display_info():
-459 # SysFiles scrapes info from the same place that Light used to
-460 # so it makes sense to use that output
-461 if device['path'].replace('/sys/class', 'sysfs') in light_output:
-462 del device['scale']
-463 device['light_path'] = device['path'].replace(
-464 '/sys/class', 'sysfs')
-465 device['method'] = cls
-466 device['index'] = index
-467
-468 displays.append(device)
-469 index += 1
-470
-471 if display is not None:
-472 displays = filter_monitors(display=display, haystack=displays, include=[
-473 'path', 'light_path'])
-474 return displays
-475
-476 @classmethod
-477 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-478 info = cls.get_display_info()
-479 if display is not None:
-480 info = [info[display]]
-481
-482 for i in info:
-483 check_output(
-484 f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
+ 436class Light(BrightnessMethod):
+437 '''
+438 Wraps around [light](https://github.com/haikarainen/light), an external
+439 3rd party tool that can control brightness levels for e-DP displays.
+440
+441 .. warning::
+442 As of April 2nd 2023, the official repository for the light project has
+443 [been archived](https://github.com/haikarainen/light/issues/147) and
+444 will no longer receive any updates unless another maintainer picks it
+445 up.
+446 '''
+447
+448 executable: str = 'light'
+449 '''the light executable to be called'''
+450
+451 @classmethod
+452 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+453 '''
+454 Implements `BrightnessMethod.get_display_info`.
+455
+456 Works by taking the output of `SysFiles.get_display_info` and
+457 filtering out any displays that aren't supported by Light
+458 '''
+459 light_output = check_output([cls.executable, '-L']).decode()
+460 displays = []
+461 index = 0
+462 for device in SysFiles.get_display_info():
+463 # SysFiles scrapes info from the same place that Light used to
+464 # so it makes sense to use that output
+465 if device['path'].replace('/sys/class', 'sysfs') in light_output:
+466 del device['scale']
+467 device['light_path'] = device['path'].replace(
+468 '/sys/class', 'sysfs')
+469 device['method'] = cls
+470 device['index'] = index
+471
+472 displays.append(device)
+473 index += 1
+474
+475 if display is not None:
+476 displays = filter_monitors(display=display, haystack=displays, include=[
+477 'path', 'light_path'])
+478 return displays
+479
+480 @classmethod
+481 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+482 info = cls.get_display_info()
+483 if display is not None:
+484 info = [info[display]]
485
-486 @classmethod
-487 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-488 info = cls.get_display_info()
-489 if display is not None:
-490 info = [info[display]]
-491
-492 results = []
-493 for i in info:
-494 results.append(
-495 check_output([cls.executable, '-G', '-s', i['light_path']])
-496 )
-497 results = [int(round(float(i.decode()), 0)) for i in results]
-498 return results
+486 for i in info:
+487 check_output(
+488 f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
+489
+490 @classmethod
+491 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+492 info = cls.get_display_info()
+493 if display is not None:
+494 info = [info[display]]
+495
+496 results = []
+497 for i in info:
+498 results.append(
+499 check_output([cls.executable, '-G', '-s', i['light_path']])
+500 )
+501 return [int(round(float(i.decode()), 0)) for i in results]
Raises:
447 @classmethod
-448 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-449 '''
-450 Implements `BrightnessMethod.get_display_info`.
-451
-452 Works by taking the output of `SysFiles.get_display_info` and
-453 filtering out any displays that aren't supported by Light
-454 '''
-455 light_output = check_output([cls.executable, '-L']).decode()
-456 displays = []
-457 index = 0
-458 for device in SysFiles.get_display_info():
-459 # SysFiles scrapes info from the same place that Light used to
-460 # so it makes sense to use that output
-461 if device['path'].replace('/sys/class', 'sysfs') in light_output:
-462 del device['scale']
-463 device['light_path'] = device['path'].replace(
-464 '/sys/class', 'sysfs')
-465 device['method'] = cls
-466 device['index'] = index
-467
-468 displays.append(device)
-469 index += 1
-470
-471 if display is not None:
-472 displays = filter_monitors(display=display, haystack=displays, include=[
-473 'path', 'light_path'])
-474 return displays
+ 451 @classmethod
+452 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+453 '''
+454 Implements `BrightnessMethod.get_display_info`.
+455
+456 Works by taking the output of `SysFiles.get_display_info` and
+457 filtering out any displays that aren't supported by Light
+458 '''
+459 light_output = check_output([cls.executable, '-L']).decode()
+460 displays = []
+461 index = 0
+462 for device in SysFiles.get_display_info():
+463 # SysFiles scrapes info from the same place that Light used to
+464 # so it makes sense to use that output
+465 if device['path'].replace('/sys/class', 'sysfs') in light_output:
+466 del device['scale']
+467 device['light_path'] = device['path'].replace(
+468 '/sys/class', 'sysfs')
+469 device['method'] = cls
+470 device['index'] = index
+471
+472 displays.append(device)
+473 index += 1
+474
+475 if display is not None:
+476 displays = filter_monitors(display=display, haystack=displays, include=[
+477 'path', 'light_path'])
+478 return displays
Raises:
476 @classmethod
-477 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-478 info = cls.get_display_info()
-479 if display is not None:
-480 info = [info[display]]
-481
-482 for i in info:
-483 check_output(
-484 f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
+ 480 @classmethod
+481 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+482 info = cls.get_display_info()
+483 if display is not None:
+484 info = [info[display]]
+485
+486 for i in info:
+487 check_output(
+488 f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
Arguments:
@@ -2855,19 +2920,18 @@
Raises:
486 @classmethod
-487 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-488 info = cls.get_display_info()
-489 if display is not None:
-490 info = [info[display]]
-491
-492 results = []
-493 for i in info:
-494 results.append(
-495 check_output([cls.executable, '-G', '-s', i['light_path']])
-496 )
-497 results = [int(round(float(i.decode()), 0)) for i in results]
-498 return results
+ 490 @classmethod
+491 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+492 info = cls.get_display_info()
+493 if display is not None:
+494 info = [info[display]]
+495
+496 results = []
+497 for i in info:
+498 results.append(
+499 check_output([cls.executable, '-G', '-s', i['light_path']])
+500 )
+501 return [int(round(float(i.decode()), 0)) for i in results]
Raises:
Returns:
- A list of types.IntPercentage values, one for each
+
A list of screen_brightness_control.types.IntPercentage values, one for each
queried display
Returns:
501class XRandr(BrightnessMethodAdv):
-502 '''collection of screen brightness related methods using the xrandr executable'''
-503
-504 executable: str = 'xrandr'
-505 '''the xrandr executable to be called'''
+ 504class XRandr(BrightnessMethodAdv):
+505 '''collection of screen brightness related methods using the xrandr executable'''
506
-507 @classmethod
-508 def _gdi(cls):
-509 '''
-510 .. warning:: Don't use this
-511 This function isn't final and I will probably make breaking changes to it.
-512 You have been warned
-513
-514 Gets all displays reported by XRandr even if they're not supported
-515 '''
-516 xrandr_output = check_output(
-517 [cls.executable, '--verbose']).decode().split('\n')
-518
-519 display_count = 0
-520 tmp_display = {}
+507 executable: str = 'xrandr'
+508 '''the xrandr executable to be called'''
+509
+510 @classmethod
+511 def _gdi(cls):
+512 '''
+513 .. warning:: Don't use this
+514 This function isn't final and I will probably make breaking changes to it.
+515 You have been warned
+516
+517 Gets all displays reported by XRandr even if they're not supported
+518 '''
+519 xrandr_output = check_output(
+520 [cls.executable, '--verbose']).decode().split('\n')
521
-522 for line_index, line in enumerate(xrandr_output):
-523 if line == '':
-524 continue
-525
-526 if not line.startswith((' ', '\t')) and 'connected' in line and 'disconnected' not in line:
-527 if tmp_display:
-528 yield tmp_display
-529
-530 tmp_display = {
-531 'name': line.split(' ')[0],
-532 'interface': line.split(' ')[0],
-533 'method': cls,
-534 'index': display_count,
-535 'model': None,
-536 'serial': None,
-537 'manufacturer': None,
-538 'manufacturer_id': None,
-539 'edid': None,
-540 'unsupported': line.startswith('XWAYLAND')
-541 }
-542 display_count += 1
-543
-544 elif 'EDID:' in line:
-545 # extract the edid from the chunk of the output that will contain the edid
-546 edid = ''.join(
-547 i.replace('\t', '') for i in xrandr_output[line_index + 1: line_index + 9]
-548 )
-549 tmp_display['edid'] = edid
-550
-551 for key, value in zip(
-552 ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
-553 EDID.parse(tmp_display['edid'])
-554 ):
-555 if value is None:
-556 continue
-557 tmp_display[key] = value
-558
-559 elif 'Brightness:' in line:
-560 tmp_display['brightness'] = int(
-561 float(line.replace('Brightness:', '')) * 100)
-562
-563 if tmp_display:
-564 yield tmp_display
+522 display_count = 0
+523 tmp_display: dict = {}
+524
+525 for line_index, line in enumerate(xrandr_output):
+526 if line == '':
+527 continue
+528
+529 if not line.startswith((' ', '\t')) and 'connected' in line and 'disconnected' not in line:
+530 if tmp_display:
+531 yield tmp_display
+532
+533 tmp_display = {
+534 'name': line.split(' ')[0],
+535 'interface': line.split(' ')[0],
+536 'method': cls,
+537 'index': display_count,
+538 'model': None,
+539 'serial': None,
+540 'manufacturer': None,
+541 'manufacturer_id': None,
+542 'edid': None,
+543 'unsupported': line.startswith('XWAYLAND')
+544 }
+545 display_count += 1
+546
+547 elif 'EDID:' in line:
+548 # extract the edid from the chunk of the output that will contain the edid
+549 edid = ''.join(
+550 i.replace('\t', '') for i in xrandr_output[line_index + 1: line_index + 9]
+551 )
+552 tmp_display['edid'] = edid
+553
+554 for key, value in zip(
+555 ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+556 EDID.parse(tmp_display['edid'])
+557 ):
+558 if value is None:
+559 continue
+560 tmp_display[key] = value
+561
+562 elif 'Brightness:' in line:
+563 tmp_display['brightness'] = int(
+564 float(line.replace('Brightness:', '')) * 100)
565
-566 @classmethod
-567 def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
-568 '''
-569 Implements `BrightnessMethod.get_display_info`.
-570
-571 Args:
-572 display: the index of the specific display to query.
-573 If unspecified, all detected displays are queried
-574 brightness: whether to include the current brightness
-575 in the returned info
-576 '''
-577 valid_displays = []
-578 for item in cls._gdi():
-579 if item['unsupported']:
-580 continue
-581 if not brightness:
-582 del item['brightness']
-583 del item['unsupported']
-584 valid_displays.append(item)
-585 if display is not None:
-586 valid_displays = filter_monitors(
-587 display=display, haystack=valid_displays, include=['interface'])
-588 return valid_displays
-589
-590 @classmethod
-591 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-592 monitors = cls.get_display_info(brightness=True)
-593 if display is not None:
-594 monitors = [monitors[display]]
-595 brightness = [i['brightness'] for i in monitors]
-596
-597 return brightness
-598
-599 @classmethod
-600 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-601 value = str(float(value) / 100)
-602 info = cls.get_display_info()
-603 if display is not None:
-604 info = [info[display]]
-605
-606 for i in info:
-607 check_output([cls.executable, '--output',
-608 i['interface'], '--brightness', value])
+566 if tmp_display:
+567 yield tmp_display
+568
+569 @classmethod
+570 def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+571 '''
+572 Implements `BrightnessMethod.get_display_info`.
+573
+574 Args:
+575 display: the index of the specific display to query.
+576 If unspecified, all detected displays are queried
+577 brightness: whether to include the current brightness
+578 in the returned info
+579 '''
+580 valid_displays = []
+581 for item in cls._gdi():
+582 if item['unsupported']:
+583 continue
+584 if not brightness:
+585 del item['brightness']
+586 del item['unsupported']
+587 valid_displays.append(item)
+588 if display is not None:
+589 valid_displays = filter_monitors(
+590 display=display, haystack=valid_displays, include=['interface'])
+591 return valid_displays
+592
+593 @classmethod
+594 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+595 monitors = cls.get_display_info(brightness=True)
+596 if display is not None:
+597 monitors = [monitors[display]]
+598 brightness = [i['brightness'] for i in monitors]
+599
+600 return brightness
+601
+602 @classmethod
+603 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+604 value_as_str = str(float(value) / 100)
+605 info = cls.get_display_info()
+606 if display is not None:
+607 info = [info[display]]
+608
+609 for i in info:
+610 check_output([cls.executable, '--output',
+611 i['interface'], '--brightness', value_as_str])
Returns:
566 @classmethod
-567 def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
-568 '''
-569 Implements `BrightnessMethod.get_display_info`.
-570
-571 Args:
-572 display: the index of the specific display to query.
-573 If unspecified, all detected displays are queried
-574 brightness: whether to include the current brightness
-575 in the returned info
-576 '''
-577 valid_displays = []
-578 for item in cls._gdi():
-579 if item['unsupported']:
-580 continue
-581 if not brightness:
-582 del item['brightness']
-583 del item['unsupported']
-584 valid_displays.append(item)
-585 if display is not None:
-586 valid_displays = filter_monitors(
-587 display=display, haystack=valid_displays, include=['interface'])
-588 return valid_displays
+ 569 @classmethod
+570 def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+571 '''
+572 Implements `BrightnessMethod.get_display_info`.
+573
+574 Args:
+575 display: the index of the specific display to query.
+576 If unspecified, all detected displays are queried
+577 brightness: whether to include the current brightness
+578 in the returned info
+579 '''
+580 valid_displays = []
+581 for item in cls._gdi():
+582 if item['unsupported']:
+583 continue
+584 if not brightness:
+585 del item['brightness']
+586 del item['unsupported']
+587 valid_displays.append(item)
+588 if display is not None:
+589 valid_displays = filter_monitors(
+590 display=display, haystack=valid_displays, include=['interface'])
+591 return valid_displays
Arguments:
590 @classmethod
-591 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-592 monitors = cls.get_display_info(brightness=True)
-593 if display is not None:
-594 monitors = [monitors[display]]
-595 brightness = [i['brightness'] for i in monitors]
-596
-597 return brightness
+ 593 @classmethod
+594 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+595 monitors = cls.get_display_info(brightness=True)
+596 if display is not None:
+597 monitors = [monitors[display]]
+598 brightness = [i['brightness'] for i in monitors]
+599
+600 return brightness
Arguments:
Returns:
- A list of types.IntPercentage values, one for each
+
A list of screen_brightness_control.types.IntPercentage values, one for each
queried display
Returns:
599 @classmethod
-600 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-601 value = str(float(value) / 100)
-602 info = cls.get_display_info()
-603 if display is not None:
-604 info = [info[display]]
-605
-606 for i in info:
-607 check_output([cls.executable, '--output',
-608 i['interface'], '--brightness', value])
+ 602 @classmethod
+603 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+604 value_as_str = str(float(value) / 100)
+605 info = cls.get_display_info()
+606 if display is not None:
+607 info = [info[display]]
+608
+609 for i in info:
+610 check_output([cls.executable, '--output',
+611 i['interface'], '--brightness', value_as_str])
Arguments:
@@ -3169,200 +3233,200 @@
Returns:
611class DDCUtil(BrightnessMethodAdv):
-612 '''collection of screen brightness related methods using the ddcutil executable'''
-613 logger = logger.getChild('DDCUtil')
-614
-615 executable: str = 'ddcutil'
-616 '''the ddcutil executable to be called'''
-617 sleep_multiplier: float = 0.5
-618 '''how long ddcutil should sleep between each DDC request (lower is shorter).
-619 See [the ddcutil docs](https://www.ddcutil.com/performance_options/) for more info.'''
-620 cmd_max_tries: int = 10
-621 '''max number of retries when calling the ddcutil'''
-622 enable_async = True
-623 _max_brightness_cache: dict = {}
-624 '''Cache for displays and their maximum brightness values'''
-625
-626 @classmethod
-627 def _gdi(cls):
-628 '''
-629 .. warning:: Don't use this
-630 This function isn't final and I will probably make breaking changes to it.
-631 You have been warned
-632
-633 Gets all displays reported by DDCUtil even if they're not supported
-634 '''
-635 raw_ddcutil_output = str(
-636 check_output(
-637 [
-638 cls.executable, 'detect', '-v',
-639 f'--sleep-multiplier={cls.sleep_multiplier}'
-640 ] + ['--async'] if cls.enable_async else [], max_tries=cls.cmd_max_tries
-641 )
-642 )[2:-1].split('\\n')
-643 # Use -v to get EDID string but this means output cannot be decoded.
-644 # Or maybe it can. I don't know the encoding though, so let's assume it cannot be decoded.
-645 # Use str()[2:-1] workaround
-646
-647 # include "Invalid display" sections because they tell us where one displays metadata ends
-648 # and another begins. We filter out invalid displays later on
-649 ddcutil_output = [i for i in raw_ddcutil_output if i.startswith(
-650 ('Invalid display', 'Display', '\t', ' '))]
-651 tmp_display = {}
-652 display_count = 0
-653
-654 for line_index, line in enumerate(ddcutil_output):
-655 if not line.startswith(('\t', ' ')):
-656 if tmp_display:
-657 yield tmp_display
-658
-659 tmp_display = {
-660 'method': cls,
-661 'index': display_count,
-662 'model': None,
-663 'serial': None,
-664 'bin_serial': None,
-665 'manufacturer': None,
-666 'manufacturer_id': None,
-667 'edid': None,
-668 'unsupported': 'invalid display' in line.lower()
-669 }
-670 display_count += 1
-671
-672 elif 'I2C bus' in line:
-673 tmp_display['i2c_bus'] = line[line.index('/'):]
-674 tmp_display['bus_number'] = int(
-675 tmp_display['i2c_bus'].replace('/dev/i2c-', ''))
-676
-677 elif 'Mfg id' in line:
-678 # Recently ddcutil has started reporting manufacturer IDs like
-679 # 'BNQ - UNK' or 'MSI - Microstep' so we have to split the line
-680 # into chunks of alpha chars and check for a valid mfg id
-681 for code in re.split(r'[^A-Za-z]', line.replace('Mfg id:', '').replace(' ', '')):
-682 if len(code) != 3:
-683 # all mfg ids are 3 chars long
-684 continue
+ 614class DDCUtil(BrightnessMethodAdv):
+615 '''collection of screen brightness related methods using the ddcutil executable'''
+616 _logger = _logger.getChild('DDCUtil')
+617
+618 executable: str = 'ddcutil'
+619 '''The ddcutil executable to be called'''
+620 sleep_multiplier: float = 0.5
+621 '''
+622 How long ddcutil should sleep between each DDC request (lower is shorter).
+623 See [the ddcutil docs](https://www.ddcutil.com/performance_options/#option-sleep-multiplier).
+624 '''
+625 cmd_max_tries: int = 10
+626 '''Max number of retries when calling the ddcutil'''
+627 enable_async = True
+628 '''
+629 Use the `--async` flag when calling ddcutil.
+630 See [ddcutil docs](https://www.ddcutil.com/performance_options/#option-async)
+631 '''
+632 _max_brightness_cache: dict = {}
+633 '''Cache for displays and their maximum brightness values'''
+634
+635 @classmethod
+636 def _gdi(cls):
+637 '''
+638 .. warning:: Don't use this
+639 This function isn't final and I will probably make breaking changes to it.
+640 You have been warned
+641
+642 Gets all displays reported by DDCUtil even if they're not supported
+643 '''
+644 raw_ddcutil_output = str(
+645 check_output(
+646 [
+647 cls.executable, 'detect', '-v',
+648 f'--sleep-multiplier={cls.sleep_multiplier}'
+649 ] + ['--async'] if cls.enable_async else [], max_tries=cls.cmd_max_tries
+650 )
+651 )[2:-1].split('\\n')
+652 # Use -v to get EDID string but this means output cannot be decoded.
+653 # Or maybe it can. I don't know the encoding though, so let's assume it cannot be decoded.
+654 # Use str()[2:-1] workaround
+655
+656 # include "Invalid display" sections because they tell us where one displays metadata ends
+657 # and another begins. We filter out invalid displays later on
+658 ddcutil_output = [i for i in raw_ddcutil_output if i.startswith(
+659 ('Invalid display', 'Display', '\t', ' '))]
+660 tmp_display: dict = {}
+661 display_count = 0
+662
+663 for line_index, line in enumerate(ddcutil_output):
+664 if not line.startswith(('\t', ' ')):
+665 if tmp_display:
+666 yield tmp_display
+667
+668 tmp_display = {
+669 'method': cls,
+670 'index': display_count,
+671 'model': None,
+672 'serial': None,
+673 'bin_serial': None,
+674 'manufacturer': None,
+675 'manufacturer_id': None,
+676 'edid': None,
+677 'unsupported': 'invalid display' in line.lower()
+678 }
+679 display_count += 1
+680
+681 elif 'I2C bus' in line:
+682 tmp_display['i2c_bus'] = line[line.index('/'):]
+683 tmp_display['bus_number'] = int(
+684 tmp_display['i2c_bus'].replace('/dev/i2c-', ''))
685
-686 try:
-687 (
-688 tmp_display['manufacturer_id'],
-689 tmp_display['manufacturer']
-690 ) = _monitor_brand_lookup(code)
-691 except TypeError:
-692 continue
-693 else:
-694 break
-695
-696 elif 'Model' in line:
-697 # the split() removes extra spaces
-698 name = line.replace('Model:', '').split()
-699 try:
-700 tmp_display['model'] = name[1]
-701 except IndexError:
-702 pass
-703 tmp_display['name'] = ' '.join(name)
-704
-705 elif 'Serial number' in line:
-706 tmp_display['serial'] = line.replace(
-707 'Serial number:', '').replace(' ', '') or None
-708
-709 elif 'Binary serial number:' in line:
-710 tmp_display['bin_serial'] = line.split(' ')[-1][3:-1]
+686 elif 'Mfg id' in line:
+687 # Recently ddcutil has started reporting manufacturer IDs like
+688 # 'BNQ - UNK' or 'MSI - Microstep' so we have to split the line
+689 # into chunks of alpha chars and check for a valid mfg id
+690 for code in re.split(r'[^A-Za-z]', line.replace('Mfg id:', '').replace(' ', '')):
+691 if len(code) != 3:
+692 # all mfg ids are 3 chars long
+693 continue
+694
+695 if (brand := _monitor_brand_lookup(code)):
+696 tmp_display['manufacturer_id'], tmp_display['manufacturer'] = brand
+697 break
+698
+699 elif 'Model' in line:
+700 # the split() removes extra spaces
+701 name = line.replace('Model:', '').split()
+702 try:
+703 tmp_display['model'] = name[1]
+704 except IndexError:
+705 pass
+706 tmp_display['name'] = ' '.join(name)
+707
+708 elif 'Serial number' in line:
+709 tmp_display['serial'] = line.replace(
+710 'Serial number:', '').replace(' ', '') or None
711
-712 elif 'EDID hex dump:' in line:
-713 try:
-714 tmp_display['edid'] = ''.join(
-715 ''.join(i.split()[1:17]) for i in ddcutil_output[line_index + 2: line_index + 10]
-716 )
-717 except Exception:
-718 pass
-719
-720 if tmp_display:
-721 yield tmp_display
+712 elif 'Binary serial number:' in line:
+713 tmp_display['bin_serial'] = line.split(' ')[-1][3:-1]
+714
+715 elif 'EDID hex dump:' in line:
+716 try:
+717 tmp_display['edid'] = ''.join(
+718 ''.join(i.split()[1:17]) for i in ddcutil_output[line_index + 2: line_index + 10]
+719 )
+720 except Exception:
+721 pass
722
-723 @classmethod
-724 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-725 valid_displays = __cache__.get('ddcutil_monitors_info')
-726 if valid_displays is None:
-727 valid_displays = []
-728 for item in cls._gdi():
-729 if item['unsupported']:
-730 continue
-731 del item['unsupported']
-732 valid_displays.append(item)
-733
-734 if valid_displays:
-735 __cache__.store('ddcutil_monitors_info', valid_displays)
+723 if tmp_display:
+724 yield tmp_display
+725
+726 @classmethod
+727 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+728 valid_displays = __cache__.get('ddcutil_monitors_info')
+729 if valid_displays is None:
+730 valid_displays = []
+731 for item in cls._gdi():
+732 if item['unsupported']:
+733 continue
+734 del item['unsupported']
+735 valid_displays.append(item)
736
-737 if display is not None:
-738 valid_displays = filter_monitors(
-739 display=display, haystack=valid_displays, include=['i2c_bus'])
-740 return valid_displays
-741
-742 @classmethod
-743 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-744 monitors = cls.get_display_info()
-745 if display is not None:
-746 monitors = [monitors[display]]
-747
-748 res = []
-749 for monitor in monitors:
-750 value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
-751 if value is None:
-752 cmd_out = check_output(
-753 [
-754 cls.executable,
-755 'getvcp', '10', '-t',
-756 '-b', str(monitor['bus_number']),
-757 f'--sleep-multiplier={cls.sleep_multiplier}'
-758 ], max_tries=cls.cmd_max_tries
-759 ).decode().split(' ')
-760
-761 value = int(cmd_out[-2])
-762 max_value = int(cmd_out[-1])
-763 if max_value != 100:
-764 # if the max brightness is not 100 then the number is not a percentage
-765 # and will need to be scaled
-766 value = int((value / max_value) * 100)
-767
-768 # now make sure max brightness is recorded so set_brightness can use it
-769 cache_ident = '%s-%s-%s' % (monitor['name'],
-770 monitor['serial'], monitor['bin_serial'])
-771 if cache_ident not in cls._max_brightness_cache:
-772 cls._max_brightness_cache[cache_ident] = max_value
-773 cls.logger.debug(
-774 f'{cache_ident} max brightness:{max_value} (current: {value})')
-775
-776 __cache__.store(
-777 f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
-778 res.append(value)
-779 return res
-780
-781 @classmethod
-782 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-783 monitors = cls.get_display_info()
-784 if display is not None:
-785 monitors = [monitors[display]]
-786
-787 __cache__.expire(startswith='ddcutil_brightness_')
-788 for monitor in monitors:
-789 # check if monitor has a max brightness that requires us to scale this value
-790 cache_ident = '%s-%s-%s' % (monitor['name'],
-791 monitor['serial'], monitor['bin_serial'])
-792 if cache_ident not in cls._max_brightness_cache:
-793 cls.get_brightness(display=monitor['index'])
-794
-795 if cls._max_brightness_cache[cache_ident] != 100:
-796 value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+737 if valid_displays:
+738 __cache__.store('ddcutil_monitors_info', valid_displays)
+739
+740 if display is not None:
+741 valid_displays = filter_monitors(
+742 display=display, haystack=valid_displays, include=['i2c_bus'])
+743 return valid_displays
+744
+745 @classmethod
+746 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+747 monitors = cls.get_display_info()
+748 if display is not None:
+749 monitors = [monitors[display]]
+750
+751 res = []
+752 for monitor in monitors:
+753 value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+754 if value is None:
+755 cmd_out = check_output(
+756 [
+757 cls.executable,
+758 'getvcp', '10', '-t',
+759 '-b', str(monitor['bus_number']),
+760 f'--sleep-multiplier={cls.sleep_multiplier}'
+761 ], max_tries=cls.cmd_max_tries
+762 ).decode().split(' ')
+763
+764 value = int(cmd_out[-2])
+765 max_value = int(cmd_out[-1])
+766 if max_value != 100:
+767 # if the max brightness is not 100 then the number is not a percentage
+768 # and will need to be scaled
+769 value = int((value / max_value) * 100)
+770
+771 # now make sure max brightness is recorded so set_brightness can use it
+772 cache_ident = '%s-%s-%s' % (monitor['name'],
+773 monitor['serial'], monitor['bin_serial'])
+774 if cache_ident not in cls._max_brightness_cache:
+775 cls._max_brightness_cache[cache_ident] = max_value
+776 cls._logger.debug(
+777 f'{cache_ident} max brightness:{max_value} (current: {value})')
+778
+779 __cache__.store(
+780 f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+781 res.append(value)
+782 return res
+783
+784 @classmethod
+785 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+786 monitors = cls.get_display_info()
+787 if display is not None:
+788 monitors = [monitors[display]]
+789
+790 __cache__.expire(startswith='ddcutil_brightness_')
+791 for monitor in monitors:
+792 # check if monitor has a max brightness that requires us to scale this value
+793 cache_ident = '%s-%s-%s' % (monitor['name'],
+794 monitor['serial'], monitor['bin_serial'])
+795 if cache_ident not in cls._max_brightness_cache:
+796 cls.get_brightness(display=monitor['index'])
797
-798 check_output(
-799 [
-800 cls.executable, 'setvcp', '10', str(value),
-801 '-b', str(monitor['bus_number']),
-802 f'--sleep-multiplier={cls.sleep_multiplier}'
-803 ], max_tries=cls.cmd_max_tries
-804 )
+798 if cls._max_brightness_cache[cache_ident] != 100:
+799 value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+800
+801 check_output(
+802 [
+803 cls.executable, 'setvcp', '10', str(value),
+804 '-b', str(monitor['bus_number']),
+805 f'--sleep-multiplier={cls.sleep_multiplier}'
+806 ], max_tries=cls.cmd_max_tries
+807 )
Returns:
the ddcutil executable to be called
+
The ddcutil executable to be called
@@ -3393,8 +3457,8 @@
Returns:
how long ddcutil should sleep between each DDC request (lower is shorter).
-See the ddcutil docs for more info.
+
How long ddcutil should sleep between each DDC request (lower is shorter).
+See the ddcutil docs.
@@ -3408,7 +3472,22 @@
Returns:
max number of retries when calling the ddcutil
+
Max number of retries when calling the ddcutil
+
+
+
+
+
+ enable_async =
+True
+
+
+
+
+
+
Use the --async flag when calling ddcutil.
+See ddcutil docs
@@ -3425,24 +3504,24 @@
Returns:
723 @classmethod
-724 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-725 valid_displays = __cache__.get('ddcutil_monitors_info')
-726 if valid_displays is None:
-727 valid_displays = []
-728 for item in cls._gdi():
-729 if item['unsupported']:
-730 continue
-731 del item['unsupported']
-732 valid_displays.append(item)
-733
-734 if valid_displays:
-735 __cache__.store('ddcutil_monitors_info', valid_displays)
+ 726 @classmethod
+727 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+728 valid_displays = __cache__.get('ddcutil_monitors_info')
+729 if valid_displays is None:
+730 valid_displays = []
+731 for item in cls._gdi():
+732 if item['unsupported']:
+733 continue
+734 del item['unsupported']
+735 valid_displays.append(item)
736
-737 if display is not None:
-738 valid_displays = filter_monitors(
-739 display=display, haystack=valid_displays, include=['i2c_bus'])
-740 return valid_displays
+737 if valid_displays:
+738 __cache__.store('ddcutil_monitors_info', valid_displays)
+739
+740 if display is not None:
+741 valid_displays = filter_monitors(
+742 display=display, haystack=valid_displays, include=['i2c_bus'])
+743 return valid_displays
Returns:
Arguments:
Returns:
@@ -3488,44 +3567,44 @@ Returns:
742 @classmethod
-743 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-744 monitors = cls.get_display_info()
-745 if display is not None:
-746 monitors = [monitors[display]]
-747
-748 res = []
-749 for monitor in monitors:
-750 value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
-751 if value is None:
-752 cmd_out = check_output(
-753 [
-754 cls.executable,
-755 'getvcp', '10', '-t',
-756 '-b', str(monitor['bus_number']),
-757 f'--sleep-multiplier={cls.sleep_multiplier}'
-758 ], max_tries=cls.cmd_max_tries
-759 ).decode().split(' ')
-760
-761 value = int(cmd_out[-2])
-762 max_value = int(cmd_out[-1])
-763 if max_value != 100:
-764 # if the max brightness is not 100 then the number is not a percentage
-765 # and will need to be scaled
-766 value = int((value / max_value) * 100)
-767
-768 # now make sure max brightness is recorded so set_brightness can use it
-769 cache_ident = '%s-%s-%s' % (monitor['name'],
-770 monitor['serial'], monitor['bin_serial'])
-771 if cache_ident not in cls._max_brightness_cache:
-772 cls._max_brightness_cache[cache_ident] = max_value
-773 cls.logger.debug(
-774 f'{cache_ident} max brightness:{max_value} (current: {value})')
-775
-776 __cache__.store(
-777 f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
-778 res.append(value)
-779 return res
+ 745 @classmethod
+746 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+747 monitors = cls.get_display_info()
+748 if display is not None:
+749 monitors = [monitors[display]]
+750
+751 res = []
+752 for monitor in monitors:
+753 value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+754 if value is None:
+755 cmd_out = check_output(
+756 [
+757 cls.executable,
+758 'getvcp', '10', '-t',
+759 '-b', str(monitor['bus_number']),
+760 f'--sleep-multiplier={cls.sleep_multiplier}'
+761 ], max_tries=cls.cmd_max_tries
+762 ).decode().split(' ')
+763
+764 value = int(cmd_out[-2])
+765 max_value = int(cmd_out[-1])
+766 if max_value != 100:
+767 # if the max brightness is not 100 then the number is not a percentage
+768 # and will need to be scaled
+769 value = int((value / max_value) * 100)
+770
+771 # now make sure max brightness is recorded so set_brightness can use it
+772 cache_ident = '%s-%s-%s' % (monitor['name'],
+773 monitor['serial'], monitor['bin_serial'])
+774 if cache_ident not in cls._max_brightness_cache:
+775 cls._max_brightness_cache[cache_ident] = max_value
+776 cls._logger.debug(
+777 f'{cache_ident} max brightness:{max_value} (current: {value})')
+778
+779 __cache__.store(
+780 f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+781 res.append(value)
+782 return res
Returns:
Returns:
- A list of types.IntPercentage values, one for each
+
A list of screen_brightness_control.types.IntPercentage values, one for each
queried display
Returns:
781 @classmethod
-782 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-783 monitors = cls.get_display_info()
-784 if display is not None:
-785 monitors = [monitors[display]]
-786
-787 __cache__.expire(startswith='ddcutil_brightness_')
-788 for monitor in monitors:
-789 # check if monitor has a max brightness that requires us to scale this value
-790 cache_ident = '%s-%s-%s' % (monitor['name'],
-791 monitor['serial'], monitor['bin_serial'])
-792 if cache_ident not in cls._max_brightness_cache:
-793 cls.get_brightness(display=monitor['index'])
-794
-795 if cls._max_brightness_cache[cache_ident] != 100:
-796 value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+ 784 @classmethod
+785 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+786 monitors = cls.get_display_info()
+787 if display is not None:
+788 monitors = [monitors[display]]
+789
+790 __cache__.expire(startswith='ddcutil_brightness_')
+791 for monitor in monitors:
+792 # check if monitor has a max brightness that requires us to scale this value
+793 cache_ident = '%s-%s-%s' % (monitor['name'],
+794 monitor['serial'], monitor['bin_serial'])
+795 if cache_ident not in cls._max_brightness_cache:
+796 cls.get_brightness(display=monitor['index'])
797
-798 check_output(
-799 [
-800 cls.executable, 'setvcp', '10', str(value),
-801 '-b', str(monitor['bus_number']),
-802 f'--sleep-multiplier={cls.sleep_multiplier}'
-803 ], max_tries=cls.cmd_max_tries
-804 )
+798 if cls._max_brightness_cache[cache_ident] != 100:
+799 value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+800
+801 check_output(
+802 [
+803 cls.executable, 'setvcp', '10', str(value),
+804 '-b', str(monitor['bus_number']),
+805 f'--sleep-multiplier={cls.sleep_multiplier}'
+806 ], max_tries=cls.cmd_max_tries
+807 )
Arguments:
@@ -3608,39 +3687,39 @@
Returns:
807def list_monitors_info(
-808 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
-809) -> List[dict]:
-810 '''
-811 Lists detailed information about all detected displays
-812
-813 Args:
-814 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
-815 for more info on available methods
-816 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
-817 unsupported: include detected displays that are invalid or unsupported
-818 '''
-819 all_methods = get_methods(method).values()
-820 haystack = []
-821 for method_class in all_methods:
-822 try:
-823 if unsupported and issubclass(method_class, BrightnessMethodAdv):
-824 haystack += method_class._gdi()
-825 else:
-826 haystack += method_class.get_display_info()
-827 except Exception as e:
-828 logger.warning(
-829 f'error grabbing display info from {method_class} - {format_exc(e)}')
-830 pass
-831
-832 if allow_duplicates:
-833 return haystack
+ 810def list_monitors_info(
+811 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+812) -> List[dict]:
+813 '''
+814 Lists detailed information about all detected displays
+815
+816 Args:
+817 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
+818 for more info on available methods
+819 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+820 unsupported: include detected displays that are invalid or unsupported
+821 '''
+822 all_methods = get_methods(method).values()
+823 haystack = []
+824 for method_class in all_methods:
+825 try:
+826 if unsupported and issubclass(method_class, BrightnessMethodAdv):
+827 haystack += method_class._gdi()
+828 else:
+829 haystack += method_class.get_display_info()
+830 except Exception as e:
+831 _logger.warning(
+832 f'error grabbing display info from {method_class} - {format_exc(e)}')
+833 pass
834
-835 try:
-836 # use filter_monitors to remove duplicates
-837 return filter_monitors(haystack=haystack)
-838 except NoValidDisplayError:
-839 return []
+835 if allow_duplicates:
+836 return haystack
+837
+838 try:
+839 # use filter_monitors to remove duplicates
+840 return filter_monitors(haystack=haystack)
+841 except NoValidDisplayError:
+842 return []
and a value of '-40' would imply 10% brightness.
-
Relative brightness values will usually be resolved by the helpers.percentage function.
+Relative brightness values will usually be resolved by the helpers.percentage function.
- edid (str)
- serial (str)
- name (str)
-- model (str)
-
-###### Deprecated
-Identifying a display by its model is deprecated for removal in v0.22.0
-
-
-
-
-See Display for descriptions of each property and its type
+See Display for descriptions of each property and its type
39 monitor_info = win32api.GetMonitorInfo(pyhandle)
40 for adaptor_index in range(5):
41 try:
- 42 device = win32api.EnumDisplayDevices(
- 43 monitor_info['Device'], adaptor_index, 1)
- 44 except pywintypes.error:
- 45 logger.debug(
- 46 f'failed to get display device {monitor_info["Device"]} on adaptor index {adaptor_index}')
- 47 else:
- 48 yield device
- 49 break
- 50
+ 42 # EDD_GET_DEVICE_INTERFACE_NAME flag to populate DeviceID field
+ 43 device = win32api.EnumDisplayDevices(
+ 44 monitor_info['Device'], adaptor_index, 1)
+ 45 except pywintypes.error:
+ 46 _logger.debug(
+ 47 f'failed to get display device {monitor_info["Device"]} on adaptor index {adaptor_index}')
+ 48 else:
+ 49 yield device
+ 50 break
51
- 52def get_display_info() -> List[dict]:
- 53 '''
- 54 Gets information about all connected displays using WMI and win32api
- 55
- 56 Example:
- 57 ```python
- 58 import screen_brightness_control as s
- 59
- 60 info = s.windows.get_display_info()
- 61 for display in info:
- 62 print(display['name'])
- 63 ```
- 64 '''
- 65 info = __cache__.get('windows_monitors_info_raw')
- 66 if info is None:
- 67 info = []
- 68 # collect all monitor UIDs (derived from DeviceID)
- 69 monitor_uids = {}
- 70 for device in enum_display_devices():
- 71 monitor_uids[device.DeviceID.split('#')[2]] = device
- 72
- 73 # gather list of laptop displays to check against later
- 74 wmi = _wmi_init()
- 75 try:
- 76 laptop_displays = [
- 77 i.InstanceName
- 78 for i in wmi.WmiMonitorBrightness()
- 79 ]
- 80 except Exception as e:
- 81 # don't do specific exception classes here because WMI does not play ball with it
- 82 logger.warning(
- 83 f'get_display_info: failed to gather list of laptop displays - {format_exc(e)}')
- 84 laptop_displays = []
- 85
- 86 extras, desktop, laptop = [], 0, 0
- 87 uid_keys = list(monitor_uids.keys())
- 88 for monitor in wmi.WmiMonitorDescriptorMethods():
- 89 model, serial, manufacturer, man_id, edid = None, None, None, None, None
- 90 instance_name = monitor.InstanceName.replace(
- 91 '_0', '', 1).split('\\')[2]
- 92 pydevice = monitor_uids[instance_name]
- 93
- 94 # get the EDID
- 95 try:
- 96 edid = ''.join(
- 97 f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
- 98 # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
- 99 # takes too long
-100 parsed = EDID.parse(edid)
-101 man_id, manufacturer, model, name, serial = parsed
-102 if name is None:
-103 raise EDIDParseError(
-104 'parsed EDID returned invalid display name')
-105 except EDIDParseError as e:
-106 edid = None
-107 logger.warning(
-108 f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
-109 except Exception as e:
-110 edid = None
-111 logger.error(
-112 f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
-113 finally:
-114 if edid is None:
-115 devid = pydevice.DeviceID.split('#')
-116 serial = devid[2]
-117 man_id = devid[1][:3]
-118 model = devid[1][3:] or 'Generic Monitor'
-119 del devid
-120 try:
-121 man_id, manufacturer = _monitor_brand_lookup(man_id)
-122 except TypeError:
-123 manufacturer = None
-124
-125 if (serial, model) != (None, None):
-126 data = {
-127 'name': f'{manufacturer} {model}',
-128 'model': model,
-129 'serial': serial,
-130 'manufacturer': manufacturer,
-131 'manufacturer_id': man_id,
-132 'edid': edid
-133 }
-134 if monitor.InstanceName in laptop_displays:
-135 data['index'] = laptop
-136 data['method'] = WMI
-137 laptop += 1
-138 else:
-139 data['method'] = VCP
-140 desktop += 1
-141
-142 if instance_name in uid_keys:
-143 # insert the data into the uid_keys list because
-144 # uid_keys has the monitors sorted correctly. This
-145 # means we don't have to re-sort the list later
-146 uid_keys[uid_keys.index(instance_name)] = data
-147 else:
-148 extras.append(data)
-149
-150 info = uid_keys + extras
-151 if desktop:
-152 # now make sure desktop monitors have the correct index
-153 count = 0
-154 for item in info:
-155 if item['method'] == VCP:
-156 item['index'] = count
-157 count += 1
-158
-159 # return info only which has correct data
-160 info = [i for i in info if isinstance(i, dict)]
-161
-162 __cache__.store('windows_monitors_info_raw', info)
-163
-164 return info
+ 52
+ 53def get_display_info() -> List[dict]:
+ 54 '''
+ 55 Gets information about all connected displays using WMI and win32api
+ 56
+ 57 Example:
+ 58 ```python
+ 59 import screen_brightness_control as s
+ 60
+ 61 info = s.windows.get_display_info()
+ 62 for display in info:
+ 63 print(display['name'])
+ 64 ```
+ 65 '''
+ 66 info = __cache__.get('windows_monitors_info_raw')
+ 67 if info is None:
+ 68 info = []
+ 69 # collect all monitor UIDs (derived from DeviceID)
+ 70 monitor_uids = {}
+ 71 for device in enum_display_devices():
+ 72 monitor_uids[device.DeviceID.split('#')[2]] = device
+ 73
+ 74 # gather list of laptop displays to check against later
+ 75 wmi = _wmi_init()
+ 76 try:
+ 77 laptop_displays = [
+ 78 i.InstanceName
+ 79 for i in wmi.WmiMonitorBrightness()
+ 80 ]
+ 81 except Exception as e:
+ 82 # don't do specific exception classes here because WMI does not play ball with it
+ 83 _logger.warning(
+ 84 f'get_display_info: failed to gather list of laptop displays - {format_exc(e)}')
+ 85 laptop_displays = []
+ 86
+ 87 extras, desktop, laptop = [], 0, 0
+ 88 uid_keys = list(monitor_uids.keys())
+ 89 for monitor in wmi.WmiMonitorDescriptorMethods():
+ 90 model, serial, manufacturer, man_id, edid = None, None, None, None, None
+ 91 instance_name = monitor.InstanceName.replace(
+ 92 '_0', '', 1).split('\\')[2]
+ 93 pydevice = monitor_uids[instance_name]
+ 94
+ 95 # get the EDID
+ 96 try:
+ 97 edid = ''.join(
+ 98 f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
+ 99 # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
+100 # takes too long
+101 parsed = EDID.parse(edid)
+102 man_id, manufacturer, model, name, serial = parsed
+103 if name is None:
+104 raise EDIDParseError(
+105 'parsed EDID returned invalid display name')
+106 except EDIDParseError as e:
+107 edid = None
+108 _logger.warning(
+109 f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
+110 except Exception as e:
+111 edid = None
+112 _logger.error(
+113 f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
+114 finally:
+115 if edid is None:
+116 devid = pydevice.DeviceID.split('#')
+117 serial = devid[2]
+118 man_id = devid[1][:3]
+119 model = devid[1][3:] or 'Generic Monitor'
+120 del devid
+121 if (brand := _monitor_brand_lookup(man_id)):
+122 man_id, manufacturer = brand
+123
+124 if (serial, model) != (None, None):
+125 data: dict = {
+126 'name': f'{manufacturer} {model}',
+127 'model': model,
+128 'serial': serial,
+129 'manufacturer': manufacturer,
+130 'manufacturer_id': man_id,
+131 'edid': edid
+132 }
+133 if monitor.InstanceName in laptop_displays:
+134 data['index'] = laptop
+135 data['method'] = WMI
+136 laptop += 1
+137 else:
+138 data['method'] = VCP
+139 desktop += 1
+140
+141 if instance_name in uid_keys:
+142 # insert the data into the uid_keys list because
+143 # uid_keys has the monitors sorted correctly. This
+144 # means we don't have to re-sort the list later
+145 uid_keys[uid_keys.index(instance_name)] = data
+146 else:
+147 extras.append(data)
+148
+149 info = uid_keys + extras
+150 if desktop:
+151 # now make sure desktop monitors have the correct index
+152 count = 0
+153 for item in info:
+154 if item['method'] == VCP:
+155 item['index'] = count
+156 count += 1
+157
+158 # return info only which has correct data
+159 info = [i for i in info if isinstance(i, dict)]
+160
+161 __cache__.store('windows_monitors_info_raw', info)
+162
+163 return info
+164
165
-166
-167class WMI(BrightnessMethod):
-168 '''
-169 A collection of screen brightness related methods using the WMI API.
-170 This class primarily works with laptop displays.
-171 '''
-172 @classmethod
-173 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-174 info = [i for i in get_display_info() if i['method'] == cls]
-175 if display is not None:
-176 info = filter_monitors(display=display, haystack=info)
-177 return info
-178
-179 @classmethod
-180 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-181 brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
-182 if display is not None:
-183 brightness_method = [brightness_method[display]]
-184
-185 for method in brightness_method:
-186 method.WmiSetBrightness(value, 0)
-187
-188 @classmethod
-189 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-190 brightness_method = _wmi_init().WmiMonitorBrightness()
-191 if display is not None:
-192 brightness_method = [brightness_method[display]]
-193
-194 values = [i.CurrentBrightness for i in brightness_method]
-195 return values
+166class WMI(BrightnessMethod):
+167 '''
+168 A collection of screen brightness related methods using the WMI API.
+169 This class primarily works with laptop displays.
+170 '''
+171 @classmethod
+172 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+173 info = [i for i in get_display_info() if i['method'] == cls]
+174 if display is not None:
+175 info = filter_monitors(display=display, haystack=info)
+176 return info
+177
+178 @classmethod
+179 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+180 brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
+181 if display is not None:
+182 brightness_method = [brightness_method[display]]
+183
+184 for method in brightness_method:
+185 method.WmiSetBrightness(value, 0)
+186
+187 @classmethod
+188 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+189 brightness_method = _wmi_init().WmiMonitorBrightness()
+190 if display is not None:
+191 brightness_method = [brightness_method[display]]
+192
+193 values = [i.CurrentBrightness for i in brightness_method]
+194 return values
+195
196
-197
-198class VCP(BrightnessMethod):
-199 '''Collection of screen brightness related methods using the DDC/CI commands'''
-200 _MONITORENUMPROC = WINFUNCTYPE(BOOL, HMONITOR, HDC, POINTER(RECT), LPARAM)
-201
-202 logger = logger.getChild('VCP')
-203
-204 class _PHYSICAL_MONITOR(Structure):
-205 '''internal class, do not call'''
-206 _fields_ = [('handle', HANDLE),
-207 ('description', WCHAR * 128)]
-208
-209 @classmethod
-210 def iter_physical_monitors(cls, start: int = 0) -> Generator[ctypes.wintypes.HANDLE, None, None]:
-211 '''
-212 A generator to iterate through all physical monitors
-213 and then close them again afterwards, yielding their handles.
-214 It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
-215
-216 Args:
-217 start: skip the first X handles
-218
-219 Raises:
-220 ctypes.WinError: upon failure to enumerate through the monitors
-221 '''
-222 def callback(hmonitor, *_):
-223 monitors.append(HMONITOR(hmonitor))
-224 return True
-225
-226 monitors = []
-227 if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
-228 cls.logger.error('EnumDisplayMonitors failed')
-229 raise WinError('EnumDisplayMonitors failed')
-230
-231 # user index keeps track of valid monitors
-232 user_index = 0
-233 # monitor index keeps track of valid and pseudo monitors
-234 monitor_index = 0
-235 display_devices = list(enum_display_devices())
-236
-237 wmi = _wmi_init()
-238 try:
-239 laptop_displays = [
-240 i.InstanceName.replace('_0', '').split('\\')[2]
-241 for i in wmi.WmiMonitorBrightness()
-242 ]
-243 except Exception as e:
-244 cls.logger.warning(
-245 f'failed to gather list of laptop displays - {format_exc(e)}')
-246 laptop_displays = []
-247
-248 for monitor in monitors:
-249 # Get physical monitor count
-250 count = DWORD()
-251 if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
-252 raise WinError(
-253 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
-254 if count.value > 0:
-255 # Get physical monitor handles
-256 physical_array = (cls._PHYSICAL_MONITOR * count.value)()
-257 if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
-258 raise WinError(
-259 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
-260 for item in physical_array:
-261 # check that the monitor is not a pseudo monitor by
-262 # checking it's StateFlags for the
-263 # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
-264 if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
-265 # check if monitor is actually a laptop display
-266 if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
-267 if start is None or user_index >= start:
-268 yield item.handle
-269 # increment user index as a valid monitor was found
-270 user_index += 1
-271 # increment monitor index
-272 monitor_index += 1
-273 windll.dxva2.DestroyPhysicalMonitor(item.handle)
-274
-275 @classmethod
-276 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-277 info = [i for i in get_display_info() if i['method'] == cls]
-278 if display is not None:
-279 info = filter_monitors(display=display, haystack=info)
-280 return info
-281
-282 @classmethod
-283 def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
-284 '''
-285 Args:
-286 display: the index of the specific display to query.
-287 If unspecified, all detected displays are queried
-288 max_tries: the maximum allowed number of attempts to
-289 read the VCP output from the display
-290
-291 Returns:
-292 See `BrightnessMethod.get_brightness`
-293 '''
-294 code = BYTE(0x10)
-295 values = []
-296 start = display if display is not None else 0
-297 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
-298 current = __cache__.get(f'vcp_brightness_{index}')
-299 if current is None:
-300 cur_out = DWORD()
-301 handle = HANDLE(monitor)
-302 for attempt in range(max_tries):
-303 if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
-304 current = cur_out.value
-305 break
-306 current = None
-307 time.sleep(0.02 if attempt < 20 else 0.1)
-308 else:
-309 cls.logger.error(
-310 f'failed to get VCP feature reply for display:{index} after {attempt} tries')
-311
-312 if current is not None:
-313 __cache__.store(
-314 f'vcp_brightness_{index}', current, expires=0.1)
-315 values.append(current)
-316
-317 if display == index:
-318 # if we have just got the display we wanted then exit here
-319 # no point iterating through all the other ones
-320 break
-321
-322 if 'handle' in locals():
-323 # make sure final handle is destroyed
-324 windll.dxva2.DestroyPhysicalMonitor(handle)
-325 return values
-326
-327 @classmethod
-328 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
-329 '''
-330 Args:
-331 display: The specific display you wish to query.
-332 max_tries: the maximum allowed number of attempts to
-333 send the VCP input to the display
-334 '''
-335 __cache__.expire(startswith='vcp_brightness_')
-336 code = BYTE(0x10)
-337 value = DWORD(value)
-338 start = display if display is not None else 0
-339 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
-340 if display is None or display == index:
-341 handle = HANDLE(monitor)
-342 for attempt in range(max_tries):
-343 if windll.dxva2.SetVCPFeature(handle, code, value):
-344 break
-345 time.sleep(0.02 if attempt < 20 else 0.1)
-346 else:
-347 cls.logger.error(
-348 f'failed to set display:{index}->{value} after {attempt} tries')
-349
-350 if 'handle' in locals():
-351 # make sure final handle is destroyed
-352 windll.dxva2.DestroyPhysicalMonitor(handle)
+197class VCP(BrightnessMethod):
+198 '''Collection of screen brightness related methods using the DDC/CI commands'''
+199 _MONITORENUMPROC = WINFUNCTYPE(BOOL, HMONITOR, HDC, POINTER(RECT), LPARAM)
+200
+201 _logger = _logger.getChild('VCP')
+202
+203 class _PHYSICAL_MONITOR(Structure):
+204 '''internal class, do not call'''
+205 _fields_ = [('handle', HANDLE),
+206 ('description', WCHAR * 128)]
+207
+208 @classmethod
+209 def iter_physical_monitors(cls, start: int = 0) -> Generator[ctypes.wintypes.HANDLE, None, None]:
+210 '''
+211 A generator to iterate through all physical monitors
+212 and then close them again afterwards, yielding their handles.
+213 It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+214
+215 Args:
+216 start: skip the first X handles
+217
+218 Raises:
+219 ctypes.WinError: upon failure to enumerate through the monitors
+220 '''
+221 def callback(hmonitor, *_):
+222 monitors.append(HMONITOR(hmonitor))
+223 return True
+224
+225 monitors: List[HMONITOR] = []
+226 if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
+227 cls._logger.error('EnumDisplayMonitors failed')
+228 raise WinError('EnumDisplayMonitors failed')
+229
+230 # user index keeps track of valid monitors
+231 user_index = 0
+232 # monitor index keeps track of valid and pseudo monitors
+233 monitor_index = 0
+234 display_devices = list(enum_display_devices())
+235
+236 wmi = _wmi_init()
+237 try:
+238 laptop_displays = [
+239 i.InstanceName.replace('_0', '').split('\\')[2]
+240 for i in wmi.WmiMonitorBrightness()
+241 ]
+242 except Exception as e:
+243 cls._logger.warning(
+244 f'failed to gather list of laptop displays - {format_exc(e)}')
+245 laptop_displays = []
+246
+247 for monitor in monitors:
+248 # Get physical monitor count
+249 count = DWORD()
+250 if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+251 raise WinError(
+252 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+253 if count.value > 0:
+254 # Get physical monitor handles
+255 physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+256 if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+257 raise WinError(
+258 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+259 for item in physical_array:
+260 # check that the monitor is not a pseudo monitor by
+261 # checking it's StateFlags for the
+262 # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+263 if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+264 # check if monitor is actually a laptop display
+265 if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+266 if start is None or user_index >= start:
+267 yield item.handle
+268 # increment user index as a valid monitor was found
+269 user_index += 1
+270 # increment monitor index
+271 monitor_index += 1
+272 windll.dxva2.DestroyPhysicalMonitor(item.handle)
+273
+274 @classmethod
+275 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+276 info = [i for i in get_display_info() if i['method'] == cls]
+277 if display is not None:
+278 info = filter_monitors(display=display, haystack=info)
+279 return info
+280
+281 @classmethod
+282 def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+283 '''
+284 Args:
+285 display: the index of the specific display to query.
+286 If unspecified, all detected displays are queried
+287 max_tries: the maximum allowed number of attempts to
+288 read the VCP output from the display
+289
+290 Returns:
+291 See `BrightnessMethod.get_brightness`
+292 '''
+293 code = BYTE(0x10)
+294 values = []
+295 start = display if display is not None else 0
+296 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
+297 current = __cache__.get(f'vcp_brightness_{index}')
+298 if current is None:
+299 cur_out = DWORD()
+300 handle = HANDLE(monitor)
+301 for attempt in range(max_tries):
+302 if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+303 current = cur_out.value
+304 break
+305 current = None
+306 time.sleep(0.02 if attempt < 20 else 0.1)
+307 else:
+308 cls._logger.error(
+309 f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+310
+311 if current is not None:
+312 __cache__.store(
+313 f'vcp_brightness_{index}', current, expires=0.1)
+314 values.append(current)
+315
+316 if display == index:
+317 # if we have just got the display we wanted then exit here
+318 # no point iterating through all the other ones
+319 break
+320
+321 if 'handle' in locals():
+322 # make sure final handle is destroyed
+323 windll.dxva2.DestroyPhysicalMonitor(handle)
+324 return values
+325
+326 @classmethod
+327 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+328 '''
+329 Args:
+330 display: The specific display you wish to query.
+331 max_tries: the maximum allowed number of attempts to
+332 send the VCP input to the display
+333 '''
+334 __cache__.expire(startswith='vcp_brightness_')
+335 code = BYTE(0x10)
+336 value_dword = DWORD(value)
+337 start = display if display is not None else 0
+338 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
+339 if display is None or display == index:
+340 handle = HANDLE(monitor)
+341 for attempt in range(max_tries):
+342 if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+343 break
+344 time.sleep(0.02 if attempt < 20 else 0.1)
+345 else:
+346 cls._logger.error(
+347 f'failed to set display:{index}->{value} after {attempt} tries')
+348
+349 if 'handle' in locals():
+350 # make sure final handle is destroyed
+351 windll.dxva2.DestroyPhysicalMonitor(handle)
+352
353
-354
-355def list_monitors_info(
-356 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
-357) -> List[dict]:
-358 '''
-359 Lists detailed information about all detected displays
-360
-361 Args:
-362 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
-363 for more info on available methods
-364 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
-365 unsupported: include detected displays that are invalid or unsupported.
-366 This argument does nothing on Windows
-367 '''
-368 # no caching here because get_display_info caches its results
-369 info = get_display_info()
-370
-371 all_methods = get_methods(method).values()
-372
-373 if method is not None:
-374 info = [i for i in info if i['method'] in all_methods]
-375
-376 if allow_duplicates:
-377 return info
-378
-379 try:
-380 # use filter_monitors to remove duplicates
-381 return filter_monitors(haystack=info)
-382 except NoValidDisplayError:
-383 return []
+354def list_monitors_info(
+355 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+356) -> List[dict]:
+357 '''
+358 Lists detailed information about all detected displays
+359
+360 Args:
+361 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
+362 for more info on available methods
+363 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+364 unsupported: include detected displays that are invalid or unsupported.
+365 This argument does nothing on Windows
+366 '''
+367 # no caching here because get_display_info caches its results
+368 info = get_display_info()
+369
+370 all_methods = get_methods(method).values()
+371
+372 if method is not None:
+373 info = [i for i in info if i['method'] in all_methods]
+374
+375 if allow_duplicates:
+376 return info
+377
+378 try:
+379 # use filter_monitors to remove duplicates
+380 return filter_monitors(haystack=info)
+381 except NoValidDisplayError:
+382 return []
40 monitor_info = win32api.GetMonitorInfo(pyhandle)
41 for adaptor_index in range(5):
42 try:
-43 device = win32api.EnumDisplayDevices(
-44 monitor_info['Device'], adaptor_index, 1)
-45 except pywintypes.error:
-46 logger.debug(
-47 f'failed to get display device {monitor_info["Device"]} on adaptor index {adaptor_index}')
-48 else:
-49 yield device
-50 break
+43 # EDD_GET_DEVICE_INTERFACE_NAME flag to populate DeviceID field
+44 device = win32api.EnumDisplayDevices(
+45 monitor_info['Device'], adaptor_index, 1)
+46 except pywintypes.error:
+47 _logger.debug(
+48 f'failed to get display device {monitor_info["Device"]} on adaptor index {adaptor_index}')
+49 else:
+50 yield device
+51 break
53def get_display_info() -> List[dict]:
- 54 '''
- 55 Gets information about all connected displays using WMI and win32api
- 56
- 57 Example:
- 58 ```python
- 59 import screen_brightness_control as s
- 60
- 61 info = s.windows.get_display_info()
- 62 for display in info:
- 63 print(display['name'])
- 64 ```
- 65 '''
- 66 info = __cache__.get('windows_monitors_info_raw')
- 67 if info is None:
- 68 info = []
- 69 # collect all monitor UIDs (derived from DeviceID)
- 70 monitor_uids = {}
- 71 for device in enum_display_devices():
- 72 monitor_uids[device.DeviceID.split('#')[2]] = device
- 73
- 74 # gather list of laptop displays to check against later
- 75 wmi = _wmi_init()
- 76 try:
- 77 laptop_displays = [
- 78 i.InstanceName
- 79 for i in wmi.WmiMonitorBrightness()
- 80 ]
- 81 except Exception as e:
- 82 # don't do specific exception classes here because WMI does not play ball with it
- 83 logger.warning(
- 84 f'get_display_info: failed to gather list of laptop displays - {format_exc(e)}')
- 85 laptop_displays = []
- 86
- 87 extras, desktop, laptop = [], 0, 0
- 88 uid_keys = list(monitor_uids.keys())
- 89 for monitor in wmi.WmiMonitorDescriptorMethods():
- 90 model, serial, manufacturer, man_id, edid = None, None, None, None, None
- 91 instance_name = monitor.InstanceName.replace(
- 92 '_0', '', 1).split('\\')[2]
- 93 pydevice = monitor_uids[instance_name]
- 94
- 95 # get the EDID
- 96 try:
- 97 edid = ''.join(
- 98 f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
- 99 # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
-100 # takes too long
-101 parsed = EDID.parse(edid)
-102 man_id, manufacturer, model, name, serial = parsed
-103 if name is None:
-104 raise EDIDParseError(
-105 'parsed EDID returned invalid display name')
-106 except EDIDParseError as e:
-107 edid = None
-108 logger.warning(
-109 f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
-110 except Exception as e:
-111 edid = None
-112 logger.error(
-113 f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
-114 finally:
-115 if edid is None:
-116 devid = pydevice.DeviceID.split('#')
-117 serial = devid[2]
-118 man_id = devid[1][:3]
-119 model = devid[1][3:] or 'Generic Monitor'
-120 del devid
-121 try:
-122 man_id, manufacturer = _monitor_brand_lookup(man_id)
-123 except TypeError:
-124 manufacturer = None
-125
-126 if (serial, model) != (None, None):
-127 data = {
-128 'name': f'{manufacturer} {model}',
-129 'model': model,
-130 'serial': serial,
-131 'manufacturer': manufacturer,
-132 'manufacturer_id': man_id,
-133 'edid': edid
-134 }
-135 if monitor.InstanceName in laptop_displays:
-136 data['index'] = laptop
-137 data['method'] = WMI
-138 laptop += 1
-139 else:
-140 data['method'] = VCP
-141 desktop += 1
-142
-143 if instance_name in uid_keys:
-144 # insert the data into the uid_keys list because
-145 # uid_keys has the monitors sorted correctly. This
-146 # means we don't have to re-sort the list later
-147 uid_keys[uid_keys.index(instance_name)] = data
-148 else:
-149 extras.append(data)
-150
-151 info = uid_keys + extras
-152 if desktop:
-153 # now make sure desktop monitors have the correct index
-154 count = 0
-155 for item in info:
-156 if item['method'] == VCP:
-157 item['index'] = count
-158 count += 1
-159
-160 # return info only which has correct data
-161 info = [i for i in info if isinstance(i, dict)]
-162
-163 __cache__.store('windows_monitors_info_raw', info)
-164
-165 return info
+ 54def get_display_info() -> List[dict]:
+ 55 '''
+ 56 Gets information about all connected displays using WMI and win32api
+ 57
+ 58 Example:
+ 59 ```python
+ 60 import screen_brightness_control as s
+ 61
+ 62 info = s.windows.get_display_info()
+ 63 for display in info:
+ 64 print(display['name'])
+ 65 ```
+ 66 '''
+ 67 info = __cache__.get('windows_monitors_info_raw')
+ 68 if info is None:
+ 69 info = []
+ 70 # collect all monitor UIDs (derived from DeviceID)
+ 71 monitor_uids = {}
+ 72 for device in enum_display_devices():
+ 73 monitor_uids[device.DeviceID.split('#')[2]] = device
+ 74
+ 75 # gather list of laptop displays to check against later
+ 76 wmi = _wmi_init()
+ 77 try:
+ 78 laptop_displays = [
+ 79 i.InstanceName
+ 80 for i in wmi.WmiMonitorBrightness()
+ 81 ]
+ 82 except Exception as e:
+ 83 # don't do specific exception classes here because WMI does not play ball with it
+ 84 _logger.warning(
+ 85 f'get_display_info: failed to gather list of laptop displays - {format_exc(e)}')
+ 86 laptop_displays = []
+ 87
+ 88 extras, desktop, laptop = [], 0, 0
+ 89 uid_keys = list(monitor_uids.keys())
+ 90 for monitor in wmi.WmiMonitorDescriptorMethods():
+ 91 model, serial, manufacturer, man_id, edid = None, None, None, None, None
+ 92 instance_name = monitor.InstanceName.replace(
+ 93 '_0', '', 1).split('\\')[2]
+ 94 pydevice = monitor_uids[instance_name]
+ 95
+ 96 # get the EDID
+ 97 try:
+ 98 edid = ''.join(
+ 99 f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
+100 # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
+101 # takes too long
+102 parsed = EDID.parse(edid)
+103 man_id, manufacturer, model, name, serial = parsed
+104 if name is None:
+105 raise EDIDParseError(
+106 'parsed EDID returned invalid display name')
+107 except EDIDParseError as e:
+108 edid = None
+109 _logger.warning(
+110 f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
+111 except Exception as e:
+112 edid = None
+113 _logger.error(
+114 f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
+115 finally:
+116 if edid is None:
+117 devid = pydevice.DeviceID.split('#')
+118 serial = devid[2]
+119 man_id = devid[1][:3]
+120 model = devid[1][3:] or 'Generic Monitor'
+121 del devid
+122 if (brand := _monitor_brand_lookup(man_id)):
+123 man_id, manufacturer = brand
+124
+125 if (serial, model) != (None, None):
+126 data: dict = {
+127 'name': f'{manufacturer} {model}',
+128 'model': model,
+129 'serial': serial,
+130 'manufacturer': manufacturer,
+131 'manufacturer_id': man_id,
+132 'edid': edid
+133 }
+134 if monitor.InstanceName in laptop_displays:
+135 data['index'] = laptop
+136 data['method'] = WMI
+137 laptop += 1
+138 else:
+139 data['method'] = VCP
+140 desktop += 1
+141
+142 if instance_name in uid_keys:
+143 # insert the data into the uid_keys list because
+144 # uid_keys has the monitors sorted correctly. This
+145 # means we don't have to re-sort the list later
+146 uid_keys[uid_keys.index(instance_name)] = data
+147 else:
+148 extras.append(data)
+149
+150 info = uid_keys + extras
+151 if desktop:
+152 # now make sure desktop monitors have the correct index
+153 count = 0
+154 for item in info:
+155 if item['method'] == VCP:
+156 item['index'] = count
+157 count += 1
+158
+159 # return info only which has correct data
+160 info = [i for i in info if isinstance(i, dict)]
+161
+162 __cache__.store('windows_monitors_info_raw', info)
+163
+164 return info
Example:
168class WMI(BrightnessMethod):
-169 '''
-170 A collection of screen brightness related methods using the WMI API.
-171 This class primarily works with laptop displays.
-172 '''
-173 @classmethod
-174 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-175 info = [i for i in get_display_info() if i['method'] == cls]
-176 if display is not None:
-177 info = filter_monitors(display=display, haystack=info)
-178 return info
-179
-180 @classmethod
-181 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-182 brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
-183 if display is not None:
-184 brightness_method = [brightness_method[display]]
-185
-186 for method in brightness_method:
-187 method.WmiSetBrightness(value, 0)
-188
-189 @classmethod
-190 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-191 brightness_method = _wmi_init().WmiMonitorBrightness()
-192 if display is not None:
-193 brightness_method = [brightness_method[display]]
-194
-195 values = [i.CurrentBrightness for i in brightness_method]
-196 return values
+ 167class WMI(BrightnessMethod):
+168 '''
+169 A collection of screen brightness related methods using the WMI API.
+170 This class primarily works with laptop displays.
+171 '''
+172 @classmethod
+173 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+174 info = [i for i in get_display_info() if i['method'] == cls]
+175 if display is not None:
+176 info = filter_monitors(display=display, haystack=info)
+177 return info
+178
+179 @classmethod
+180 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+181 brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
+182 if display is not None:
+183 brightness_method = [brightness_method[display]]
+184
+185 for method in brightness_method:
+186 method.WmiSetBrightness(value, 0)
+187
+188 @classmethod
+189 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+190 brightness_method = _wmi_init().WmiMonitorBrightness()
+191 if display is not None:
+192 brightness_method = [brightness_method[display]]
+193
+194 values = [i.CurrentBrightness for i in brightness_method]
+195 return values
Example:
173 @classmethod
-174 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-175 info = [i for i in get_display_info() if i['method'] == cls]
-176 if display is not None:
-177 info = filter_monitors(display=display, haystack=info)
-178 return info
+ 172 @classmethod
+173 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+174 info = [i for i in get_display_info() if i['method'] == cls]
+175 if display is not None:
+176 info = filter_monitors(display=display, haystack=info)
+177 return info
Example:
Arguments:
Returns:
@@ -810,21 +808,21 @@ Returns:
180 @classmethod
-181 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
-182 brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
-183 if display is not None:
-184 brightness_method = [brightness_method[display]]
-185
-186 for method in brightness_method:
-187 method.WmiSetBrightness(value, 0)
+ 179 @classmethod
+180 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+181 brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
+182 if display is not None:
+183 brightness_method = [brightness_method[display]]
+184
+185 for method in brightness_method:
+186 method.WmiSetBrightness(value, 0)
Arguments:
@@ -844,14 +842,14 @@
Returns:
189 @classmethod
-190 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
-191 brightness_method = _wmi_init().WmiMonitorBrightness()
-192 if display is not None:
-193 brightness_method = [brightness_method[display]]
-194
-195 values = [i.CurrentBrightness for i in brightness_method]
-196 return values
+ 188 @classmethod
+189 def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+190 brightness_method = _wmi_init().WmiMonitorBrightness()
+191 if display is not None:
+192 brightness_method = [brightness_method[display]]
+193
+194 values = [i.CurrentBrightness for i in brightness_method]
+195 return values
Returns:
Returns:
- A list of types.IntPercentage values, one for each
+
A list of screen_brightness_control.types.IntPercentage values, one for each
queried display
Returns:
199class VCP(BrightnessMethod):
-200 '''Collection of screen brightness related methods using the DDC/CI commands'''
-201 _MONITORENUMPROC = WINFUNCTYPE(BOOL, HMONITOR, HDC, POINTER(RECT), LPARAM)
-202
-203 logger = logger.getChild('VCP')
-204
-205 class _PHYSICAL_MONITOR(Structure):
-206 '''internal class, do not call'''
-207 _fields_ = [('handle', HANDLE),
-208 ('description', WCHAR * 128)]
-209
-210 @classmethod
-211 def iter_physical_monitors(cls, start: int = 0) -> Generator[ctypes.wintypes.HANDLE, None, None]:
-212 '''
-213 A generator to iterate through all physical monitors
-214 and then close them again afterwards, yielding their handles.
-215 It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
-216
-217 Args:
-218 start: skip the first X handles
-219
-220 Raises:
-221 ctypes.WinError: upon failure to enumerate through the monitors
-222 '''
-223 def callback(hmonitor, *_):
-224 monitors.append(HMONITOR(hmonitor))
-225 return True
-226
-227 monitors = []
-228 if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
-229 cls.logger.error('EnumDisplayMonitors failed')
-230 raise WinError('EnumDisplayMonitors failed')
-231
-232 # user index keeps track of valid monitors
-233 user_index = 0
-234 # monitor index keeps track of valid and pseudo monitors
-235 monitor_index = 0
-236 display_devices = list(enum_display_devices())
-237
-238 wmi = _wmi_init()
-239 try:
-240 laptop_displays = [
-241 i.InstanceName.replace('_0', '').split('\\')[2]
-242 for i in wmi.WmiMonitorBrightness()
-243 ]
-244 except Exception as e:
-245 cls.logger.warning(
-246 f'failed to gather list of laptop displays - {format_exc(e)}')
-247 laptop_displays = []
-248
-249 for monitor in monitors:
-250 # Get physical monitor count
-251 count = DWORD()
-252 if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
-253 raise WinError(
-254 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
-255 if count.value > 0:
-256 # Get physical monitor handles
-257 physical_array = (cls._PHYSICAL_MONITOR * count.value)()
-258 if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
-259 raise WinError(
-260 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
-261 for item in physical_array:
-262 # check that the monitor is not a pseudo monitor by
-263 # checking it's StateFlags for the
-264 # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
-265 if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
-266 # check if monitor is actually a laptop display
-267 if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
-268 if start is None or user_index >= start:
-269 yield item.handle
-270 # increment user index as a valid monitor was found
-271 user_index += 1
-272 # increment monitor index
-273 monitor_index += 1
-274 windll.dxva2.DestroyPhysicalMonitor(item.handle)
-275
-276 @classmethod
-277 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-278 info = [i for i in get_display_info() if i['method'] == cls]
-279 if display is not None:
-280 info = filter_monitors(display=display, haystack=info)
-281 return info
-282
-283 @classmethod
-284 def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
-285 '''
-286 Args:
-287 display: the index of the specific display to query.
-288 If unspecified, all detected displays are queried
-289 max_tries: the maximum allowed number of attempts to
-290 read the VCP output from the display
-291
-292 Returns:
-293 See `BrightnessMethod.get_brightness`
-294 '''
-295 code = BYTE(0x10)
-296 values = []
-297 start = display if display is not None else 0
-298 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
-299 current = __cache__.get(f'vcp_brightness_{index}')
-300 if current is None:
-301 cur_out = DWORD()
-302 handle = HANDLE(monitor)
-303 for attempt in range(max_tries):
-304 if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
-305 current = cur_out.value
-306 break
-307 current = None
-308 time.sleep(0.02 if attempt < 20 else 0.1)
-309 else:
-310 cls.logger.error(
-311 f'failed to get VCP feature reply for display:{index} after {attempt} tries')
-312
-313 if current is not None:
-314 __cache__.store(
-315 f'vcp_brightness_{index}', current, expires=0.1)
-316 values.append(current)
-317
-318 if display == index:
-319 # if we have just got the display we wanted then exit here
-320 # no point iterating through all the other ones
-321 break
-322
-323 if 'handle' in locals():
-324 # make sure final handle is destroyed
-325 windll.dxva2.DestroyPhysicalMonitor(handle)
-326 return values
-327
-328 @classmethod
-329 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
-330 '''
-331 Args:
-332 display: The specific display you wish to query.
-333 max_tries: the maximum allowed number of attempts to
-334 send the VCP input to the display
-335 '''
-336 __cache__.expire(startswith='vcp_brightness_')
-337 code = BYTE(0x10)
-338 value = DWORD(value)
-339 start = display if display is not None else 0
-340 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
-341 if display is None or display == index:
-342 handle = HANDLE(monitor)
-343 for attempt in range(max_tries):
-344 if windll.dxva2.SetVCPFeature(handle, code, value):
-345 break
-346 time.sleep(0.02 if attempt < 20 else 0.1)
-347 else:
-348 cls.logger.error(
-349 f'failed to set display:{index}->{value} after {attempt} tries')
-350
-351 if 'handle' in locals():
-352 # make sure final handle is destroyed
-353 windll.dxva2.DestroyPhysicalMonitor(handle)
+ 198class VCP(BrightnessMethod):
+199 '''Collection of screen brightness related methods using the DDC/CI commands'''
+200 _MONITORENUMPROC = WINFUNCTYPE(BOOL, HMONITOR, HDC, POINTER(RECT), LPARAM)
+201
+202 _logger = _logger.getChild('VCP')
+203
+204 class _PHYSICAL_MONITOR(Structure):
+205 '''internal class, do not call'''
+206 _fields_ = [('handle', HANDLE),
+207 ('description', WCHAR * 128)]
+208
+209 @classmethod
+210 def iter_physical_monitors(cls, start: int = 0) -> Generator[ctypes.wintypes.HANDLE, None, None]:
+211 '''
+212 A generator to iterate through all physical monitors
+213 and then close them again afterwards, yielding their handles.
+214 It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+215
+216 Args:
+217 start: skip the first X handles
+218
+219 Raises:
+220 ctypes.WinError: upon failure to enumerate through the monitors
+221 '''
+222 def callback(hmonitor, *_):
+223 monitors.append(HMONITOR(hmonitor))
+224 return True
+225
+226 monitors: List[HMONITOR] = []
+227 if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
+228 cls._logger.error('EnumDisplayMonitors failed')
+229 raise WinError('EnumDisplayMonitors failed')
+230
+231 # user index keeps track of valid monitors
+232 user_index = 0
+233 # monitor index keeps track of valid and pseudo monitors
+234 monitor_index = 0
+235 display_devices = list(enum_display_devices())
+236
+237 wmi = _wmi_init()
+238 try:
+239 laptop_displays = [
+240 i.InstanceName.replace('_0', '').split('\\')[2]
+241 for i in wmi.WmiMonitorBrightness()
+242 ]
+243 except Exception as e:
+244 cls._logger.warning(
+245 f'failed to gather list of laptop displays - {format_exc(e)}')
+246 laptop_displays = []
+247
+248 for monitor in monitors:
+249 # Get physical monitor count
+250 count = DWORD()
+251 if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+252 raise WinError(
+253 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+254 if count.value > 0:
+255 # Get physical monitor handles
+256 physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+257 if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+258 raise WinError(
+259 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+260 for item in physical_array:
+261 # check that the monitor is not a pseudo monitor by
+262 # checking it's StateFlags for the
+263 # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+264 if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+265 # check if monitor is actually a laptop display
+266 if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+267 if start is None or user_index >= start:
+268 yield item.handle
+269 # increment user index as a valid monitor was found
+270 user_index += 1
+271 # increment monitor index
+272 monitor_index += 1
+273 windll.dxva2.DestroyPhysicalMonitor(item.handle)
+274
+275 @classmethod
+276 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+277 info = [i for i in get_display_info() if i['method'] == cls]
+278 if display is not None:
+279 info = filter_monitors(display=display, haystack=info)
+280 return info
+281
+282 @classmethod
+283 def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+284 '''
+285 Args:
+286 display: the index of the specific display to query.
+287 If unspecified, all detected displays are queried
+288 max_tries: the maximum allowed number of attempts to
+289 read the VCP output from the display
+290
+291 Returns:
+292 See `BrightnessMethod.get_brightness`
+293 '''
+294 code = BYTE(0x10)
+295 values = []
+296 start = display if display is not None else 0
+297 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
+298 current = __cache__.get(f'vcp_brightness_{index}')
+299 if current is None:
+300 cur_out = DWORD()
+301 handle = HANDLE(monitor)
+302 for attempt in range(max_tries):
+303 if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+304 current = cur_out.value
+305 break
+306 current = None
+307 time.sleep(0.02 if attempt < 20 else 0.1)
+308 else:
+309 cls._logger.error(
+310 f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+311
+312 if current is not None:
+313 __cache__.store(
+314 f'vcp_brightness_{index}', current, expires=0.1)
+315 values.append(current)
+316
+317 if display == index:
+318 # if we have just got the display we wanted then exit here
+319 # no point iterating through all the other ones
+320 break
+321
+322 if 'handle' in locals():
+323 # make sure final handle is destroyed
+324 windll.dxva2.DestroyPhysicalMonitor(handle)
+325 return values
+326
+327 @classmethod
+328 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+329 '''
+330 Args:
+331 display: The specific display you wish to query.
+332 max_tries: the maximum allowed number of attempts to
+333 send the VCP input to the display
+334 '''
+335 __cache__.expire(startswith='vcp_brightness_')
+336 code = BYTE(0x10)
+337 value_dword = DWORD(value)
+338 start = display if display is not None else 0
+339 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
+340 if display is None or display == index:
+341 handle = HANDLE(monitor)
+342 for attempt in range(max_tries):
+343 if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+344 break
+345 time.sleep(0.02 if attempt < 20 else 0.1)
+346 else:
+347 cls._logger.error(
+348 f'failed to set display:{index}->{value} after {attempt} tries')
+349
+350 if 'handle' in locals():
+351 # make sure final handle is destroyed
+352 windll.dxva2.DestroyPhysicalMonitor(handle)
Returns:
210 @classmethod
-211 def iter_physical_monitors(cls, start: int = 0) -> Generator[ctypes.wintypes.HANDLE, None, None]:
-212 '''
-213 A generator to iterate through all physical monitors
-214 and then close them again afterwards, yielding their handles.
-215 It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
-216
-217 Args:
-218 start: skip the first X handles
-219
-220 Raises:
-221 ctypes.WinError: upon failure to enumerate through the monitors
-222 '''
-223 def callback(hmonitor, *_):
-224 monitors.append(HMONITOR(hmonitor))
-225 return True
-226
-227 monitors = []
-228 if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
-229 cls.logger.error('EnumDisplayMonitors failed')
-230 raise WinError('EnumDisplayMonitors failed')
-231
-232 # user index keeps track of valid monitors
-233 user_index = 0
-234 # monitor index keeps track of valid and pseudo monitors
-235 monitor_index = 0
-236 display_devices = list(enum_display_devices())
-237
-238 wmi = _wmi_init()
-239 try:
-240 laptop_displays = [
-241 i.InstanceName.replace('_0', '').split('\\')[2]
-242 for i in wmi.WmiMonitorBrightness()
-243 ]
-244 except Exception as e:
-245 cls.logger.warning(
-246 f'failed to gather list of laptop displays - {format_exc(e)}')
-247 laptop_displays = []
-248
-249 for monitor in monitors:
-250 # Get physical monitor count
-251 count = DWORD()
-252 if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
-253 raise WinError(
-254 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
-255 if count.value > 0:
-256 # Get physical monitor handles
-257 physical_array = (cls._PHYSICAL_MONITOR * count.value)()
-258 if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
-259 raise WinError(
-260 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
-261 for item in physical_array:
-262 # check that the monitor is not a pseudo monitor by
-263 # checking it's StateFlags for the
-264 # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
-265 if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
-266 # check if monitor is actually a laptop display
-267 if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
-268 if start is None or user_index >= start:
-269 yield item.handle
-270 # increment user index as a valid monitor was found
-271 user_index += 1
-272 # increment monitor index
-273 monitor_index += 1
-274 windll.dxva2.DestroyPhysicalMonitor(item.handle)
+ 209 @classmethod
+210 def iter_physical_monitors(cls, start: int = 0) -> Generator[ctypes.wintypes.HANDLE, None, None]:
+211 '''
+212 A generator to iterate through all physical monitors
+213 and then close them again afterwards, yielding their handles.
+214 It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+215
+216 Args:
+217 start: skip the first X handles
+218
+219 Raises:
+220 ctypes.WinError: upon failure to enumerate through the monitors
+221 '''
+222 def callback(hmonitor, *_):
+223 monitors.append(HMONITOR(hmonitor))
+224 return True
+225
+226 monitors: List[HMONITOR] = []
+227 if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
+228 cls._logger.error('EnumDisplayMonitors failed')
+229 raise WinError('EnumDisplayMonitors failed')
+230
+231 # user index keeps track of valid monitors
+232 user_index = 0
+233 # monitor index keeps track of valid and pseudo monitors
+234 monitor_index = 0
+235 display_devices = list(enum_display_devices())
+236
+237 wmi = _wmi_init()
+238 try:
+239 laptop_displays = [
+240 i.InstanceName.replace('_0', '').split('\\')[2]
+241 for i in wmi.WmiMonitorBrightness()
+242 ]
+243 except Exception as e:
+244 cls._logger.warning(
+245 f'failed to gather list of laptop displays - {format_exc(e)}')
+246 laptop_displays = []
+247
+248 for monitor in monitors:
+249 # Get physical monitor count
+250 count = DWORD()
+251 if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+252 raise WinError(
+253 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+254 if count.value > 0:
+255 # Get physical monitor handles
+256 physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+257 if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+258 raise WinError(
+259 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+260 for item in physical_array:
+261 # check that the monitor is not a pseudo monitor by
+262 # checking it's StateFlags for the
+263 # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+264 if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+265 # check if monitor is actually a laptop display
+266 if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+267 if start is None or user_index >= start:
+268 yield item.handle
+269 # increment user index as a valid monitor was found
+270 user_index += 1
+271 # increment monitor index
+272 monitor_index += 1
+273 windll.dxva2.DestroyPhysicalMonitor(item.handle)
Raises:
276 @classmethod
-277 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
-278 info = [i for i in get_display_info() if i['method'] == cls]
-279 if display is not None:
-280 info = filter_monitors(display=display, haystack=info)
-281 return info
+ 275 @classmethod
+276 def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+277 info = [i for i in get_display_info() if i['method'] == cls]
+278 if display is not None:
+279 info = filter_monitors(display=display, haystack=info)
+280 return info
Raises:
Arguments:
Returns:
@@ -1208,50 +1206,50 @@ Returns:
283 @classmethod
-284 def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
-285 '''
-286 Args:
-287 display: the index of the specific display to query.
-288 If unspecified, all detected displays are queried
-289 max_tries: the maximum allowed number of attempts to
-290 read the VCP output from the display
-291
-292 Returns:
-293 See `BrightnessMethod.get_brightness`
-294 '''
-295 code = BYTE(0x10)
-296 values = []
-297 start = display if display is not None else 0
-298 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
-299 current = __cache__.get(f'vcp_brightness_{index}')
-300 if current is None:
-301 cur_out = DWORD()
-302 handle = HANDLE(monitor)
-303 for attempt in range(max_tries):
-304 if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
-305 current = cur_out.value
-306 break
-307 current = None
-308 time.sleep(0.02 if attempt < 20 else 0.1)
-309 else:
-310 cls.logger.error(
-311 f'failed to get VCP feature reply for display:{index} after {attempt} tries')
-312
-313 if current is not None:
-314 __cache__.store(
-315 f'vcp_brightness_{index}', current, expires=0.1)
-316 values.append(current)
-317
-318 if display == index:
-319 # if we have just got the display we wanted then exit here
-320 # no point iterating through all the other ones
-321 break
-322
-323 if 'handle' in locals():
-324 # make sure final handle is destroyed
-325 windll.dxva2.DestroyPhysicalMonitor(handle)
-326 return values
+ 282 @classmethod
+283 def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+284 '''
+285 Args:
+286 display: the index of the specific display to query.
+287 If unspecified, all detected displays are queried
+288 max_tries: the maximum allowed number of attempts to
+289 read the VCP output from the display
+290
+291 Returns:
+292 See `BrightnessMethod.get_brightness`
+293 '''
+294 code = BYTE(0x10)
+295 values = []
+296 start = display if display is not None else 0
+297 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
+298 current = __cache__.get(f'vcp_brightness_{index}')
+299 if current is None:
+300 cur_out = DWORD()
+301 handle = HANDLE(monitor)
+302 for attempt in range(max_tries):
+303 if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+304 current = cur_out.value
+305 break
+306 current = None
+307 time.sleep(0.02 if attempt < 20 else 0.1)
+308 else:
+309 cls._logger.error(
+310 f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+311
+312 if current is not None:
+313 __cache__.store(
+314 f'vcp_brightness_{index}', current, expires=0.1)
+315 values.append(current)
+316
+317 if display == index:
+318 # if we have just got the display we wanted then exit here
+319 # no point iterating through all the other ones
+320 break
+321
+322 if 'handle' in locals():
+323 # make sure final handle is destroyed
+324 windll.dxva2.DestroyPhysicalMonitor(handle)
+325 return values
Returns:
328 @classmethod
-329 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
-330 '''
-331 Args:
-332 display: The specific display you wish to query.
-333 max_tries: the maximum allowed number of attempts to
-334 send the VCP input to the display
-335 '''
-336 __cache__.expire(startswith='vcp_brightness_')
-337 code = BYTE(0x10)
-338 value = DWORD(value)
-339 start = display if display is not None else 0
-340 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
-341 if display is None or display == index:
-342 handle = HANDLE(monitor)
-343 for attempt in range(max_tries):
-344 if windll.dxva2.SetVCPFeature(handle, code, value):
-345 break
-346 time.sleep(0.02 if attempt < 20 else 0.1)
-347 else:
-348 cls.logger.error(
-349 f'failed to set display:{index}->{value} after {attempt} tries')
-350
-351 if 'handle' in locals():
-352 # make sure final handle is destroyed
-353 windll.dxva2.DestroyPhysicalMonitor(handle)
+ 327 @classmethod
+328 def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+329 '''
+330 Args:
+331 display: The specific display you wish to query.
+332 max_tries: the maximum allowed number of attempts to
+333 send the VCP input to the display
+334 '''
+335 __cache__.expire(startswith='vcp_brightness_')
+336 code = BYTE(0x10)
+337 value_dword = DWORD(value)
+338 start = display if display is not None else 0
+339 for index, monitor in enumerate(cls.iter_physical_monitors(start=start), start=start):
+340 if display is None or display == index:
+341 handle = HANDLE(monitor)
+342 for attempt in range(max_tries):
+343 if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+344 break
+345 time.sleep(0.02 if attempt < 20 else 0.1)
+346 else:
+347 cls._logger.error(
+348 f'failed to set display:{index}->{value} after {attempt} tries')
+349
+350 if 'handle' in locals():
+351 # make sure final handle is destroyed
+352 windll.dxva2.DestroyPhysicalMonitor(handle)
Returns:
356def list_monitors_info(
-357 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
-358) -> List[dict]:
-359 '''
-360 Lists detailed information about all detected displays
-361
-362 Args:
-363 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
-364 for more info on available methods
-365 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
-366 unsupported: include detected displays that are invalid or unsupported.
-367 This argument does nothing on Windows
-368 '''
-369 # no caching here because get_display_info caches its results
-370 info = get_display_info()
-371
-372 all_methods = get_methods(method).values()
-373
-374 if method is not None:
-375 info = [i for i in info if i['method'] in all_methods]
-376
-377 if allow_duplicates:
-378 return info
-379
-380 try:
-381 # use filter_monitors to remove duplicates
-382 return filter_monitors(haystack=info)
-383 except NoValidDisplayError:
-384 return []
+ 355def list_monitors_info(
+356 method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+357) -> List[dict]:
+358 '''
+359 Lists detailed information about all detected displays
+360
+361 Args:
+362 method: the method the display can be addressed by. See `screen_brightness_control.get_methods`
+363 for more info on available methods
+364 allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+365 unsupported: include detected displays that are invalid or unsupported.
+366 This argument does nothing on Windows
+367 '''
+368 # no caching here because get_display_info caches its results
+369 info = get_display_info()
+370
+371 all_methods = get_methods(method).values()
+372
+373 if method is not None:
+374 info = [i for i in info if i['method'] in all_methods]
+375
+376 if allow_duplicates:
+377 return info
+378
+379 try:
+380 # use filter_monitors to remove duplicates
+381 return filter_monitors(haystack=info)
+382 except NoValidDisplayError:
+383 return []
Returns the current brightness of one or more displays
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the specific display to query
\n- method: the method to use to get the brightness. See
get_methods for\nmore info on available methods \n- verbose_error: controls the level of detail in the error messages
\n
\n\nReturns:
\n\n\n A list of IntPercentage values, each being the brightness of an\n individual display. Invalid displays may return None.
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# get the current screen brightness (for all detected displays)\ncurrent_brightness = sbc.get_brightness()\n\n# get the brightness of the primary display\nprimary_brightness = sbc.get_brightness(display=0)\n\n# get the brightness of the secondary display (if connected)\nsecondary_brightness = sbc.get_brightness(display=1)\n
\n
\n", "signature": "(\tdisplay: Union[str, int, NoneType] = None,\tmethod: Optional[str] = None,\tverbose_error: bool = False) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.set_brightness", "modulename": "screen_brightness_control", "qualname": "set_brightness", "kind": "function", "doc": "Sets the brightness level of one or more displays to a given value.
\n\nArguments:
\n\n\n- value (types.Percentage): the new brightness level
\n- display (types.DisplayIdentifier): the specific display to adjust
\n- method: the method to use to set the brightness. See
get_methods for\nmore info on available methods \n- force: [Linux Only] if False the brightness will never be set lower than 1.\nThis is because on most displays a brightness of 0 will turn off the backlight.\nIf True, this check is bypassed
\n- verbose_error: boolean value controls the amount of detail error messages will contain
\n- no_return: don't return the new brightness level(s)
\n
\n\nReturns:
\n\n\n If no_return is set to True (the default) then this function returns nothing.\n Otherwise, a list of types.IntPercentage is returned, each item being the new\n brightness of each adjusted display (invalid displays may return None)
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# set brightness to 50%\nsbc.set_brightness(50)\n\n# set brightness to 0%\nsbc.set_brightness(0, force=True)\n\n# increase brightness by 25%\nsbc.set_brightness('+25')\n\n# decrease brightness by 30%\nsbc.set_brightness('-30')\n\n# set the brightness of display 0 to 50%\nsbc.set_brightness(50, display=0)\n
\n
\n", "signature": "(\tvalue: Union[int, str],\tdisplay: Union[str, int, NoneType] = None,\tmethod: Optional[str] = None,\tforce: bool = False,\tverbose_error: bool = False,\tno_return: bool = True) -> Optional[List[int]]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.fade_brightness", "modulename": "screen_brightness_control", "qualname": "fade_brightness", "kind": "function", "doc": "Gradually change the brightness of one or more displays
\n\nArguments:
\n\n\n- finish (types.Percentage): fade to this brightness level
\n- start (types.Percentage): where the brightness should fade from.\nIf this arg is not specified, the fade will be started from the\ncurrent brightness.
\n- interval: the time delay between each step in brightness
\n- increment: the amount to change the brightness by per step
\n- blocking: whether this should occur in the main thread (
True) or a new daemonic thread (False) \n- force: [Linux Only] if False the brightness will never be set lower than 1.\nThis is because on most displays a brightness of 0 will turn off the backlight.\nIf True, this check is bypassed
\n- logarithmic: follow a logarithmic brightness curve when adjusting the brightness
\n- **kwargs: passed through to
filter_monitors for display selection.\nWill also be passed to get_brightness if blocking is True \n
\n\nReturns:
\n\n\n By default, this function calls get_brightness() to return the new\n brightness of any adjusted displays.
\n \n If the blocking is set to False, then a list of threads are\n returned, one for each display being faded.
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# fade brightness from the current brightness to 50%\nsbc.fade_brightness(50)\n\n# fade the brightness from 25% to 75%\nsbc.fade_brightness(75, start=25)\n\n# fade the brightness from the current value to 100% in steps of 10%\nsbc.fade_brightness(100, increment=10)\n\n# fade the brightness from 100% to 90% with time intervals of 0.1 seconds\nsbc.fade_brightness(90, start=100, interval=0.1)\n\n# fade the brightness to 100% in a new thread\nsbc.fade_brightness(100, blocking=False)\n
\n
\n", "signature": "(\tfinish: Union[int, str],\tstart: Union[str, int, NoneType] = None,\tinterval: float = 0.01,\tincrement: int = 1,\tblocking: bool = True,\tforce: bool = False,\tlogarithmic: bool = True,\t**kwargs) -> Union[List[threading.Thread], List[int]]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.list_monitors_info", "modulename": "screen_brightness_control", "qualname": "list_monitors_info", "kind": "function", "doc": "List detailed information about all displays that are controllable by this library
\n\nArguments:
\n\n\n- method: the method to use to list the available displays. See
get_methods for\nmore info on available methods \n- allow_duplicates: whether to filter out duplicate displays or not
\n- unsupported: include detected displays that are invalid or unsupported
\n
\n\nReturns:
\n\n\n list: list of dictionaries containing information about the detected displays
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\ndisplays = sbc.list_monitors_info()\nfor display in displays:\n print('=======================')\n # the manufacturer name plus the model\n print('Name:', display['name'])\n # the general model of the display\n print('Model:', display['model'])\n # the serial of the display\n print('Serial:', display['serial'])\n # the name of the brand of the display\n print('Manufacturer:', display['manufacturer'])\n # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ\n print('Manufacturer ID:', display['manufacturer_id'])\n # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES\n print('Index:', display['index'])\n # the method this display can be addressed by\n print('Method:', display['method'])\n # the EDID string associated with that display\n print('EDID:', display['edid'])\n
\n
\n", "signature": "(\tmethod: Optional[str] = None,\tallow_duplicates: bool = False,\tunsupported: bool = False) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.list_monitors", "modulename": "screen_brightness_control", "qualname": "list_monitors", "kind": "function", "doc": "List the names of all detected displays
\n\nArguments:
\n\n\n- method: the method to use to list the available displays. See
get_methods for\nmore info on available methods \n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\ndisplay_names = sbc.list_monitors()\n# eg: ['BenQ GL2450H', 'Dell U2211H']\n
\n
\n", "signature": "(method: Optional[str] = None) -> List[str]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.get_methods", "modulename": "screen_brightness_control", "qualname": "get_methods", "kind": "function", "doc": "Returns all available brightness method names and their associated classes.
\n\nArguments:
\n\n\n- name: if specified, return the method corresponding to this name
\n
\n\nRaises:
\n\n\n- ValueError: if the given name is incorrect
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\nall_methods = sbc.get_methods()\n\nfor method_name, method_class in all_methods.items():\n print('Method:', method_name)\n print('Class:', method_class)\n print('Associated monitors:', sbc.list_monitors(method=method_name))\n
\n
\n", "signature": "(\tname: str = None) -> Dict[str, screen_brightness_control.helpers.BrightnessMethod]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Display", "modulename": "screen_brightness_control", "qualname": "Display", "kind": "class", "doc": "Represents a single connected display.
\n"}, {"fullname": "screen_brightness_control.Display.__init__", "modulename": "screen_brightness_control", "qualname": "Display.__init__", "kind": "function", "doc": "\n", "signature": "(\tindex: int,\tmethod: screen_brightness_control.helpers.BrightnessMethod,\tedid: str = None,\tmanufacturer: str = None,\tmanufacturer_id: str = None,\tmodel: str = None,\tname: str = None,\tserial: str = None)"}, {"fullname": "screen_brightness_control.Display.index", "modulename": "screen_brightness_control", "qualname": "Display.index", "kind": "variable", "doc": "The index of the display relative to the method it uses.\nSo if the index is 0 and the method is windows.VCP, then this is the 1st\ndisplay reported by windows.VCP, not the first display overall.
\n", "annotation": ": int"}, {"fullname": "screen_brightness_control.Display.method", "modulename": "screen_brightness_control", "qualname": "Display.method", "kind": "variable", "doc": "The method by which this monitor can be addressed.\nThis will be a class from either the windows or linux sub-module
\n", "annotation": ": screen_brightness_control.helpers.BrightnessMethod"}, {"fullname": "screen_brightness_control.Display.edid", "modulename": "screen_brightness_control", "qualname": "Display.edid", "kind": "variable", "doc": "A 256 character hex string containing information about a display and its capabilities
\n", "annotation": ": str", "default_value": "None"}, {"fullname": "screen_brightness_control.Display.manufacturer", "modulename": "screen_brightness_control", "qualname": "Display.manufacturer", "kind": "variable", "doc": "Name of the display's manufacturer
\n", "annotation": ": str", "default_value": "None"}, {"fullname": "screen_brightness_control.Display.manufacturer_id", "modulename": "screen_brightness_control", "qualname": "Display.manufacturer_id", "kind": "variable", "doc": "3 letter code corresponding to the manufacturer name
\n", "annotation": ": str", "default_value": "None"}, {"fullname": "screen_brightness_control.Display.model", "modulename": "screen_brightness_control", "qualname": "Display.model", "kind": "variable", "doc": "Model name of the display
\n", "annotation": ": str", "default_value": "None"}, {"fullname": "screen_brightness_control.Display.name", "modulename": "screen_brightness_control", "qualname": "Display.name", "kind": "variable", "doc": "The name of the display, often the manufacturer name plus the model name
\n", "annotation": ": str", "default_value": "None"}, {"fullname": "screen_brightness_control.Display.serial", "modulename": "screen_brightness_control", "qualname": "Display.serial", "kind": "variable", "doc": "The serial number of the display or (if serial is not available) an ID assigned by the OS
\n", "annotation": ": str", "default_value": "None"}, {"fullname": "screen_brightness_control.Display.fade_brightness", "modulename": "screen_brightness_control", "qualname": "Display.fade_brightness", "kind": "function", "doc": "Gradually change the brightness of this display to a set value.\nThis works by incrementally changing the brightness until the desired\nvalue is reached.
\n\nArguments:
\n\n\n- finish (types.Percentage): the brightness level to end up on
\n- start (types.Percentage): where the fade should start from. Defaults\nto whatever the current brightness level for the display is
\n- interval: time delay between each change in brightness
\n- increment: amount to change the brightness by each time (as a percentage)
\n- force: [Linux only] allow the brightness to be set to 0. By default,\nbrightness values will never be set lower than 1, since setting them to 0\noften turns off the backlight
\n- logarithmic: follow a logarithmic curve when setting brightness values.\nSee
logarithmic_range for rationale \n
\n\nReturns:
\n\n\n The brightness of the display after the fade is complete.\n See types.IntPercentage
\n
\n", "signature": "(\tself,\tfinish: Union[int, str],\tstart: Union[str, int, NoneType] = None,\tinterval: float = 0.01,\tincrement: int = 1,\tforce: bool = False,\tlogarithmic: bool = True) -> int:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Display.from_dict", "modulename": "screen_brightness_control", "qualname": "Display.from_dict", "kind": "function", "doc": "Initialise an instance of the class from a dictionary, ignoring\nany unwanted keys
\n", "signature": "(cls, display: dict) -> screen_brightness_control.Display:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Display.get_brightness", "modulename": "screen_brightness_control", "qualname": "Display.get_brightness", "kind": "function", "doc": "Returns the brightness of this display.
\n\nReturns:
\n\n\n The brightness value of the display, as a percentage.\n See types.IntPercentage
\n
\n", "signature": "(self) -> int:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Display.get_identifier", "modulename": "screen_brightness_control", "qualname": "Display.get_identifier", "kind": "function", "doc": "Returns the types.DisplayIdentifier for this display.\nWill iterate through the EDID, serial, name and index and return the first\nvalue that is not equal to None
\n\nReturns:
\n\n\n The name of the property returned and the value of said property.\n EG: ('serial', '123abc...') or ('name', 'BenQ GL2450H')
\n
\n", "signature": "(self) -> Tuple[str, Union[int, str]]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Display.is_active", "modulename": "screen_brightness_control", "qualname": "Display.is_active", "kind": "function", "doc": "Attempts to retrieve the brightness for this display. If it works the display is deemed active
\n", "signature": "(self) -> bool:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Display.set_brightness", "modulename": "screen_brightness_control", "qualname": "Display.set_brightness", "kind": "function", "doc": "Sets the brightness for this display. See set_brightness for the full docs
\n\nArguments:
\n\n\n- value (types.Percentage): the brightness percentage to set the display to
\n- force: allow the brightness to be set to 0 on Linux. This is disabled by default\nbecause setting the brightness of 0 will often turn off the backlight
\n
\n", "signature": "(self, value: Union[int, str], force: bool = False):", "funcdef": "def"}, {"fullname": "screen_brightness_control.Monitor", "modulename": "screen_brightness_control", "qualname": "Monitor", "kind": "class", "doc": "Legacy class for managing displays.
\n\n\n\n
Deprecated
\n\n
Deprecated for removal in v0.23.0. Please use the new Display class instead
\n\n
Arguments:
\n\n\n- display (types.DisplayIdentifier or dict): the display you\nwish to control. Is passed to
filter_monitors\nto decide which display to use. \n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# create a class for the primary display and then a specifically named monitor\nprimary = sbc.Monitor(0)\nbenq_monitor = sbc.Monitor('BenQ GL2450H')\n\n# check if the benq monitor is the primary one\nif primary.serial == benq_monitor.serial:\n print('BenQ GL2450H is the primary display')\nelse:\n print('The primary display is', primary.name)\n\n# DEPRECATED BEHAVIOUR\n# Will be removed in v0.22.0\nprint(primary['name'])\nprint(benq_monitor['name'])\n
\n
\n", "signature": "(display: Union[int, str, dict])"}, {"fullname": "screen_brightness_control.Monitor.get_identifier", "modulename": "screen_brightness_control", "qualname": "Monitor.get_identifier", "kind": "function", "doc": "Returns the types.DisplayIdentifier for this display.\nWill iterate through the EDID, serial, name and index and return the first\nvalue that is not equal to None
\n\nArguments:
\n\n\n- monitor: extract an identifier from this dict instead of the monitor class
\n
\n\nReturns:
\n\n\n A tuple containing the name of the property returned and the value of said\n property. EG: ('serial', '123abc...') or ('name', 'BenQ GL2450H')
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\nprimary = sbc.Monitor(0)\nprint(primary.get_identifier()) # eg: ('serial', '123abc...')\n\nsecondary = sbc.list_monitors_info()[1]\nprint(primary.get_identifier(monitor=secondary)) # eg: ('serial', '456def...')\n\n# you can also use the class uninitialized\nprint(sbc.Monitor.get_identifier(secondary)) # eg: ('serial', '456def...')\n
\n
\n", "signature": "(self, monitor: dict = None) -> Tuple[str, Union[int, str]]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Monitor.set_brightness", "modulename": "screen_brightness_control", "qualname": "Monitor.set_brightness", "kind": "function", "doc": "Wrapper for Display.set_brightness
\n\nArguments:
\n\n\n- value: see
Display.set_brightness \n- no_return: do not return the new brightness after it has been set
\n- force: see
Display.set_brightness \n
\n", "signature": "(\tself,\tvalue: Union[int, str],\tno_return: bool = True,\tforce: bool = False) -> Optional[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Monitor.get_brightness", "modulename": "screen_brightness_control", "qualname": "Monitor.get_brightness", "kind": "function", "doc": "Returns the brightness of this display.
\n\nReturns:
\n\n\n The brightness value of the display, as a percentage.\n See types.IntPercentage
\n
\n", "signature": "(self) -> int:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Monitor.fade_brightness", "modulename": "screen_brightness_control", "qualname": "Monitor.fade_brightness", "kind": "function", "doc": "Wrapper for Display.fade_brightness
\n\nArguments:
\n\n\n- *args: see
Display.fade_brightness \n- blocking: run this function in the current thread and block until\nit completes. If
False, the fade will be run in a new daemonic\nthread, which will be started and returned \n- **kwargs: see
Display.fade_brightness \n
\n", "signature": "(\tself,\t*args,\tblocking: bool = True,\t**kwargs) -> Union[threading.Thread, int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Monitor.from_dict", "modulename": "screen_brightness_control", "qualname": "Monitor.from_dict", "kind": "function", "doc": "Initialise an instance of the class from a dictionary, ignoring\nany unwanted keys
\n", "signature": "(cls, display) -> screen_brightness_control.Monitor:", "funcdef": "def"}, {"fullname": "screen_brightness_control.Monitor.get_info", "modulename": "screen_brightness_control", "qualname": "Monitor.get_info", "kind": "function", "doc": "Returns all known information about this monitor instance
\n\nArguments:
\n\n\n- refresh: whether to refresh the information\nor to return the cached version
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# initialize class for primary display\nprimary = sbc.Monitor(0)\n# get the info\ninfo = primary.get_info()\n
\n
\n", "signature": "(self, refresh: bool = True) -> dict:", "funcdef": "def"}, {"fullname": "screen_brightness_control.filter_monitors", "modulename": "screen_brightness_control", "qualname": "filter_monitors", "kind": "function", "doc": "Searches through the information for all detected displays\nand attempts to return the info matching the value given.\nWill attempt to match against index, name, model, edid, method and serial
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the display you are searching for
\n- haystack: the information to filter from.\nIf this isn't set it defaults to the return of
list_monitors_info \n- method: the method the monitors use. See
get_methods for\nmore info on available methods \n- include: extra fields of information to sort by
\n
\n\nRaises:
\n\n\n- NoValidDisplayError: if the display does not have a match
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\nsearch = 'GL2450H'\nmatch = sbc.filter_displays(search)\nprint(match)\n# EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]\n
\n
\n", "signature": "(\tdisplay: Union[str, int, NoneType] = None,\thaystack: Optional[List[dict]] = None,\tmethod: Optional[str] = None,\tinclude: List[str] = []) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.exceptions", "modulename": "screen_brightness_control.exceptions", "kind": "module", "doc": "\n"}, {"fullname": "screen_brightness_control.exceptions.format_exc", "modulename": "screen_brightness_control.exceptions", "qualname": "format_exc", "kind": "function", "doc": "\n", "signature": "(e: Exception) -> str:", "funcdef": "def"}, {"fullname": "screen_brightness_control.exceptions.ScreenBrightnessError", "modulename": "screen_brightness_control.exceptions", "qualname": "ScreenBrightnessError", "kind": "class", "doc": "Generic error class designed to make catching errors under one umbrella easy.
\n", "bases": "builtins.Exception"}, {"fullname": "screen_brightness_control.exceptions.EDIDParseError", "modulename": "screen_brightness_control.exceptions", "qualname": "EDIDParseError", "kind": "class", "doc": "Generic error class designed to make catching errors under one umbrella easy.
\n", "bases": "ScreenBrightnessError"}, {"fullname": "screen_brightness_control.exceptions.NoValidDisplayError", "modulename": "screen_brightness_control.exceptions", "qualname": "NoValidDisplayError", "kind": "class", "doc": "Generic error class designed to make catching errors under one umbrella easy.
\n", "bases": "ScreenBrightnessError, builtins.LookupError"}, {"fullname": "screen_brightness_control.exceptions.I2CValidationError", "modulename": "screen_brightness_control.exceptions", "qualname": "I2CValidationError", "kind": "class", "doc": "Generic error class designed to make catching errors under one umbrella easy.
\n", "bases": "ScreenBrightnessError"}, {"fullname": "screen_brightness_control.exceptions.MaxRetriesExceededError", "modulename": "screen_brightness_control.exceptions", "qualname": "MaxRetriesExceededError", "kind": "class", "doc": "Generic error class designed to make catching errors under one umbrella easy.
\n", "bases": "ScreenBrightnessError, subprocess.CalledProcessError"}, {"fullname": "screen_brightness_control.helpers", "modulename": "screen_brightness_control.helpers", "kind": "module", "doc": "Helper functions for the library
\n"}, {"fullname": "screen_brightness_control.helpers.BrightnessMethod", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod", "kind": "class", "doc": "Helper class that provides a standard way to create an ABC using\ninheritance.
\n", "bases": "abc.ABC"}, {"fullname": "screen_brightness_control.helpers.BrightnessMethod.get_display_info", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.helpers.BrightnessMethod.get_brightness", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.helpers.BrightnessMethod.set_brightness", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, {"fullname": "screen_brightness_control.helpers.BrightnessMethodAdv", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethodAdv", "kind": "class", "doc": "Helper class that provides a standard way to create an ABC using\ninheritance.
\n", "bases": "BrightnessMethod"}, {"fullname": "screen_brightness_control.helpers.EDID", "modulename": "screen_brightness_control.helpers", "qualname": "EDID", "kind": "class", "doc": "Simple structure and method to extract display serial and name from an EDID string.
\n\nThe EDID parsing was created with inspiration from the pyedid library
\n"}, {"fullname": "screen_brightness_control.helpers.EDID.EDID_FORMAT", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.EDID_FORMAT", "kind": "variable", "doc": "The byte structure for EDID strings
\n", "annotation": ": str", "default_value": "'>8sHHIBBBBBBBBB10sHB16s18s18s18s18sBB'"}, {"fullname": "screen_brightness_control.helpers.EDID.parse", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.parse", "kind": "function", "doc": "Takes an EDID string and parses some relevant information from it according to the\nEDID 1.4\nspecification on Wikipedia.
\n\nArguments:
\n\n\n- edid (bytes or str): the EDID, can either be raw bytes or\na hex formatted string (00 ff ff ff ff...)
\n
\n\nReturns:
\n\n\n tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID,\n manufacturer, model, name, serial in that order.\n If any of these values are unable to be determined, they will be None.\n Otherwise, expect a string
\n
\n\nRaises:
\n\n\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\nedid = sbc.list_monitors_info()[0]['edid']\nmanufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)\n\nprint('Manufacturer:', manufacturer_id or 'Unknown')\nprint('Model:', model or 'Unknown')\nprint('Name:', name or 'Unknown')\n
\n
\n", "signature": "(cls, edid: Union[bytes, str]) -> Tuple[Optional[str], ...]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.helpers.EDID.hexdump", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.hexdump", "kind": "function", "doc": "Returns a hexadecimal string of binary data from a file
\n\nArguments:
\n\n\n- file (str): the file to read
\n
\n\nReturns:
\n\n\n str: one long hex string
\n
\n\nExample:
\n\n\n \n
from screen_brightness_control import EDID\n\nprint(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))\n# '00ffffffffffff00...'\n
\n
\n", "signature": "(file: str) -> str:", "funcdef": "def"}, {"fullname": "screen_brightness_control.helpers.check_output", "modulename": "screen_brightness_control.helpers", "qualname": "check_output", "kind": "function", "doc": "Run a command with retry management built in.
\n\nArguments:
\n\n\n- command: the command to run
\n- max_tries: the maximum number of retries to allow before raising an error
\n
\n\nReturns:
\n\n\n The output from the command
\n
\n", "signature": "(command: List[str], max_tries: int = 1) -> bytes:", "funcdef": "def"}, {"fullname": "screen_brightness_control.helpers.logarithmic_range", "modulename": "screen_brightness_control.helpers", "qualname": "logarithmic_range", "kind": "function", "doc": "A range-like function that yields a sequence of integers following\na logarithmic curve (y = 10 ^ (x / 50)) from start (inclusive) to\nstop (inclusive).
\n\nThis is useful because it skips many of the higher percentages in the\nsequence where single percent brightness changes are hard to notice.
\n\nThis function is designed to deal with brightness percentages, and so\nwill never return a value less than 0 or greater than 100.
\n\nArguments:
\n\n\n- start: the start of your percentage range
\n- stop: the end of your percentage range
\n- step: the increment per iteration through the sequence
\n
\n\nYields:
\n\n\n int
\n
\n", "signature": "(\tstart: int,\tstop: int,\tstep: int = 1) -> collections.abc.Generator[int, None, None]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.helpers.percentage", "modulename": "screen_brightness_control.helpers", "qualname": "percentage", "kind": "function", "doc": "Convenience function to convert a brightness value into a percentage. Can handle\nintegers, floats and strings. Also can handle relative strings (eg: '+10' or '-10')
\n\nArguments:
\n\n\n- value: the brightness value to convert
\n- current: the current brightness value or a function that returns the current brightness\nvalue. Used when dealing with relative brightness values
\n- lower_bound: the minimum value the brightness can be set to
\n
\n\nReturns:
\n\n\n The new brightness percentage, between lower_bound and 100
\n
\n", "signature": "(\tvalue: Union[int, str],\tcurrent: Union[int, Callable[[], int]] = None,\tlower_bound: int = 0) -> int:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux", "modulename": "screen_brightness_control.linux", "kind": "module", "doc": "\n"}, {"fullname": "screen_brightness_control.linux.SysFiles", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles", "kind": "class", "doc": "A way of getting display information and adjusting the brightness\nthat does not rely on any 3rd party software.
\n\nThis class works with displays that show up in the /sys/class/backlight\ndirectory (so usually laptop displays).
\n\nTo set the brightness, your user will need write permissions for\n/sys/class/backlight/*/brightness or you will need to run the program\nas root.
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, {"fullname": "screen_brightness_control.linux.SysFiles.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.SysFiles.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.SysFiles.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C", "modulename": "screen_brightness_control.linux", "qualname": "I2C", "kind": "class", "doc": "In the same spirit as SysFiles, this class serves as a way of getting\ndisplay information and adjusting the brightness without relying on any\n3rd party software.
\n\nUsage of this class requires read and write permission for /dev/i2c-*.
\n\nThis class works over the I2C bus, primarily with desktop monitors as I\nhaven't tested any e-DP displays yet.
\n\nMassive thanks to siemer for\nhis work on the ddcci.py project,\nwhich served as a my main reference for this.
\n\nReferences:
\n\n\n \n
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, {"fullname": "screen_brightness_control.linux.I2C.GET_VCP_CMD", "modulename": "screen_brightness_control.linux", "qualname": "I2C.GET_VCP_CMD", "kind": "variable", "doc": "VCP command to get the value of a feature (eg: brightness)
\n", "default_value": "1"}, {"fullname": "screen_brightness_control.linux.I2C.GET_VCP_REPLY", "modulename": "screen_brightness_control.linux", "qualname": "I2C.GET_VCP_REPLY", "kind": "variable", "doc": "VCP feature reply op code
\n", "default_value": "2"}, {"fullname": "screen_brightness_control.linux.I2C.SET_VCP_CMD", "modulename": "screen_brightness_control.linux", "qualname": "I2C.SET_VCP_CMD", "kind": "variable", "doc": "VCP command to set the value of a feature (eg: brightness)
\n", "default_value": "3"}, {"fullname": "screen_brightness_control.linux.I2C.DDCCI_ADDR", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCCI_ADDR", "kind": "variable", "doc": "DDC packets are transmittred using this I2C address
\n", "default_value": "55"}, {"fullname": "screen_brightness_control.linux.I2C.HOST_ADDR_R", "modulename": "screen_brightness_control.linux", "qualname": "I2C.HOST_ADDR_R", "kind": "variable", "doc": "Packet source address (the computer) when reading data
\n", "default_value": "80"}, {"fullname": "screen_brightness_control.linux.I2C.HOST_ADDR_W", "modulename": "screen_brightness_control.linux", "qualname": "I2C.HOST_ADDR_W", "kind": "variable", "doc": "Packet source address (the computer) when writing data
\n", "default_value": "81"}, {"fullname": "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DESTINATION_ADDR_W", "kind": "variable", "doc": "Packet destination address (the monitor) when writing data
\n", "default_value": "110"}, {"fullname": "screen_brightness_control.linux.I2C.I2C_SLAVE", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2C_SLAVE", "kind": "variable", "doc": "The I2C slave address
\n", "default_value": "1795"}, {"fullname": "screen_brightness_control.linux.I2C.WAIT_TIME", "modulename": "screen_brightness_control.linux", "qualname": "I2C.WAIT_TIME", "kind": "variable", "doc": "How long to wait between I2C commands
\n", "default_value": "0.05"}, {"fullname": "screen_brightness_control.linux.I2C.I2CDevice", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice", "kind": "class", "doc": "Class to read and write data to an I2C bus,\nbased on the I2CDev class from ddcci.py
\n"}, {"fullname": "screen_brightness_control.linux.I2C.I2CDevice.__init__", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice.__init__", "kind": "function", "doc": "Arguments:
\n\n\n- fname: the I2C path, eg:
/dev/i2c-2 \n- slave_addr: not entirely sure what this is meant to be
\n
\n", "signature": "(fname: str, slave_addr: int)"}, {"fullname": "screen_brightness_control.linux.I2C.I2CDevice.read", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice.read", "kind": "function", "doc": "Read a certain number of bytes from the I2C bus
\n\nArguments:
\n\n\n- length: the number of bytes to read
\n
\n\nReturns:
\n\n\n bytes
\n
\n", "signature": "(self, length: int) -> bytes:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.I2CDevice.write", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice.write", "kind": "function", "doc": "Writes data to the I2C bus
\n\nArguments:
\n\n\n- data: the data to write
\n
\n\nReturns:
\n\n\n The number of bytes written
\n
\n", "signature": "(self, data: bytes) -> int:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.DDCInterface", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface", "kind": "class", "doc": "Class to send DDC (Display Data Channel) commands to an I2C device,\nbased on the Ddcci and Mccs classes from ddcci.py
\n", "bases": "I2C.I2CDevice"}, {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.__init__", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.__init__", "kind": "function", "doc": "Arguments:
\n\n\n- i2c_path: the path to the I2C device, eg:
/dev/i2c-2 \n
\n", "signature": "(i2c_path: str)"}, {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.write", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.write", "kind": "function", "doc": "Write some data to the I2C device.
\n\nIt is recommended to use setvcp to set VCP values on the DDC device\ninstead of using this function directly.
\n\nArguments:
\n\n\n- *args: variable length list of arguments. This will be put\ninto a
bytearray and wrapped up in various flags and\nchecksums before being written to the I2C device \n
\n\nReturns:
\n\n\n The number of bytes that were written
\n
\n", "signature": "(self, *args) -> int:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.setvcp", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.setvcp", "kind": "function", "doc": "Set a VCP value on the device
\n\nArguments:
\n\n\n- vcp_code: the VCP command to send, eg:
0x10 is brightness \n- value: what to set the value to
\n
\n\nReturns:
\n\n\n The number of bytes written to the device
\n
\n", "signature": "(self, vcp_code: int, value: int) -> int:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.read", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.read", "kind": "function", "doc": "Reads data from the DDC device.
\n\nIt is recommended to use getvcp to retrieve VCP values from the\nDDC device instead of using this function directly.
\n\nArguments:
\n\n\n- amount: the number of bytes to read
\n
\n\nRaises:
\n\n\n- ValueError: if the read data is deemed invalid
\n
\n", "signature": "(self, amount: int) -> bytes:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.getvcp", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.getvcp", "kind": "function", "doc": "Retrieves a VCP value from the DDC device.
\n\nArguments:
\n\n\n- vcp_code: the VCP value to read, eg:
0x10 is brightness \n
\n\nReturns:
\n\n\n The current and maximum value respectively
\n
\n\nRaises:
\n\n\n- ValueError: if the read data is deemed invalid
\n
\n", "signature": "(self, vcp_code: int) -> Tuple[int, int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "I2C.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "I2C.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.I2C.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "I2C.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.Light", "modulename": "screen_brightness_control.linux", "qualname": "Light", "kind": "class", "doc": "Wraps around light, an external\n3rd party tool that can control brightness levels for e-DP displays.
\n\n\n\n
As of April 2nd 2023, the official repository for the light project has\nbeen archived and\nwill no longer receive any updates unless another maintainer picks it\nup.
\n\n
the light executable to be called
\n", "annotation": ": str", "default_value": "'light'"}, {"fullname": "screen_brightness_control.linux.Light.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "Light.get_display_info", "kind": "function", "doc": "Implements BrightnessMethod.get_display_info.
\n\nWorks by taking the output of SysFiles.get_display_info and\nfiltering out any displays that aren't supported by Light
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.Light.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "Light.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.Light.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "Light.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.XRandr", "modulename": "screen_brightness_control.linux", "qualname": "XRandr", "kind": "class", "doc": "collection of screen brightness related methods using the xrandr executable
\n", "bases": "screen_brightness_control.helpers.BrightnessMethodAdv"}, {"fullname": "screen_brightness_control.linux.XRandr.executable", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.executable", "kind": "variable", "doc": "the xrandr executable to be called
\n", "annotation": ": str", "default_value": "'xrandr'"}, {"fullname": "screen_brightness_control.linux.XRandr.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.get_display_info", "kind": "function", "doc": "Implements BrightnessMethod.get_display_info.
\n\nArguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n- brightness: whether to include the current brightness\nin the returned info
\n
\n", "signature": "(\tcls,\tdisplay: Union[str, int, NoneType] = None,\tbrightness: bool = False) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.XRandr.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.XRandr.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.DDCUtil", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil", "kind": "class", "doc": "collection of screen brightness related methods using the ddcutil executable
\n", "bases": "screen_brightness_control.helpers.BrightnessMethodAdv"}, {"fullname": "screen_brightness_control.linux.DDCUtil.executable", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.executable", "kind": "variable", "doc": "the ddcutil executable to be called
\n", "annotation": ": str", "default_value": "'ddcutil'"}, {"fullname": "screen_brightness_control.linux.DDCUtil.sleep_multiplier", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.sleep_multiplier", "kind": "variable", "doc": "how long ddcutil should sleep between each DDC request (lower is shorter).\nSee the ddcutil docs for more info.
\n", "annotation": ": float", "default_value": "0.5"}, {"fullname": "screen_brightness_control.linux.DDCUtil.cmd_max_tries", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.cmd_max_tries", "kind": "variable", "doc": "max number of retries when calling the ddcutil
\n", "annotation": ": int", "default_value": "10"}, {"fullname": "screen_brightness_control.linux.DDCUtil.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.DDCUtil.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.DDCUtil.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, {"fullname": "screen_brightness_control.linux.list_monitors_info", "modulename": "screen_brightness_control.linux", "qualname": "list_monitors_info", "kind": "function", "doc": "Lists detailed information about all detected displays
\n\nArguments:
\n\n\n- method: the method the display can be addressed by. See
screen_brightness_control.get_methods\nfor more info on available methods \n- allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
\n- unsupported: include detected displays that are invalid or unsupported
\n
\n", "signature": "(\tmethod: Optional[str] = None,\tallow_duplicates: bool = False,\tunsupported: bool = False) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.types", "modulename": "screen_brightness_control.types", "kind": "module", "doc": "Submodule containing types and type aliases used throughout the library.
\n\nSplitting these definitions into a seperate submodule allows for detailed\nexplanations and verbose type definitions, without cluttering up the rest\nof the library.
\n\nThis file is also useful for wrangling types based on the current Python\nversion.
\n"}, {"fullname": "screen_brightness_control.types.IntPercentage", "modulename": "screen_brightness_control.types", "qualname": "IntPercentage", "kind": "variable", "doc": "An integer between 0 and 100 (inclusive) that represents a brightness level.\nOther than the implied bounds, this is just a normal integer.
\n", "default_value": "<class 'int'>"}, {"fullname": "screen_brightness_control.types.Percentage", "modulename": "screen_brightness_control.types", "qualname": "Percentage", "kind": "variable", "doc": "An IntPercentage or a string representing an IntPercentage.
\n\nString values may come in two forms:
\n\n\n- Absolute values: for example
'40' converts directly to int('40') \n- Relative values: strings prefixed with
+/- will be interpreted relative to the\ncurrent brightness level. In this case, the integer value of your string will be added to the\ncurrent brightness level.\nFor example, if the current brightness is 50%, a value of '+40' would imply 90% brightness\nand a value of '-40' would imply 10% brightness. \n
\n\nRelative brightness values will usually be resolved by the helpers.percentage function.
\n", "default_value": "typing.Union[int, str]"}, {"fullname": "screen_brightness_control.types.DisplayIdentifier", "modulename": "screen_brightness_control.types", "qualname": "DisplayIdentifier", "kind": "variable", "doc": "Something that can be used to identify a particular display.\nCan be any one of the following properties of a display:
\n\n\n\n\n\nSee Display for descriptions of each property and its type
\n", "default_value": "typing.Union[int, str]"}, {"fullname": "screen_brightness_control.windows", "modulename": "screen_brightness_control.windows", "kind": "module", "doc": "\n"}, {"fullname": "screen_brightness_control.windows.enum_display_devices", "modulename": "screen_brightness_control.windows", "qualname": "enum_display_devices", "kind": "function", "doc": "Yields all display devices connected to the computer
\n", "signature": "() -> collections.abc.Generator[win32api.PyDISPLAY_DEVICEType, None, None]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.get_display_info", "modulename": "screen_brightness_control.windows", "qualname": "get_display_info", "kind": "function", "doc": "Gets information about all connected displays using WMI and win32api
\n\nExample:
\n\n\n \n
import screen_brightness_control as s\n\ninfo = s.windows.get_display_info()\nfor display in info:\n print(display['name'])\n
\n
\n", "signature": "() -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.WMI", "modulename": "screen_brightness_control.windows", "qualname": "WMI", "kind": "class", "doc": "A collection of screen brightness related methods using the WMI API.\nThis class primarily works with laptop displays.
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, {"fullname": "screen_brightness_control.windows.WMI.get_display_info", "modulename": "screen_brightness_control.windows", "qualname": "WMI.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.WMI.set_brightness", "modulename": "screen_brightness_control.windows", "qualname": "WMI.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.WMI.get_brightness", "modulename": "screen_brightness_control.windows", "qualname": "WMI.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.VCP", "modulename": "screen_brightness_control.windows", "qualname": "VCP", "kind": "class", "doc": "Collection of screen brightness related methods using the DDC/CI commands
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, {"fullname": "screen_brightness_control.windows.VCP.iter_physical_monitors", "modulename": "screen_brightness_control.windows", "qualname": "VCP.iter_physical_monitors", "kind": "function", "doc": "A generator to iterate through all physical monitors\nand then close them again afterwards, yielding their handles.\nIt is not recommended to use this function unless you are familiar with ctypes and windll
\n\nArguments:
\n\n\n- start: skip the first X handles
\n
\n\nRaises:
\n\n\n- ctypes.WinError: upon failure to enumerate through the monitors
\n
\n", "signature": "(\tcls,\tstart: int = 0) -> collections.abc.Generator[wintypes.HANDLE, None, None]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.VCP.get_display_info", "modulename": "screen_brightness_control.windows", "qualname": "VCP.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.VCP.get_brightness", "modulename": "screen_brightness_control.windows", "qualname": "VCP.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n- max_tries: the maximum allowed number of attempts to\nread the VCP output from the display
\n
\n\nReturns:
\n\n\n See BrightnessMethod.get_brightness
\n
\n", "signature": "(cls, display: Optional[int] = None, max_tries: int = 50) -> List[int]:", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.VCP.set_brightness", "modulename": "screen_brightness_control.windows", "qualname": "VCP.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: The specific display you wish to query.
\n- max_tries: the maximum allowed number of attempts to\nsend the VCP input to the display
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None, max_tries: int = 50):", "funcdef": "def"}, {"fullname": "screen_brightness_control.windows.list_monitors_info", "modulename": "screen_brightness_control.windows", "qualname": "list_monitors_info", "kind": "function", "doc": "Lists detailed information about all detected displays
\n\nArguments:
\n\n\n- method: the method the display can be addressed by. See
screen_brightness_control.get_methods\nfor more info on available methods \n- allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
\n- unsupported: include detected displays that are invalid or unsupported.\nThis argument does nothing on Windows
\n
\n", "signature": "(\tmethod: Optional[str] = None,\tallow_duplicates: bool = False,\tunsupported: bool = False) -> List[dict]:", "funcdef": "def"}];
+ /** pdoc search index */const docs = {"version": "0.9.5", "fields": ["qualname", "fullname", "annotation", "default_value", "signature", "bases", "doc"], "ref": "fullname", "documentStore": {"docs": {"screen_brightness_control": {"fullname": "screen_brightness_control", "modulename": "screen_brightness_control", "kind": "module", "doc": "\n"}, "screen_brightness_control.get_brightness": {"fullname": "screen_brightness_control.get_brightness", "modulename": "screen_brightness_control", "qualname": "get_brightness", "kind": "function", "doc": "Returns the current brightness of one or more displays
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the specific display to query
\n- method: the method to use to get the brightness. See
get_methods for\nmore info on available methods \n- verbose_error: controls the level of detail in the error messages
\n
\n\nReturns:
\n\n\n A list of IntPercentage values, each being the brightness of an\n individual display. Invalid displays may return None.
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# get the current screen brightness (for all detected displays)\ncurrent_brightness = sbc.get_brightness()\n\n# get the brightness of the primary display\nprimary_brightness = sbc.get_brightness(display=0)\n\n# get the brightness of the secondary display (if connected)\nsecondary_brightness = sbc.get_brightness(display=1)\n
\n
\n", "signature": "(\tdisplay: Union[str, int, NoneType] = None,\tmethod: Optional[str] = None,\tverbose_error: bool = False) -> List[Optional[int]]:", "funcdef": "def"}, "screen_brightness_control.set_brightness": {"fullname": "screen_brightness_control.set_brightness", "modulename": "screen_brightness_control", "qualname": "set_brightness", "kind": "function", "doc": "Sets the brightness level of one or more displays to a given value.
\n\nArguments:
\n\n\n- value (.types.Percentage): the new brightness level
\n- display (.types.DisplayIdentifier): the specific display to adjust
\n- method: the method to use to set the brightness. See
get_methods for\nmore info on available methods \n- force: [Linux Only] if False the brightness will never be set lower than 1.\nThis is because on most displays a brightness of 0 will turn off the backlight.\nIf True, this check is bypassed
\n- verbose_error: boolean value controls the amount of detail error messages will contain
\n- no_return: don't return the new brightness level(s)
\n
\n\nReturns:
\n\n\n If no_return is set to True (the default) then this function returns nothing.\n Otherwise, a list of .types.IntPercentage is returned, each item being the new\n brightness of each adjusted display (invalid displays may return None)
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# set brightness to 50%\nsbc.set_brightness(50)\n\n# set brightness to 0%\nsbc.set_brightness(0, force=True)\n\n# increase brightness by 25%\nsbc.set_brightness('+25')\n\n# decrease brightness by 30%\nsbc.set_brightness('-30')\n\n# set the brightness of display 0 to 50%\nsbc.set_brightness(50, display=0)\n
\n
\n", "signature": "(\tvalue: Union[int, str],\tdisplay: Union[str, int, NoneType] = None,\tmethod: Optional[str] = None,\tforce: bool = False,\tverbose_error: bool = False,\tno_return: bool = True) -> Optional[List[Optional[int]]]:", "funcdef": "def"}, "screen_brightness_control.fade_brightness": {"fullname": "screen_brightness_control.fade_brightness", "modulename": "screen_brightness_control", "qualname": "fade_brightness", "kind": "function", "doc": "Gradually change the brightness of one or more displays
\n\nArguments:
\n\n\n- finish (.types.Percentage): fade to this brightness level
\n- start (.types.Percentage): where the brightness should fade from.\nIf this arg is not specified, the fade will be started from the\ncurrent brightness.
\n- interval: the time delay between each step in brightness
\n- increment: the amount to change the brightness by per step
\n- blocking: whether this should occur in the main thread (
True) or a new daemonic thread (False) \n- force: [Linux Only] if False the brightness will never be set lower than 1.\nThis is because on most displays a brightness of 0 will turn off the backlight.\nIf True, this check is bypassed
\n- logarithmic: follow a logarithmic brightness curve when adjusting the brightness
\n- **kwargs: passed through to
filter_monitors for display selection.\nWill also be passed to get_brightness if blocking is True \n
\n\nReturns:
\n\n\n By default, this function calls get_brightness() to return the new\n brightness of any adjusted displays.
\n \n If the blocking is set to False, then a list of threads are\n returned, one for each display being faded.
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# fade brightness from the current brightness to 50%\nsbc.fade_brightness(50)\n\n# fade the brightness from 25% to 75%\nsbc.fade_brightness(75, start=25)\n\n# fade the brightness from the current value to 100% in steps of 10%\nsbc.fade_brightness(100, increment=10)\n\n# fade the brightness from 100% to 90% with time intervals of 0.1 seconds\nsbc.fade_brightness(90, start=100, interval=0.1)\n\n# fade the brightness to 100% in a new thread\nsbc.fade_brightness(100, blocking=False)\n
\n
\n", "signature": "(\tfinish: Union[int, str],\tstart: Union[str, int, NoneType] = None,\tinterval: float = 0.01,\tincrement: int = 1,\tblocking: bool = True,\tforce: bool = False,\tlogarithmic: bool = True,\t**kwargs) -> Union[List[threading.Thread], List[Optional[int]]]:", "funcdef": "def"}, "screen_brightness_control.list_monitors_info": {"fullname": "screen_brightness_control.list_monitors_info", "modulename": "screen_brightness_control", "qualname": "list_monitors_info", "kind": "function", "doc": "List detailed information about all displays that are controllable by this library
\n\nArguments:
\n\n\n- method: the method to use to list the available displays. See
get_methods for\nmore info on available methods \n- allow_duplicates: whether to filter out duplicate displays or not
\n- unsupported: include detected displays that are invalid or unsupported
\n
\n\nReturns:
\n\n\n list: list of dictionaries containing information about the detected displays
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\ndisplays = sbc.list_monitors_info()\nfor display in displays:\n print('=======================')\n # the manufacturer name plus the model\n print('Name:', display['name'])\n # the general model of the display\n print('Model:', display['model'])\n # the serial of the display\n print('Serial:', display['serial'])\n # the name of the brand of the display\n print('Manufacturer:', display['manufacturer'])\n # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ\n print('Manufacturer ID:', display['manufacturer_id'])\n # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES\n print('Index:', display['index'])\n # the method this display can be addressed by\n print('Method:', display['method'])\n # the EDID string associated with that display\n print('EDID:', display['edid'])\n
\n
\n", "signature": "(\tmethod: Optional[str] = None,\tallow_duplicates: bool = False,\tunsupported: bool = False) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.list_monitors": {"fullname": "screen_brightness_control.list_monitors", "modulename": "screen_brightness_control", "qualname": "list_monitors", "kind": "function", "doc": "List the names of all detected displays
\n\nArguments:
\n\n\n- method: the method to use to list the available displays. See
get_methods for\nmore info on available methods \n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\ndisplay_names = sbc.list_monitors()\n# eg: ['BenQ GL2450H', 'Dell U2211H']\n
\n
\n", "signature": "(method: Optional[str] = None) -> List[str]:", "funcdef": "def"}, "screen_brightness_control.get_methods": {"fullname": "screen_brightness_control.get_methods", "modulename": "screen_brightness_control", "qualname": "get_methods", "kind": "function", "doc": "Returns all available brightness method names and their associated classes.
\n\nArguments:
\n\n\n- name: if specified, return the method corresponding to this name
\n
\n\nRaises:
\n\n\n- ValueError: if the given name is incorrect
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\nall_methods = sbc.get_methods()\n\nfor method_name, method_class in all_methods.items():\n print('Method:', method_name)\n print('Class:', method_class)\n print('Associated monitors:', sbc.list_monitors(method=method_name))\n
\n
\n", "signature": "(\tname: Optional[str] = None) -> Dict[str, Type[screen_brightness_control.helpers.BrightnessMethod]]:", "funcdef": "def"}, "screen_brightness_control.Display": {"fullname": "screen_brightness_control.Display", "modulename": "screen_brightness_control", "qualname": "Display", "kind": "class", "doc": "Represents a single connected display.
\n"}, "screen_brightness_control.Display.__init__": {"fullname": "screen_brightness_control.Display.__init__", "modulename": "screen_brightness_control", "qualname": "Display.__init__", "kind": "function", "doc": "\n", "signature": "(\tindex: int,\tmethod: Type[screen_brightness_control.helpers.BrightnessMethod],\tedid: Optional[str] = None,\tmanufacturer: Optional[str] = None,\tmanufacturer_id: Optional[str] = None,\tmodel: Optional[str] = None,\tname: Optional[str] = None,\tserial: Optional[str] = None)"}, "screen_brightness_control.Display.index": {"fullname": "screen_brightness_control.Display.index", "modulename": "screen_brightness_control", "qualname": "Display.index", "kind": "variable", "doc": "The index of the display relative to the method it uses.\nSo if the index is 0 and the method is windows.VCP, then this is the 1st\ndisplay reported by windows.VCP, not the first display overall.
\n", "annotation": ": int"}, "screen_brightness_control.Display.method": {"fullname": "screen_brightness_control.Display.method", "modulename": "screen_brightness_control", "qualname": "Display.method", "kind": "variable", "doc": "The method by which this monitor can be addressed.\nThis will be a class from either the windows or linux sub-module
\n", "annotation": ": Type[screen_brightness_control.helpers.BrightnessMethod]"}, "screen_brightness_control.Display.edid": {"fullname": "screen_brightness_control.Display.edid", "modulename": "screen_brightness_control", "qualname": "Display.edid", "kind": "variable", "doc": "A 256 character hex string containing information about a display and its capabilities
\n", "annotation": ": Optional[str]", "default_value": "None"}, "screen_brightness_control.Display.manufacturer": {"fullname": "screen_brightness_control.Display.manufacturer", "modulename": "screen_brightness_control", "qualname": "Display.manufacturer", "kind": "variable", "doc": "Name of the display's manufacturer
\n", "annotation": ": Optional[str]", "default_value": "None"}, "screen_brightness_control.Display.manufacturer_id": {"fullname": "screen_brightness_control.Display.manufacturer_id", "modulename": "screen_brightness_control", "qualname": "Display.manufacturer_id", "kind": "variable", "doc": "3 letter code corresponding to the manufacturer name
\n", "annotation": ": Optional[str]", "default_value": "None"}, "screen_brightness_control.Display.model": {"fullname": "screen_brightness_control.Display.model", "modulename": "screen_brightness_control", "qualname": "Display.model", "kind": "variable", "doc": "Model name of the display
\n", "annotation": ": Optional[str]", "default_value": "None"}, "screen_brightness_control.Display.name": {"fullname": "screen_brightness_control.Display.name", "modulename": "screen_brightness_control", "qualname": "Display.name", "kind": "variable", "doc": "The name of the display, often the manufacturer name plus the model name
\n", "annotation": ": Optional[str]", "default_value": "None"}, "screen_brightness_control.Display.serial": {"fullname": "screen_brightness_control.Display.serial", "modulename": "screen_brightness_control", "qualname": "Display.serial", "kind": "variable", "doc": "The serial number of the display or (if serial is not available) an ID assigned by the OS
\n", "annotation": ": Optional[str]", "default_value": "None"}, "screen_brightness_control.Display.fade_brightness": {"fullname": "screen_brightness_control.Display.fade_brightness", "modulename": "screen_brightness_control", "qualname": "Display.fade_brightness", "kind": "function", "doc": "Gradually change the brightness of this display to a set value.\nThis works by incrementally changing the brightness until the desired\nvalue is reached.
\n\nArguments:
\n\n\n- finish (.types.Percentage): the brightness level to end up on
\n- start (.types.Percentage): where the fade should start from. Defaults\nto whatever the current brightness level for the display is
\n- interval: time delay between each change in brightness
\n- increment: amount to change the brightness by each time (as a percentage)
\n- force: [Linux only] allow the brightness to be set to 0. By default,\nbrightness values will never be set lower than 1, since setting them to 0\noften turns off the backlight
\n- logarithmic: follow a logarithmic curve when setting brightness values.\nSee
logarithmic_range for rationale \n
\n\nReturns:
\n\n\n The brightness of the display after the fade is complete.\n See .types.IntPercentage
\n \n \n \n
Deprecated
\n \n
This function will return None in v0.23.0 and later.
\n \n
\n", "signature": "(\tself,\tfinish: Union[int, str],\tstart: Union[str, int, NoneType] = None,\tinterval: float = 0.01,\tincrement: int = 1,\tforce: bool = False,\tlogarithmic: bool = True) -> int:", "funcdef": "def"}, "screen_brightness_control.Display.from_dict": {"fullname": "screen_brightness_control.Display.from_dict", "modulename": "screen_brightness_control", "qualname": "Display.from_dict", "kind": "function", "doc": "Initialise an instance of the class from a dictionary, ignoring\nany unwanted keys
\n", "signature": "(cls, display: dict) -> screen_brightness_control.Display:", "funcdef": "def"}, "screen_brightness_control.Display.get_brightness": {"fullname": "screen_brightness_control.Display.get_brightness", "modulename": "screen_brightness_control", "qualname": "Display.get_brightness", "kind": "function", "doc": "Returns the brightness of this display.
\n\nReturns:
\n\n\n The brightness value of the display, as a percentage.\n See .types.IntPercentage
\n
\n", "signature": "(self) -> int:", "funcdef": "def"}, "screen_brightness_control.Display.get_identifier": {"fullname": "screen_brightness_control.Display.get_identifier", "modulename": "screen_brightness_control", "qualname": "Display.get_identifier", "kind": "function", "doc": "Returns the .types.DisplayIdentifier for this display.\nWill iterate through the EDID, serial, name and index and return the first\nvalue that is not equal to None
\n\nReturns:
\n\n\n The name of the property returned and the value of said property.\n EG: ('serial', '123abc...') or ('name', 'BenQ GL2450H')
\n
\n", "signature": "(self) -> Tuple[str, Union[int, str]]:", "funcdef": "def"}, "screen_brightness_control.Display.is_active": {"fullname": "screen_brightness_control.Display.is_active", "modulename": "screen_brightness_control", "qualname": "Display.is_active", "kind": "function", "doc": "Attempts to retrieve the brightness for this display. If it works the display is deemed active
\n", "signature": "(self) -> bool:", "funcdef": "def"}, "screen_brightness_control.Display.set_brightness": {"fullname": "screen_brightness_control.Display.set_brightness", "modulename": "screen_brightness_control", "qualname": "Display.set_brightness", "kind": "function", "doc": "Sets the brightness for this display. See set_brightness for the full docs
\n\nArguments:
\n\n\n- value (.types.Percentage): the brightness percentage to set the display to
\n- force: allow the brightness to be set to 0 on Linux. This is disabled by default\nbecause setting the brightness of 0 will often turn off the backlight
\n
\n", "signature": "(self, value: Union[int, str], force: bool = False):", "funcdef": "def"}, "screen_brightness_control.Monitor": {"fullname": "screen_brightness_control.Monitor", "modulename": "screen_brightness_control", "qualname": "Monitor", "kind": "class", "doc": "Legacy class for managing displays.
\n\n\n\n
Deprecated
\n\n
Deprecated for removal in v0.23.0. Please use the new Display class instead
\n\n
Arguments:
\n\n\n- display (.types.DisplayIdentifier or dict): the display you\nwish to control. Is passed to
filter_monitors\nto decide which display to use. \n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# create a class for the primary display and then a specifically named monitor\nprimary = sbc.Monitor(0)\nbenq_monitor = sbc.Monitor('BenQ GL2450H')\n\n# check if the benq monitor is the primary one\nif primary.serial == benq_monitor.serial:\n print('BenQ GL2450H is the primary display')\nelse:\n print('The primary display is', primary.name)\n
\n
\n", "signature": "(display: Union[int, str, dict])"}, "screen_brightness_control.Monitor.get_identifier": {"fullname": "screen_brightness_control.Monitor.get_identifier", "modulename": "screen_brightness_control", "qualname": "Monitor.get_identifier", "kind": "function", "doc": "Returns the .types.DisplayIdentifier for this display.\nWill iterate through the EDID, serial, name and index and return the first\nvalue that is not equal to None
\n\nArguments:
\n\n\n- monitor: extract an identifier from this dict instead of the monitor class
\n
\n\nReturns:
\n\n\n A tuple containing the name of the property returned and the value of said\n property. EG: ('serial', '123abc...') or ('name', 'BenQ GL2450H')
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\nprimary = sbc.Monitor(0)\nprint(primary.get_identifier()) # eg: ('serial', '123abc...')\n\nsecondary = sbc.list_monitors_info()[1]\nprint(primary.get_identifier(monitor=secondary)) # eg: ('serial', '456def...')\n\n# you can also use the class uninitialized\nprint(sbc.Monitor.get_identifier(secondary)) # eg: ('serial', '456def...')\n
\n
\n", "signature": "(self, monitor: Optional[dict] = None) -> Tuple[str, Union[int, str]]:", "funcdef": "def"}, "screen_brightness_control.Monitor.set_brightness": {"fullname": "screen_brightness_control.Monitor.set_brightness", "modulename": "screen_brightness_control", "qualname": "Monitor.set_brightness", "kind": "function", "doc": "Wrapper for Display.set_brightness
\n\nArguments:
\n\n\n- value: see
Display.set_brightness \n- no_return: do not return the new brightness after it has been set
\n- force: see
Display.set_brightness \n
\n", "signature": "(\tself,\tvalue: Union[int, str],\tno_return: bool = True,\tforce: bool = False) -> Optional[int]:", "funcdef": "def"}, "screen_brightness_control.Monitor.get_brightness": {"fullname": "screen_brightness_control.Monitor.get_brightness", "modulename": "screen_brightness_control", "qualname": "Monitor.get_brightness", "kind": "function", "doc": "Returns the brightness of this display.
\n\nReturns:
\n\n\n The brightness value of the display, as a percentage.\n See .types.IntPercentage
\n
\n", "signature": "(self) -> int:", "funcdef": "def"}, "screen_brightness_control.Monitor.fade_brightness": {"fullname": "screen_brightness_control.Monitor.fade_brightness", "modulename": "screen_brightness_control", "qualname": "Monitor.fade_brightness", "kind": "function", "doc": "Wrapper for Display.fade_brightness
\n\nArguments:
\n\n\n- *args: see
Display.fade_brightness \n- blocking: run this function in the current thread and block until\nit completes. If
False, the fade will be run in a new daemonic\nthread, which will be started and returned \n- **kwargs: see
Display.fade_brightness \n
\n", "signature": "(\tself,\t*args,\tblocking: bool = True,\t**kwargs) -> Union[threading.Thread, int]:", "funcdef": "def"}, "screen_brightness_control.Monitor.from_dict": {"fullname": "screen_brightness_control.Monitor.from_dict", "modulename": "screen_brightness_control", "qualname": "Monitor.from_dict", "kind": "function", "doc": "Initialise an instance of the class from a dictionary, ignoring\nany unwanted keys
\n", "signature": "(cls, display) -> screen_brightness_control.Monitor:", "funcdef": "def"}, "screen_brightness_control.Monitor.get_info": {"fullname": "screen_brightness_control.Monitor.get_info", "modulename": "screen_brightness_control", "qualname": "Monitor.get_info", "kind": "function", "doc": "Returns all known information about this monitor instance
\n\nArguments:
\n\n\n- refresh: whether to refresh the information\nor to return the cached version
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\n# initialize class for primary display\nprimary = sbc.Monitor(0)\n# get the info\ninfo = primary.get_info()\n
\n
\n", "signature": "(self, refresh: bool = True) -> dict:", "funcdef": "def"}, "screen_brightness_control.filter_monitors": {"fullname": "screen_brightness_control.filter_monitors", "modulename": "screen_brightness_control", "qualname": "filter_monitors", "kind": "function", "doc": "Searches through the information for all detected displays\nand attempts to return the info matching the value given.\nWill attempt to match against index, name, edid, method and serial
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the display you are searching for
\n- haystack: the information to filter from.\nIf this isn't set it defaults to the return of
list_monitors_info \n- method: the method the monitors use. See
get_methods for\nmore info on available methods \n- include: extra fields of information to sort by
\n
\n\nRaises:
\n\n\n- NoValidDisplayError: if the display does not have a match
\n
\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\nsearch = 'GL2450H'\nmatch = sbc.filter_displays(search)\nprint(match)\n# EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]\n
\n
\n", "signature": "(\tdisplay: Union[str, int, NoneType] = None,\thaystack: Optional[List[dict]] = None,\tmethod: Optional[str] = None,\tinclude: List[str] = []) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.exceptions": {"fullname": "screen_brightness_control.exceptions", "modulename": "screen_brightness_control.exceptions", "kind": "module", "doc": "\n"}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"fullname": "screen_brightness_control.exceptions.ScreenBrightnessError", "modulename": "screen_brightness_control.exceptions", "qualname": "ScreenBrightnessError", "kind": "class", "doc": "Generic error class designed to make catching errors under one umbrella easy.
\n", "bases": "builtins.Exception"}, "screen_brightness_control.exceptions.EDIDParseError": {"fullname": "screen_brightness_control.exceptions.EDIDParseError", "modulename": "screen_brightness_control.exceptions", "qualname": "EDIDParseError", "kind": "class", "doc": "Unparsable/invalid EDID
\n", "bases": "ScreenBrightnessError"}, "screen_brightness_control.exceptions.NoValidDisplayError": {"fullname": "screen_brightness_control.exceptions.NoValidDisplayError", "modulename": "screen_brightness_control.exceptions", "qualname": "NoValidDisplayError", "kind": "class", "doc": "Could not find a valid display
\n", "bases": "ScreenBrightnessError, builtins.LookupError"}, "screen_brightness_control.exceptions.I2CValidationError": {"fullname": "screen_brightness_control.exceptions.I2CValidationError", "modulename": "screen_brightness_control.exceptions", "qualname": "I2CValidationError", "kind": "class", "doc": "I2C data validation failed
\n", "bases": "ScreenBrightnessError"}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"fullname": "screen_brightness_control.exceptions.MaxRetriesExceededError", "modulename": "screen_brightness_control.exceptions", "qualname": "MaxRetriesExceededError", "kind": "class", "doc": "The command has been retried too many times.
\n\nExample:
\n\n\n \n
try:\n subprocess.check_output(['exit', '1'])\nexcept subprocess.CalledProcessError as e:\n raise MaxRetriesExceededError('failed after 1 try', e)\n
\n
\n", "bases": "ScreenBrightnessError, subprocess.CalledProcessError"}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"fullname": "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__", "modulename": "screen_brightness_control.exceptions", "qualname": "MaxRetriesExceededError.__init__", "kind": "function", "doc": "\n", "signature": "(message: str, exc: subprocess.CalledProcessError)"}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"fullname": "screen_brightness_control.exceptions.MaxRetriesExceededError.message", "modulename": "screen_brightness_control.exceptions", "qualname": "MaxRetriesExceededError.message", "kind": "variable", "doc": "\n", "annotation": ": str"}, "screen_brightness_control.helpers": {"fullname": "screen_brightness_control.helpers", "modulename": "screen_brightness_control.helpers", "kind": "module", "doc": "Helper functions for the library
\n"}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"fullname": "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES", "modulename": "screen_brightness_control.helpers", "qualname": "MONITOR_MANUFACTURER_CODES", "kind": "variable", "doc": "\n", "default_value": "{'AAC': 'AcerView', 'ACI': 'Asus (ASUSTeK Computer Inc.)', 'ACR': 'Acer', 'ACT': 'Targa', 'ADI': 'ADI Corporation', 'AIC': 'AG Neovo', 'ALX': 'Anrecson', 'AMW': 'AMW', 'AOC': 'AOC', 'API': 'Acer America Corp.', 'APP': 'Apple Computer', 'ART': 'ArtMedia', 'AST': 'AST Research', 'AUO': 'Asus', 'BMM': 'BMM', 'BNQ': 'BenQ', 'BOE': 'BOE Display Technology', 'CMO': 'Acer', 'CPL': 'Compal', 'CPQ': 'Compaq', 'CPT': 'Chunghwa Pciture Tubes, Ltd.', 'CTX': 'CTX', 'DEC': 'DEC', 'DEL': 'Dell', 'DPC': 'Delta', 'DWE': 'Daewoo', 'ECS': 'ELITEGROUP Computer Systems', 'EIZ': 'EIZO', 'ELS': 'ELSA', 'ENC': 'EIZO', 'EPI': 'Envision', 'FCM': 'Funai', 'FUJ': 'Fujitsu', 'FUS': 'Fujitsu-Siemens', 'GSM': 'LG Electronics', 'GWY': 'Gateway 2000', 'GBT': 'Gigabyte', 'HEI': 'Hyundai', 'HIQ': 'Hyundai ImageQuest', 'HIT': 'Hyundai', 'HPN': 'HP', 'HSD': 'Hannspree Inc', 'HSL': 'Hansol', 'HTC': 'Hitachi/Nissei', 'HWP': 'HP', 'IBM': 'IBM', 'ICL': 'Fujitsu ICL', 'IFS': 'InFocus', 'IQT': 'Hyundai', 'IVM': 'Iiyama', 'KDS': 'Korea Data Systems', 'KFC': 'KFC Computek', 'LEN': 'Lenovo', 'LGD': 'Asus', 'LKM': 'ADLAS / AZALEA', 'LNK': 'LINK Technologies, Inc.', 'LPL': 'Fujitsu', 'LTN': 'Lite-On', 'MAG': 'MAG InnoVision', 'MAX': 'Belinea', 'MEI': 'Panasonic', 'MEL': 'Mitsubishi Electronics', 'MIR': 'miro Computer Products AG', 'MSI': 'MSI', 'MS_': 'Panasonic', 'MTC': 'MITAC', 'NAN': 'Nanao', 'NEC': 'NEC', 'NOK': 'Nokia Data', 'NVD': 'Fujitsu', 'OPT': 'Optoma', 'OQI': 'OPTIQUEST', 'PBN': 'Packard Bell', 'PCK': 'Daewoo', 'PDC': 'Polaroid', 'PGS': 'Princeton Graphic Systems', 'PHL': 'Philips', 'PRT': 'Princeton', 'REL': 'Relisys', 'SAM': 'Samsung', 'SAN': 'Samsung', 'SBI': 'Smarttech', 'SEC': 'Hewlett-Packard', 'SGI': 'SGI', 'SMC': 'Samtron', 'SMI': 'Smile', 'SNI': 'Siemens Nixdorf', 'SNY': 'Sony', 'SPT': 'Sceptre', 'SRC': 'Shamrock', 'STN': 'Samtron', 'STP': 'Sceptre', 'SUN': 'Sun Microsystems', 'TAT': 'Tatung', 'TOS': 'Toshiba', 'TRL': 'Royal Information Company', 'TSB': 'Toshiba', 'UNK': 'Unknown', 'UNM': 'Unisys Corporation', 'VSC': 'ViewSonic', 'WTC': 'Wen Technology', 'ZCM': 'Zenith', '_YV': 'Fujitsu'}"}, "screen_brightness_control.helpers.BrightnessMethod": {"fullname": "screen_brightness_control.helpers.BrightnessMethod", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod", "kind": "class", "doc": "Helper class that provides a standard way to create an ABC using\ninheritance.
\n", "bases": "abc.ABC"}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"fullname": "screen_brightness_control.helpers.BrightnessMethod.get_display_info", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"fullname": "screen_brightness_control.helpers.BrightnessMethod.get_brightness", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of .types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"fullname": "screen_brightness_control.helpers.BrightnessMethod.set_brightness", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethod.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (.types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"fullname": "screen_brightness_control.helpers.BrightnessMethodAdv", "modulename": "screen_brightness_control.helpers", "qualname": "BrightnessMethodAdv", "kind": "class", "doc": "Helper class that provides a standard way to create an ABC using\ninheritance.
\n", "bases": "BrightnessMethod"}, "screen_brightness_control.helpers.EDID": {"fullname": "screen_brightness_control.helpers.EDID", "modulename": "screen_brightness_control.helpers", "qualname": "EDID", "kind": "class", "doc": "Simple structure and method to extract display serial and name from an EDID string.
\n"}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"fullname": "screen_brightness_control.helpers.EDID.EDID_FORMAT", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.EDID_FORMAT", "kind": "variable", "doc": "The byte structure for EDID strings, taken from\npyedid,\nCopyright 2019-2020 Jonas Lieb, Davydov Denis.
\n", "annotation": ": str", "default_value": "'>8sHHIBBBBBBBBB10sHB16s18s18s18s18sBB'"}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"fullname": "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.SERIAL_DESCRIPTOR", "kind": "variable", "doc": "\n", "default_value": "b'\\x00\\x00\\x00\\xff\\x00'"}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"fullname": "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.NAME_DESCRIPTOR", "kind": "variable", "doc": "\n", "default_value": "b'\\x00\\x00\\x00\\xfc\\x00'"}, "screen_brightness_control.helpers.EDID.parse": {"fullname": "screen_brightness_control.helpers.EDID.parse", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.parse", "kind": "function", "doc": "Takes an EDID string and parses some relevant information from it according to the\nEDID 1.4\nspecification on Wikipedia.
\n\nArguments:
\n\n\n- edid (bytes or str): the EDID, can either be raw bytes or\na hex formatted string (00 ff ff ff ff...)
\n
\n\nReturns:
\n\n\n tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID,\n manufacturer, model, name, serial in that order.\n If any of these values are unable to be determined, they will be None.\n Otherwise, expect a string
\n
\n\nRaises:
\n\n\n\nExample:
\n\n\n \n
import screen_brightness_control as sbc\n\nedid = sbc.list_monitors_info()[0]['edid']\nmanufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)\n\nprint('Manufacturer:', manufacturer_id or 'Unknown')\nprint('Model:', model or 'Unknown')\nprint('Name:', name or 'Unknown')\n
\n
\n", "signature": "(cls, edid: Union[bytes, str]) -> Tuple[Optional[str], ...]:", "funcdef": "def"}, "screen_brightness_control.helpers.EDID.hexdump": {"fullname": "screen_brightness_control.helpers.EDID.hexdump", "modulename": "screen_brightness_control.helpers", "qualname": "EDID.hexdump", "kind": "function", "doc": "Returns a hexadecimal string of binary data from a file
\n\nArguments:
\n\n\n- file (str): the file to read
\n
\n\nReturns:
\n\n\n str: one long hex string
\n
\n\nExample:
\n\n\n \n
from screen_brightness_control import EDID\n\nprint(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))\n# '00ffffffffffff00...'\n
\n
\n", "signature": "(file: str) -> str:", "funcdef": "def"}, "screen_brightness_control.helpers.check_output": {"fullname": "screen_brightness_control.helpers.check_output", "modulename": "screen_brightness_control.helpers", "qualname": "check_output", "kind": "function", "doc": "Run a command with retry management built in.
\n\nArguments:
\n\n\n- command: the command to run
\n- max_tries: the maximum number of retries to allow before raising an error
\n
\n\nReturns:
\n\n\n The output from the command
\n
\n", "signature": "(command: List[str], max_tries: int = 1) -> bytes:", "funcdef": "def"}, "screen_brightness_control.helpers.logarithmic_range": {"fullname": "screen_brightness_control.helpers.logarithmic_range", "modulename": "screen_brightness_control.helpers", "qualname": "logarithmic_range", "kind": "function", "doc": "A range-like function that yields a sequence of integers following\na logarithmic curve (y = 10 ^ (x / 50)) from start (inclusive) to\nstop (inclusive).
\n\nThis is useful because it skips many of the higher percentages in the\nsequence where single percent brightness changes are hard to notice.
\n\nThis function is designed to deal with brightness percentages, and so\nwill never return a value less than 0 or greater than 100.
\n\nArguments:
\n\n\n- start: the start of your percentage range
\n- stop: the end of your percentage range
\n- step: the increment per iteration through the sequence
\n
\n\nYields:
\n\n\n int
\n
\n", "signature": "(\tstart: int,\tstop: int,\tstep: int = 1) -> collections.abc.Generator[int, None, None]:", "funcdef": "def"}, "screen_brightness_control.helpers.percentage": {"fullname": "screen_brightness_control.helpers.percentage", "modulename": "screen_brightness_control.helpers", "qualname": "percentage", "kind": "function", "doc": "Convenience function to convert a brightness value into a percentage. Can handle\nintegers, floats and strings. Also can handle relative strings (eg: '+10' or '-10')
\n\nArguments:
\n\n\n- value: the brightness value to convert
\n- current: the current brightness value or a function that returns the current brightness\nvalue. Used when dealing with relative brightness values
\n- lower_bound: the minimum value the brightness can be set to
\n
\n\nReturns:
\n\n\n The new brightness percentage, between lower_bound and 100
\n
\n", "signature": "(\tvalue: Union[int, str],\tcurrent: Union[int, Callable[[], int], NoneType] = None,\tlower_bound: int = 0) -> int:", "funcdef": "def"}, "screen_brightness_control.linux": {"fullname": "screen_brightness_control.linux", "modulename": "screen_brightness_control.linux", "kind": "module", "doc": "\n"}, "screen_brightness_control.linux.SysFiles": {"fullname": "screen_brightness_control.linux.SysFiles", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles", "kind": "class", "doc": "A way of getting display information and adjusting the brightness\nthat does not rely on any 3rd party software.
\n\nThis class works with displays that show up in the /sys/class/backlight\ndirectory (so usually laptop displays).
\n\nTo set the brightness, your user will need write permissions for\n/sys/class/backlight/*/brightness or you will need to run the program\nas root.
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, "screen_brightness_control.linux.SysFiles.get_display_info": {"fullname": "screen_brightness_control.linux.SysFiles.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.linux.SysFiles.get_brightness": {"fullname": "screen_brightness_control.linux.SysFiles.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of .types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.linux.SysFiles.set_brightness": {"fullname": "screen_brightness_control.linux.SysFiles.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "SysFiles.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (.types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, "screen_brightness_control.linux.I2C": {"fullname": "screen_brightness_control.linux.I2C", "modulename": "screen_brightness_control.linux", "qualname": "I2C", "kind": "class", "doc": "In the same spirit as SysFiles, this class serves as a way of getting\ndisplay information and adjusting the brightness without relying on any\n3rd party software.
\n\nUsage of this class requires read and write permission for /dev/i2c-*.
\n\nThis class works over the I2C bus, primarily with desktop monitors as I\nhaven't tested any e-DP displays yet.
\n\nMassive thanks to siemer for\nhis work on the ddcci.py project,\nwhich served as a my main reference for this.
\n\nReferences:
\n\n\n \n
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"fullname": "screen_brightness_control.linux.I2C.GET_VCP_CMD", "modulename": "screen_brightness_control.linux", "qualname": "I2C.GET_VCP_CMD", "kind": "variable", "doc": "VCP command to get the value of a feature (eg: brightness)
\n", "default_value": "1"}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"fullname": "screen_brightness_control.linux.I2C.GET_VCP_REPLY", "modulename": "screen_brightness_control.linux", "qualname": "I2C.GET_VCP_REPLY", "kind": "variable", "doc": "VCP feature reply op code
\n", "default_value": "2"}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"fullname": "screen_brightness_control.linux.I2C.SET_VCP_CMD", "modulename": "screen_brightness_control.linux", "qualname": "I2C.SET_VCP_CMD", "kind": "variable", "doc": "VCP command to set the value of a feature (eg: brightness)
\n", "default_value": "3"}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"fullname": "screen_brightness_control.linux.I2C.DDCCI_ADDR", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCCI_ADDR", "kind": "variable", "doc": "DDC packets are transmittred using this I2C address
\n", "default_value": "55"}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"fullname": "screen_brightness_control.linux.I2C.HOST_ADDR_R", "modulename": "screen_brightness_control.linux", "qualname": "I2C.HOST_ADDR_R", "kind": "variable", "doc": "Packet source address (the computer) when reading data
\n", "default_value": "80"}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"fullname": "screen_brightness_control.linux.I2C.HOST_ADDR_W", "modulename": "screen_brightness_control.linux", "qualname": "I2C.HOST_ADDR_W", "kind": "variable", "doc": "Packet source address (the computer) when writing data
\n", "default_value": "81"}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"fullname": "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DESTINATION_ADDR_W", "kind": "variable", "doc": "Packet destination address (the monitor) when writing data
\n", "default_value": "110"}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"fullname": "screen_brightness_control.linux.I2C.I2C_SLAVE", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2C_SLAVE", "kind": "variable", "doc": "The I2C slave address
\n", "default_value": "1795"}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"fullname": "screen_brightness_control.linux.I2C.WAIT_TIME", "modulename": "screen_brightness_control.linux", "qualname": "I2C.WAIT_TIME", "kind": "variable", "doc": "How long to wait between I2C commands
\n", "default_value": "0.05"}, "screen_brightness_control.linux.I2C.I2CDevice": {"fullname": "screen_brightness_control.linux.I2C.I2CDevice", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice", "kind": "class", "doc": "Class to read and write data to an I2C bus,\nbased on the I2CDev class from ddcci.py
\n"}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"fullname": "screen_brightness_control.linux.I2C.I2CDevice.__init__", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice.__init__", "kind": "function", "doc": "Arguments:
\n\n\n- fname: the I2C path, eg:
/dev/i2c-2 \n- slave_addr: not entirely sure what this is meant to be
\n
\n", "signature": "(fname: str, slave_addr: int)"}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"fullname": "screen_brightness_control.linux.I2C.I2CDevice.device", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice.device", "kind": "variable", "doc": "\n"}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"fullname": "screen_brightness_control.linux.I2C.I2CDevice.read", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice.read", "kind": "function", "doc": "Read a certain number of bytes from the I2C bus
\n\nArguments:
\n\n\n- length: the number of bytes to read
\n
\n\nReturns:
\n\n\n bytes
\n
\n", "signature": "(self, length: int) -> bytes:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"fullname": "screen_brightness_control.linux.I2C.I2CDevice.write", "modulename": "screen_brightness_control.linux", "qualname": "I2C.I2CDevice.write", "kind": "function", "doc": "Writes data to the I2C bus
\n\nArguments:
\n\n\n- data: the data to write
\n
\n\nReturns:
\n\n\n The number of bytes written
\n
\n", "signature": "(self, data: bytes) -> int:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.DDCInterface": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface", "kind": "class", "doc": "Class to send DDC (Display Data Channel) commands to an I2C device,\nbased on the Ddcci and Mccs classes from ddcci.py
\n", "bases": "I2C.I2CDevice"}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.__init__", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.__init__", "kind": "function", "doc": "Arguments:
\n\n\n- i2c_path: the path to the I2C device, eg:
/dev/i2c-2 \n
\n", "signature": "(i2c_path: str)"}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.PROTOCOL_FLAG", "kind": "variable", "doc": "\n", "default_value": "128"}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.logger", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.logger", "kind": "variable", "doc": "\n"}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.write", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.write", "kind": "function", "doc": "Write some data to the I2C device.
\n\nIt is recommended to use setvcp to set VCP values on the DDC device\ninstead of using this function directly.
\n\nArguments:
\n\n\n- *args: variable length list of arguments. This will be put\ninto a
bytearray and wrapped up in various flags and\nchecksums before being written to the I2C device \n
\n\nReturns:
\n\n\n The number of bytes that were written
\n
\n", "signature": "(self, *args) -> int:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.setvcp", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.setvcp", "kind": "function", "doc": "Set a VCP value on the device
\n\nArguments:
\n\n\n- vcp_code: the VCP command to send, eg:
0x10 is brightness \n- value: what to set the value to
\n
\n\nReturns:
\n\n\n The number of bytes written to the device
\n
\n", "signature": "(self, vcp_code: int, value: int) -> int:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.read", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.read", "kind": "function", "doc": "Reads data from the DDC device.
\n\nIt is recommended to use getvcp to retrieve VCP values from the\nDDC device instead of using this function directly.
\n\nArguments:
\n\n\n- amount: the number of bytes to read
\n
\n\nRaises:
\n\n\n- ValueError: if the read data is deemed invalid
\n
\n", "signature": "(self, amount: int) -> bytes:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"fullname": "screen_brightness_control.linux.I2C.DDCInterface.getvcp", "modulename": "screen_brightness_control.linux", "qualname": "I2C.DDCInterface.getvcp", "kind": "function", "doc": "Retrieves a VCP value from the DDC device.
\n\nArguments:
\n\n\n- vcp_code: the VCP value to read, eg:
0x10 is brightness \n
\n\nReturns:
\n\n\n The current and maximum value respectively
\n
\n\nRaises:
\n\n\n- ValueError: if the read data is deemed invalid
\n
\n", "signature": "(self, vcp_code: int) -> Tuple[int, int]:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.get_display_info": {"fullname": "screen_brightness_control.linux.I2C.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "I2C.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.get_brightness": {"fullname": "screen_brightness_control.linux.I2C.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "I2C.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of .types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.linux.I2C.set_brightness": {"fullname": "screen_brightness_control.linux.I2C.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "I2C.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (.types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, "screen_brightness_control.linux.Light": {"fullname": "screen_brightness_control.linux.Light", "modulename": "screen_brightness_control.linux", "qualname": "Light", "kind": "class", "doc": "Wraps around light, an external\n3rd party tool that can control brightness levels for e-DP displays.
\n\n\n\n
As of April 2nd 2023, the official repository for the light project has\nbeen archived and\nwill no longer receive any updates unless another maintainer picks it\nup.
\n\n
the light executable to be called
\n", "annotation": ": str", "default_value": "'light'"}, "screen_brightness_control.linux.Light.get_display_info": {"fullname": "screen_brightness_control.linux.Light.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "Light.get_display_info", "kind": "function", "doc": "Implements BrightnessMethod.get_display_info.
\n\nWorks by taking the output of SysFiles.get_display_info and\nfiltering out any displays that aren't supported by Light
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.linux.Light.set_brightness": {"fullname": "screen_brightness_control.linux.Light.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "Light.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (.types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, "screen_brightness_control.linux.Light.get_brightness": {"fullname": "screen_brightness_control.linux.Light.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "Light.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of .types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.linux.XRandr": {"fullname": "screen_brightness_control.linux.XRandr", "modulename": "screen_brightness_control.linux", "qualname": "XRandr", "kind": "class", "doc": "collection of screen brightness related methods using the xrandr executable
\n", "bases": "screen_brightness_control.helpers.BrightnessMethodAdv"}, "screen_brightness_control.linux.XRandr.executable": {"fullname": "screen_brightness_control.linux.XRandr.executable", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.executable", "kind": "variable", "doc": "the xrandr executable to be called
\n", "annotation": ": str", "default_value": "'xrandr'"}, "screen_brightness_control.linux.XRandr.get_display_info": {"fullname": "screen_brightness_control.linux.XRandr.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.get_display_info", "kind": "function", "doc": "Implements BrightnessMethod.get_display_info.
\n\nArguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n- brightness: whether to include the current brightness\nin the returned info
\n
\n", "signature": "(\tcls,\tdisplay: Union[str, int, NoneType] = None,\tbrightness: bool = False) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.linux.XRandr.get_brightness": {"fullname": "screen_brightness_control.linux.XRandr.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of .types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.linux.XRandr.set_brightness": {"fullname": "screen_brightness_control.linux.XRandr.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "XRandr.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (.types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, "screen_brightness_control.linux.DDCUtil": {"fullname": "screen_brightness_control.linux.DDCUtil", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil", "kind": "class", "doc": "collection of screen brightness related methods using the ddcutil executable
\n", "bases": "screen_brightness_control.helpers.BrightnessMethodAdv"}, "screen_brightness_control.linux.DDCUtil.executable": {"fullname": "screen_brightness_control.linux.DDCUtil.executable", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.executable", "kind": "variable", "doc": "The ddcutil executable to be called
\n", "annotation": ": str", "default_value": "'ddcutil'"}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"fullname": "screen_brightness_control.linux.DDCUtil.sleep_multiplier", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.sleep_multiplier", "kind": "variable", "doc": "How long ddcutil should sleep between each DDC request (lower is shorter).\nSee the ddcutil docs.
\n", "annotation": ": float", "default_value": "0.5"}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"fullname": "screen_brightness_control.linux.DDCUtil.cmd_max_tries", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.cmd_max_tries", "kind": "variable", "doc": "Max number of retries when calling the ddcutil
\n", "annotation": ": int", "default_value": "10"}, "screen_brightness_control.linux.DDCUtil.enable_async": {"fullname": "screen_brightness_control.linux.DDCUtil.enable_async", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.enable_async", "kind": "variable", "doc": "Use the --async flag when calling ddcutil.\nSee ddcutil docs
\n", "default_value": "True"}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"fullname": "screen_brightness_control.linux.DDCUtil.get_display_info", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"fullname": "screen_brightness_control.linux.DDCUtil.get_brightness", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of .types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"fullname": "screen_brightness_control.linux.DDCUtil.set_brightness", "modulename": "screen_brightness_control.linux", "qualname": "DDCUtil.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (.types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, "screen_brightness_control.linux.list_monitors_info": {"fullname": "screen_brightness_control.linux.list_monitors_info", "modulename": "screen_brightness_control.linux", "qualname": "list_monitors_info", "kind": "function", "doc": "Lists detailed information about all detected displays
\n\nArguments:
\n\n\n- method: the method the display can be addressed by. See
screen_brightness_control.get_methods\nfor more info on available methods \n- allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
\n- unsupported: include detected displays that are invalid or unsupported
\n
\n", "signature": "(\tmethod: Optional[str] = None,\tallow_duplicates: bool = False,\tunsupported: bool = False) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.types": {"fullname": "screen_brightness_control.types", "modulename": "screen_brightness_control.types", "kind": "module", "doc": "Submodule containing types and type aliases used throughout the library.
\n\nSplitting these definitions into a seperate submodule allows for detailed\nexplanations and verbose type definitions, without cluttering up the rest\nof the library.
\n\nThis file is also useful for wrangling types based on the current Python\nversion.
\n"}, "screen_brightness_control.types.IntPercentage": {"fullname": "screen_brightness_control.types.IntPercentage", "modulename": "screen_brightness_control.types", "qualname": "IntPercentage", "kind": "variable", "doc": "An integer between 0 and 100 (inclusive) that represents a brightness level.\nOther than the implied bounds, this is just a normal integer.
\n", "default_value": "<class 'int'>"}, "screen_brightness_control.types.Percentage": {"fullname": "screen_brightness_control.types.Percentage", "modulename": "screen_brightness_control.types", "qualname": "Percentage", "kind": "variable", "doc": "An IntPercentage or a string representing an IntPercentage.
\n\nString values may come in two forms:
\n\n\n- Absolute values: for example
'40' converts directly to int('40') \n- Relative values: strings prefixed with
+/- will be interpreted relative to the\ncurrent brightness level. In this case, the integer value of your string will be added to the\ncurrent brightness level.\nFor example, if the current brightness is 50%, a value of '+40' would imply 90% brightness\nand a value of '-40' would imply 10% brightness. \n
\n\nRelative brightness values will usually be resolved by the helpers.percentage function.
\n", "default_value": "typing.Union[int, str]"}, "screen_brightness_control.types.DisplayIdentifier": {"fullname": "screen_brightness_control.types.DisplayIdentifier", "modulename": "screen_brightness_control.types", "qualname": "DisplayIdentifier", "kind": "variable", "doc": "Something that can be used to identify a particular display.\nCan be any one of the following properties of a display:
\n\n\n- edid (str)
\n- serial (str)
\n- name (str)
\n- index (int)
\n
\n\nSee Display for descriptions of each property and its type
\n", "default_value": "typing.Union[int, str]"}, "screen_brightness_control.windows": {"fullname": "screen_brightness_control.windows", "modulename": "screen_brightness_control.windows", "kind": "module", "doc": "\n"}, "screen_brightness_control.windows.enum_display_devices": {"fullname": "screen_brightness_control.windows.enum_display_devices", "modulename": "screen_brightness_control.windows", "qualname": "enum_display_devices", "kind": "function", "doc": "Yields all display devices connected to the computer
\n", "signature": "() -> collections.abc.Generator[win32api.PyDISPLAY_DEVICEType, None, None]:", "funcdef": "def"}, "screen_brightness_control.windows.get_display_info": {"fullname": "screen_brightness_control.windows.get_display_info", "modulename": "screen_brightness_control.windows", "qualname": "get_display_info", "kind": "function", "doc": "Gets information about all connected displays using WMI and win32api
\n\nExample:
\n\n\n \n
import screen_brightness_control as s\n\ninfo = s.windows.get_display_info()\nfor display in info:\n print(display['name'])\n
\n
\n", "signature": "() -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.windows.WMI": {"fullname": "screen_brightness_control.windows.WMI", "modulename": "screen_brightness_control.windows", "qualname": "WMI", "kind": "class", "doc": "A collection of screen brightness related methods using the WMI API.\nThis class primarily works with laptop displays.
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, "screen_brightness_control.windows.WMI.get_display_info": {"fullname": "screen_brightness_control.windows.WMI.get_display_info", "modulename": "screen_brightness_control.windows", "qualname": "WMI.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.windows.WMI.set_brightness": {"fullname": "screen_brightness_control.windows.WMI.set_brightness", "modulename": "screen_brightness_control.windows", "qualname": "WMI.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- value (.types.IntPercentage): the new brightness value
\n- display: the index of the specific display to adjust.\nIf unspecified, all detected displays are adjusted
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None):", "funcdef": "def"}, "screen_brightness_control.windows.WMI.get_brightness": {"fullname": "screen_brightness_control.windows.WMI.get_brightness", "modulename": "screen_brightness_control.windows", "qualname": "WMI.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n
\n\nReturns:
\n\n\n A list of .types.IntPercentage values, one for each\n queried display
\n
\n", "signature": "(cls, display: Optional[int] = None) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.windows.VCP": {"fullname": "screen_brightness_control.windows.VCP", "modulename": "screen_brightness_control.windows", "qualname": "VCP", "kind": "class", "doc": "Collection of screen brightness related methods using the DDC/CI commands
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"fullname": "screen_brightness_control.windows.VCP.iter_physical_monitors", "modulename": "screen_brightness_control.windows", "qualname": "VCP.iter_physical_monitors", "kind": "function", "doc": "A generator to iterate through all physical monitors\nand then close them again afterwards, yielding their handles.\nIt is not recommended to use this function unless you are familiar with ctypes and windll
\n\nArguments:
\n\n\n- start: skip the first X handles
\n
\n\nRaises:
\n\n\n- ctypes.WinError: upon failure to enumerate through the monitors
\n
\n", "signature": "(\tcls,\tstart: int = 0) -> collections.abc.Generator[wintypes.HANDLE, None, None]:", "funcdef": "def"}, "screen_brightness_control.windows.VCP.get_display_info": {"fullname": "screen_brightness_control.windows.VCP.get_display_info", "modulename": "screen_brightness_control.windows", "qualname": "VCP.get_display_info", "kind": "function", "doc": "Return information about detected displays.
\n\nArguments:
\n\n\n- display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to
filter_monitors \n
\n\nReturns:
\n\n\n A list of dictionaries, each representing a detected display.\n Each returned dictionary will have the following keys:
\n \n \n - name (
str): the name of the display \n - model (
str): the model of the display \n - manufacturer (
str): the name of the display manufacturer \n - manufacturer_id (
str): the three letter manufacturer code (see MONITOR_MANUFACTURER_CODES) \n - serial (
str): the serial of the display OR some other unique identifier \n - edid (
str): the EDID string for the display \n - method (
BrightnessMethod): the brightness method associated with this display \n - index (
int): the index of the display, relative to the brightness method \n
\n
\n", "signature": "(cls, display: Union[str, int, NoneType] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.windows.VCP.get_brightness": {"fullname": "screen_brightness_control.windows.VCP.get_brightness", "modulename": "screen_brightness_control.windows", "qualname": "VCP.get_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: the index of the specific display to query.\nIf unspecified, all detected displays are queried
\n- max_tries: the maximum allowed number of attempts to\nread the VCP output from the display
\n
\n\nReturns:
\n\n\n See BrightnessMethod.get_brightness
\n
\n", "signature": "(cls, display: Optional[int] = None, max_tries: int = 50) -> List[int]:", "funcdef": "def"}, "screen_brightness_control.windows.VCP.set_brightness": {"fullname": "screen_brightness_control.windows.VCP.set_brightness", "modulename": "screen_brightness_control.windows", "qualname": "VCP.set_brightness", "kind": "function", "doc": "Arguments:
\n\n\n- display: The specific display you wish to query.
\n- max_tries: the maximum allowed number of attempts to\nsend the VCP input to the display
\n
\n", "signature": "(cls, value: int, display: Optional[int] = None, max_tries: int = 50):", "funcdef": "def"}, "screen_brightness_control.windows.list_monitors_info": {"fullname": "screen_brightness_control.windows.list_monitors_info", "modulename": "screen_brightness_control.windows", "qualname": "list_monitors_info", "kind": "function", "doc": "Lists detailed information about all detected displays
\n\nArguments:
\n\n\n- method: the method the display can be addressed by. See
screen_brightness_control.get_methods\nfor more info on available methods \n- allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
\n- unsupported: include detected displays that are invalid or unsupported.\nThis argument does nothing on Windows
\n
\n", "signature": "(\tmethod: Optional[str] = None,\tallow_duplicates: bool = False,\tunsupported: bool = False) -> List[dict]:", "funcdef": "def"}}, "docInfo": {"screen_brightness_control": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.get_brightness": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 98, "bases": 0, "doc": 248}, "screen_brightness_control.set_brightness": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 162, "bases": 0, "doc": 385}, "screen_brightness_control.fade_brightness": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 196, "bases": 0, "doc": 493}, "screen_brightness_control.list_monitors_info": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 495}, "screen_brightness_control.list_monitors": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 107}, "screen_brightness_control.get_methods": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 61, "bases": 0, "doc": 216}, "screen_brightness_control.Display": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 8}, "screen_brightness_control.Display.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 189, "bases": 0, "doc": 3}, "screen_brightness_control.Display.index": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 45}, "screen_brightness_control.Display.method": {"qualname": 2, "fullname": 5, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 24}, "screen_brightness_control.Display.edid": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 15}, "screen_brightness_control.Display.manufacturer": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 8}, "screen_brightness_control.Display.manufacturer_id": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "screen_brightness_control.Display.model": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 7}, "screen_brightness_control.Display.name": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 15}, "screen_brightness_control.Display.serial": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 20}, "screen_brightness_control.Display.fade_brightness": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 147, "bases": 0, "doc": 209}, "screen_brightness_control.Display.from_dict": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 15}, "screen_brightness_control.Display.get_brightness": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 33}, "screen_brightness_control.Display.get_identifier": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 68}, "screen_brightness_control.Display.is_active": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 18}, "screen_brightness_control.Display.set_brightness": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 50, "bases": 0, "doc": 72}, "screen_brightness_control.Monitor": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 33}, "screen_brightness_control.Monitor.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 229}, "screen_brightness_control.Monitor.get_identifier": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 59, "bases": 0, "doc": 287}, "screen_brightness_control.Monitor.set_brightness": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 81, "bases": 0, "doc": 55}, "screen_brightness_control.Monitor.get_brightness": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 33}, "screen_brightness_control.Monitor.fade_brightness": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 66, "bases": 0, "doc": 75}, "screen_brightness_control.Monitor.from_dict": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 15}, "screen_brightness_control.Monitor.get_info": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 121}, "screen_brightness_control.filter_monitors": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 127, "bases": 0, "doc": 234}, "screen_brightness_control.exceptions": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 15}, "screen_brightness_control.exceptions.EDIDParseError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 4}, "screen_brightness_control.exceptions.NoValidDisplayError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 8}, "screen_brightness_control.exceptions.I2CValidationError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 6}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 111}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.helpers": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 769, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.helpers.BrightnessMethod": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 16}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 187}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 50}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 39}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 16}, "screen_brightness_control.helpers.EDID": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 17}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 6, "signature": 0, "bases": 0, "doc": 23}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.helpers.EDID.parse": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 53, "bases": 0, "doc": 328}, "screen_brightness_control.helpers.EDID.hexdump": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 109}, "screen_brightness_control.helpers.check_output": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 58}, "screen_brightness_control.helpers.logarithmic_range": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 77, "bases": 0, "doc": 141}, "screen_brightness_control.helpers.percentage": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 93, "bases": 0, "doc": 113}, "screen_brightness_control.linux": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.linux.SysFiles": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 70}, "screen_brightness_control.linux.SysFiles.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 187}, "screen_brightness_control.linux.SysFiles.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 50}, "screen_brightness_control.linux.SysFiles.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 39}, "screen_brightness_control.linux.I2C": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 124}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 14}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 7}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 14}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 6}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 9}, "screen_brightness_control.linux.I2C.I2CDevice": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 24}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 35}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 40}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 38}, "screen_brightness_control.linux.I2C.DDCInterface": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 30}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 15, "bases": 0, "doc": 24}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 92}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 61}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 71}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 69}, "screen_brightness_control.linux.I2C.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 187}, "screen_brightness_control.linux.I2C.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 50}, "screen_brightness_control.linux.I2C.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 39}, "screen_brightness_control.linux.Light": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 59}, "screen_brightness_control.linux.Light.executable": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 8}, "screen_brightness_control.linux.Light.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 35}, "screen_brightness_control.linux.Light.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 39}, "screen_brightness_control.linux.Light.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 50}, "screen_brightness_control.linux.XRandr": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 12}, "screen_brightness_control.linux.XRandr.executable": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 8}, "screen_brightness_control.linux.XRandr.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 52}, "screen_brightness_control.linux.XRandr.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 50}, "screen_brightness_control.linux.XRandr.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 39}, "screen_brightness_control.linux.DDCUtil": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 12}, "screen_brightness_control.linux.DDCUtil.executable": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 8}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 21}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"qualname": 4, "fullname": 8, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "screen_brightness_control.linux.DDCUtil.enable_async": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 17}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 187}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 50}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 39}, "screen_brightness_control.linux.list_monitors_info": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 75}, "screen_brightness_control.types": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 56}, "screen_brightness_control.types.IntPercentage": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 8, "signature": 0, "bases": 0, "doc": 26}, "screen_brightness_control.types.Percentage": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 3, "signature": 0, "bases": 0, "doc": 137}, "screen_brightness_control.types.DisplayIdentifier": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 3, "signature": 0, "bases": 0, "doc": 61}, "screen_brightness_control.windows": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.windows.enum_display_devices": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 10}, "screen_brightness_control.windows.get_display_info": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 102}, "screen_brightness_control.windows.WMI": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 21}, "screen_brightness_control.windows.WMI.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 187}, "screen_brightness_control.windows.WMI.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 39}, "screen_brightness_control.windows.WMI.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 43, "bases": 0, "doc": 50}, "screen_brightness_control.windows.VCP": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 12}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 66, "bases": 0, "doc": 76}, "screen_brightness_control.windows.VCP.get_display_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 187}, "screen_brightness_control.windows.VCP.get_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 61, "bases": 0, "doc": 62}, "screen_brightness_control.windows.VCP.set_brightness": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 62, "bases": 0, "doc": 40}, "screen_brightness_control.windows.list_monitors_info": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 81}}, "length": 123, "save": true}, "index": {"qualname": {"root": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 5, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 26, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 1}}}}}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 25, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "v": {"docs": {"screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 12, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}}, "df": 4}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 3}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 4}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 9, "s": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 6}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.model": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 3}}}}}}}}}}, "x": {"docs": {"screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}}, "df": 26, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}}, "df": 5}}}}}}}}, "docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 13}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 5}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "d": {"docs": {"screen_brightness_control.Display.manufacturer_id": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}}, "df": 2}}}}}}}}}, "s": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 26, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 8}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}}, "df": 8}}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 7, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 3}}}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 4}}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 3}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 8}}}, "w": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 2}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}}, "df": 4}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}}, "df": 5}}}}}}}}, "fullname": {"root": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 5, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control": {"tf": 1}, "screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions": {"tf": 1}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}, "screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 123, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 12, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}}, "df": 2}}}}}, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}}, "df": 4}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control": {"tf": 1}, "screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions": {"tf": 1}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}, "screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 123, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "v": {"docs": {"screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control": {"tf": 1}, "screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions": {"tf": 1}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}, "screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 123}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 3}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 26, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 3}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 4}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.linux": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}}, "df": 50}}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 9, "s": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 6}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.model": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 3}}}}}}}}}}, "x": {"docs": {"screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}}, "df": 26, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}}, "df": 5}}}}}}}}, "docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 13}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 5}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "d": {"docs": {"screen_brightness_control.Display.manufacturer_id": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}}, "df": 2}}}}}}}}}, "s": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 26, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 8}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}}, "df": 8}}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 7, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.exceptions": {"tf": 1}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}}, "df": 8}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 3}}}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 4}}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 16}}}}}, "x": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}}, "df": 2}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 8}}}, "w": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.windows": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 13}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}}, "df": 4}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 4}}}}}, "x": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}}, "df": 5}}}}}}}}, "annotation": {"root": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 15, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 2}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}}, "df": 6}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 5}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}}}, "default_value": {"root": {"0": {"5": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}}, "df": 1}, "docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 2}, "1": {"0": {"docs": {"screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 1}, "1": {"0": {"docs": {"screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "2": {"8": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "7": {"9": {"5": {"docs": {"screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {"screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}}, "df": 1}, "2": {"0": {"0": {"0": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {"screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}}, "df": 1}, "3": {"docs": {"screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}}, "df": 1}, "5": {"5": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}}, "df": 1}, "docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}, "8": {"0": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}}, "df": 1}, "1": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"1": {"0": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "b": {"1": {"6": {"docs": {}, "df": 0, "s": {"1": {"8": {"docs": {}, "df": 0, "s": {"1": {"8": {"docs": {}, "df": 0, "s": {"1": {"8": {"docs": {}, "df": 0, "s": {"1": {"8": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "b": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}}}}}}}}}, "docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 10.295630140987}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.types.IntPercentage": {"tf": 1.4142135623730951}}, "df": 8, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}}, "df": 6}}, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "x": {"0": {"0": {"docs": {}, "df": 0, "\\": {"docs": {}, "df": 0, "x": {"0": {"0": {"docs": {}, "df": 0, "\\": {"docs": {}, "df": 0, "x": {"0": {"0": {"docs": {}, "df": 0, "\\": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "\\": {"docs": {}, "df": 0, "x": {"0": {"0": {"docs": {"screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "c": {"docs": {}, "df": 0, "\\": {"docs": {}, "df": 0, "x": {"0": {"0": {"docs": {"screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "2": {"7": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 20.29778313018444}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.types.IntPercentage": {"tf": 1.4142135623730951}}, "df": 8}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.XRandr.executable": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.7320508075688772}}, "df": 1, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "r": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.7320508075688772}}, "df": 1, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "d": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "g": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}, "l": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "p": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "p": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 2}}, "df": 1}, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "q": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "q": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.7320508075688772}}, "df": 1}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}}, "b": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "f": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "q": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "b": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {"screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1}}, "df": 2, "m": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "n": {"docs": {}, "df": 0, "q": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "q": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "h": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1, "d": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "g": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "d": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "k": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.Light.executable": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.7320508075688772}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "n": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "y": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "p": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "r": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "j": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 2.449489742783178}}, "df": 1}}}}}, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "b": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 2}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "w": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 2}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "q": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "p": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}, "q": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}, "x": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "l": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "r": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "o": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}}}}, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "i": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.4142135623730951}}, "df": 1}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 2}}}}}}}}}, "v": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}}}}, "w": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "z": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {}, "df": 0, "v": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}}, "signature": {"root": {"0": {"1": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}, "docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 4}, "1": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 4}, "5": {"0": {"docs": {"screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"screen_brightness_control.get_brightness": {"tf": 9}, "screen_brightness_control.set_brightness": {"tf": 11.532562594670797}, "screen_brightness_control.fade_brightness": {"tf": 12.727922061357855}, "screen_brightness_control.list_monitors_info": {"tf": 7.937253933193772}, "screen_brightness_control.list_monitors": {"tf": 5.656854249492381}, "screen_brightness_control.get_methods": {"tf": 7}, "screen_brightness_control.Display.__init__": {"tf": 12.449899597988733}, "screen_brightness_control.Display.fade_brightness": {"tf": 11.045361017187261}, "screen_brightness_control.Display.from_dict": {"tf": 4.898979485566356}, "screen_brightness_control.Display.get_brightness": {"tf": 3.4641016151377544}, "screen_brightness_control.Display.get_identifier": {"tf": 5.477225575051661}, "screen_brightness_control.Display.is_active": {"tf": 3.4641016151377544}, "screen_brightness_control.Display.set_brightness": {"tf": 6.48074069840786}, "screen_brightness_control.Monitor.__init__": {"tf": 5.196152422706632}, "screen_brightness_control.Monitor.get_identifier": {"tf": 7}, "screen_brightness_control.Monitor.set_brightness": {"tf": 8.18535277187245}, "screen_brightness_control.Monitor.get_brightness": {"tf": 3.4641016151377544}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 7.483314773547883}, "screen_brightness_control.Monitor.from_dict": {"tf": 4.47213595499958}, "screen_brightness_control.Monitor.get_info": {"tf": 5.0990195135927845}, "screen_brightness_control.filter_monitors": {"tf": 10.344080432788601}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 4.898979485566356}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 6.782329983125268}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 6}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 6.082762530298219}, "screen_brightness_control.helpers.EDID.parse": {"tf": 6.708203932499369}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 4}, "screen_brightness_control.helpers.check_output": {"tf": 5.916079783099616}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 8}, "screen_brightness_control.helpers.percentage": {"tf": 8.774964387392123}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 6.782329983125268}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 6}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 6.082762530298219}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 4.47213595499958}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 4.47213595499958}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 4.47213595499958}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 3.4641016151377544}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 4.242640687119285}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 5.291502622129181}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 4.47213595499958}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 5.477225575051661}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 6.782329983125268}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 6}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 6.082762530298219}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 6.782329983125268}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 6.082762530298219}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 6}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 7.937253933193772}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 6}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 6.082762530298219}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 6.782329983125268}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 6}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 6.082762530298219}, "screen_brightness_control.linux.list_monitors_info": {"tf": 7.937253933193772}, "screen_brightness_control.windows.enum_display_devices": {"tf": 6}, "screen_brightness_control.windows.get_display_info": {"tf": 3.7416573867739413}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 6.782329983125268}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 6.082762530298219}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 6}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 7.416198487095663}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 6.782329983125268}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 7.0710678118654755}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 7.14142842854285}, "screen_brightness_control.windows.list_monitors_info": {"tf": 7.937253933193772}}, "df": 64, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 30}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 18}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 3}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 21}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 3}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.__init__": {"tf": 2.449489742783178}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 31}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 4}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "f": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 16}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1}}}}}, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 1}}, "docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 2}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 2}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 2}, "screen_brightness_control.helpers.percentage": {"tf": 2.23606797749979}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1.7320508075688772}}, "df": 49, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 2.449489742783178}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 40, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 14}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 2}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 8}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "x": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 3}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 2.449489742783178}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 29}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 13}}}}, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 2}}}, "x": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}}, "df": 1}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 13}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}}, "df": 5, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 5}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 10}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}}, "df": 5}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 26}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}}}}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}}, "df": 2}}}}, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.Monitor.get_info": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}}, "df": 6}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 3}}}}, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}}}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 2}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 4}}}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 3}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 2}}}, "b": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 3}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 4}}}}}, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 3}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 2}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 28}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 3}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"3": {"2": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}}, "df": 1}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}}, "df": 2}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 7, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 6, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "v": {"docs": {"screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 7, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}}, "df": 1}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 7}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1.4142135623730951}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 7}}}}}}}, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}}, "df": 1}}}}}}}}, "docs": {}, "df": 0}}}, "doc": {"root": {"0": {"0": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"0": {"0": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}}}}}}}}, "docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 2.23606797749979}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 13, "x": {"1": {"0": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "1": {"0": {"0": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 4}, "docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 4}, "2": {"3": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}}, "df": 2}}}}, "docs": {}, "df": 0}, "docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 7, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}}, "df": 1}}}, "2": {"0": {"1": {"9": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "2": {"0": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}, "3": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "3": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor": {"tf": 1}}, "df": 2}, "5": {"6": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}}, "df": 1}, "docs": {"screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}}, "df": 2}, "docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}, "3": {"0": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}}, "df": 1}, "9": {"docs": {"screen_brightness_control.set_brightness": {"tf": 2}, "screen_brightness_control.list_monitors_info": {"tf": 5.830951894845301}, "screen_brightness_control.list_monitors": {"tf": 2}, "screen_brightness_control.get_methods": {"tf": 2.449489742783178}, "screen_brightness_control.Monitor.__init__": {"tf": 2.449489742783178}, "screen_brightness_control.Monitor.get_identifier": {"tf": 3.4641016151377544}, "screen_brightness_control.filter_monitors": {"tf": 3.1622776601683795}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 2.449489742783178}, "screen_brightness_control.helpers.EDID.parse": {"tf": 3.7416573867739413}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 2}, "screen_brightness_control.windows.get_display_info": {"tf": 1.4142135623730951}}, "df": 11}, "docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 3}}}, "4": {"0": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 2}}, "df": 1}, "5": {"6": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {"screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}}, "df": 1}}}}, "docs": {}, "df": 0}, "docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}, "5": {"0": {"docs": {"screen_brightness_control.set_brightness": {"tf": 2}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 4}, "docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}, "7": {"5": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}, "9": {"0": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"screen_brightness_control": {"tf": 1.7320508075688772}, "screen_brightness_control.get_brightness": {"tf": 11.445523142259598}, "screen_brightness_control.set_brightness": {"tf": 13.527749258468683}, "screen_brightness_control.fade_brightness": {"tf": 15}, "screen_brightness_control.list_monitors_info": {"tf": 16.822603841260722}, "screen_brightness_control.list_monitors": {"tf": 7.681145747868608}, "screen_brightness_control.get_methods": {"tf": 11.958260743101398}, "screen_brightness_control.Display": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.__init__": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.index": {"tf": 2.6457513110645907}, "screen_brightness_control.Display.method": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.edid": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.manufacturer": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.model": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.name": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.serial": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 7.874007874011811}, "screen_brightness_control.Display.from_dict": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_brightness": {"tf": 3.7416573867739413}, "screen_brightness_control.Display.get_identifier": {"tf": 4.58257569495584}, "screen_brightness_control.Display.is_active": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 4.358898943540674}, "screen_brightness_control.Monitor": {"tf": 3.605551275463989}, "screen_brightness_control.Monitor.__init__": {"tf": 11.832159566199232}, "screen_brightness_control.Monitor.get_identifier": {"tf": 12.767145334803704}, "screen_brightness_control.Monitor.set_brightness": {"tf": 5.0990195135927845}, "screen_brightness_control.Monitor.get_brightness": {"tf": 3.7416573867739413}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 5.291502622129181}, "screen_brightness_control.Monitor.from_dict": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_info": {"tf": 8.774964387392123}, "screen_brightness_control.filter_monitors": {"tf": 10.44030650891055}, "screen_brightness_control.exceptions": {"tf": 1.7320508075688772}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1.7320508075688772}, "screen_brightness_control.exceptions.EDIDParseError": {"tf": 1.4142135623730951}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1.4142135623730951}, "screen_brightness_control.exceptions.I2CValidationError": {"tf": 1.4142135623730951}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 8.831760866327848}, "screen_brightness_control.exceptions.MaxRetriesExceededError.__init__": {"tf": 1.7320508075688772}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 8.426149773176359}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 4.58257569495584}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 2.6457513110645907}, "screen_brightness_control.helpers.EDID.SERIAL_DESCRIPTOR": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.NAME_DESCRIPTOR": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.parse": {"tf": 13.820274961085254}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 8.306623862918075}, "screen_brightness_control.helpers.check_output": {"tf": 5}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 6.782329983125268}, "screen_brightness_control.helpers.percentage": {"tf": 6.244997998398398}, "screen_brightness_control.linux": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.SysFiles": {"tf": 3.605551275463989}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 8.426149773176359}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 4.58257569495584}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.linux.I2C": {"tf": 6.244997998398398}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 2.449489742783178}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 4}, "screen_brightness_control.linux.I2C.I2CDevice.device": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 4.47213595499958}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 4.47213595499958}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 2.8284271247461903}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 3.4641016151377544}, "screen_brightness_control.linux.I2C.DDCInterface.PROTOCOL_FLAG": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.logger": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 5.291502622129181}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 5.0990195135927845}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 5.291502622129181}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 5.744562646538029}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 8.426149773176359}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 4.58257569495584}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.linux.Light": {"tf": 3.7416573867739413}, "screen_brightness_control.linux.Light.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 3}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 4.58257569495584}, "screen_brightness_control.linux.XRandr": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 4.358898943540674}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 4.58257569495584}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.linux.DDCUtil": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 2.23606797749979}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 2.6457513110645907}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 8.426149773176359}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 4.58257569495584}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.linux.list_monitors_info": {"tf": 4.69041575982343}, "screen_brightness_control.types": {"tf": 3}, "screen_brightness_control.types.IntPercentage": {"tf": 1.7320508075688772}, "screen_brightness_control.types.Percentage": {"tf": 6.6332495807108}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 4.69041575982343}, "screen_brightness_control.windows": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.get_display_info": {"tf": 8.366600265340756}, "screen_brightness_control.windows.WMI": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 8.426149773176359}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 4.58257569495584}, "screen_brightness_control.windows.VCP": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 5.0990195135927845}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 8.426149773176359}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 4.898979485566356}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.windows.list_monitors_info": {"tf": 4.69041575982343}}, "df": 123, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 2}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}}, "df": 17, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 34}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 12}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 1}}}, "d": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}, "s": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}}, "df": 2}}}, "y": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 9}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 4}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 7, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.Monitor.get_info": {"tf": 1.4142135623730951}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 3}}}}}}}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 6}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.7320508075688772}}, "df": 2}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.check_output": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 3}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}}, "df": 4, "h": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 3.4641016151377544}, "screen_brightness_control.set_brightness": {"tf": 3.4641016151377544}, "screen_brightness_control.fade_brightness": {"tf": 4.358898943540674}, "screen_brightness_control.list_monitors_info": {"tf": 4.358898943540674}, "screen_brightness_control.list_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.get_methods": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.index": {"tf": 2.6457513110645907}, "screen_brightness_control.Display.method": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 2}, "screen_brightness_control.Display.serial": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.fade_brightness": {"tf": 3.605551275463989}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_identifier": {"tf": 2.449489742783178}, "screen_brightness_control.Display.is_active": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 2.6457513110645907}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 2.449489742783178}, "screen_brightness_control.Monitor.get_identifier": {"tf": 2.8284271247461903}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1.7320508075688772}, "screen_brightness_control.filter_monitors": {"tf": 3}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 4.123105625617661}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 2}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 2.449489742783178}, "screen_brightness_control.helpers.percentage": {"tf": 2.449489742783178}, "screen_brightness_control.linux.SysFiles": {"tf": 2}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 4.123105625617661}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C": {"tf": 2}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 2}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 2.23606797749979}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 2}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 2}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 4.123105625617661}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.Light": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 2}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 4.123105625617661}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.7320508075688772}, "screen_brightness_control.types": {"tf": 2}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 2.23606797749979}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 4.123105625617661}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 4.123105625617661}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 2.23606797749979}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 2}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.7320508075688772}}, "df": 97, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 5}, "i": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 2}}, "m": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 2}, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 2}}, "y": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 5, "k": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 2}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 16}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C": {"tf": 2}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 35}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 6}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}}, "df": 6, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.types": {"tf": 1.4142135623730951}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.types": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 32}}}}, "o": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.set_brightness": {"tf": 2.8284271247461903}, "screen_brightness_control.fade_brightness": {"tf": 3.3166247903554}, "screen_brightness_control.list_monitors_info": {"tf": 2}, "screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 2.6457513110645907}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 2}, "screen_brightness_control.Monitor.__init__": {"tf": 2}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 2.23606797749979}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.SysFiles": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 2}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 2}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 72, "o": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1, "l": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 3, "s": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 2, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}}, "df": 2}}, "y": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1.4142135623730951}}, "df": 1}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}}, "df": 1}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}, "s": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.Light.get_display_info": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}}, "df": 9}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 16, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 4}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 4}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 11, "s": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 6}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}}, "df": 3}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 3}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 2}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}}, "df": 5, "s": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 4}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 4, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}}, "df": 2, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 3, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 9}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}}, "df": 1}}}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Monitor.get_info": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 16, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 3.605551275463989}, "screen_brightness_control.set_brightness": {"tf": 4.242640687119285}, "screen_brightness_control.fade_brightness": {"tf": 5}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 3.1622776601683795}, "screen_brightness_control.Display.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 2.23606797749979}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 2}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.percentage": {"tf": 2.6457513110645907}, "screen_brightness_control.linux.SysFiles": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 2.449489742783178}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 52, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 9}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 1}}}}, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 18, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 4}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 4}}}}}, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 6}}}}}, "n": {"docs": {}, "df": 0, "q": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 2.23606797749979}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 6}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 3}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 4, "/": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 3}}}}, "y": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 13, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 6}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 2}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "q": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}}, "df": 4}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"screen_brightness_control.get_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.set_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.fade_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.list_monitors_info": {"tf": 2.449489742783178}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 2}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 65, "f": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 18, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}}, "df": 14}, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 3}}}, "r": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 2.23606797749979}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 23, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 7, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 5}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"screen_brightness_control.Display.serial": {"tf": 1}}, "df": 1}, "p": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 8}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 2.449489742783178}, "screen_brightness_control.Monitor.get_identifier": {"tf": 2.23606797749979}, "screen_brightness_control.Monitor.get_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 11, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 16}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 2}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 2}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}}, "df": 11}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 2.449489742783178}, "screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 3}, "screen_brightness_control.Display.index": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 17, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1.7320508075688772}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 12}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 2.23606797749979}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 2.23606797749979}, "screen_brightness_control.helpers.EDID.parse": {"tf": 2.449489742783178}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 2.23606797749979}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 2.23606797749979}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 2.23606797749979}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 2.23606797749979}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 2.23606797749979}}, "df": 11}}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 1}}}}}}}, "y": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 2}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 2}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}, "x": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 4, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.get_brightness": {"tf": 2.6457513110645907}, "screen_brightness_control.set_brightness": {"tf": 2.23606797749979}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 4}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 2.449489742783178}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 3.1622776601683795}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 3.1622776601683795}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 3.1622776601683795}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 3.1622776601683795}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 3.1622776601683795}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 3.1622776601683795}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 60, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.list_monitors_info": {"tf": 2.6457513110645907}, "screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 2}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 2}}, "df": 37}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 12}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 7}}}, "y": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 28}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 4, "s": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.types": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}, "l": {"docs": {"screen_brightness_control.list_monitors": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 2}}}}}, "k": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 1}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 3}}, "docs": {}, "df": 0}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 6, "s": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {"screen_brightness_control.Monitor.set_brightness": {"tf": 1}}, "df": 1, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}}, "df": 1}, "c": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 11}}, "v": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 3, "s": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 3}}}}}}}}}, "p": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 2}, "d": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 6, "c": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1.4142135623730951}}, "df": 3}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1.4142135623730951}}, "df": 5}}}}, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 2.23606797749979}, "screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 2}, "screen_brightness_control.helpers.percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}}, "df": 50, "r": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 53}}}}}}, "s": {"docs": {"screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 2}}, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 25, "n": {"docs": {"screen_brightness_control.linux.Light.get_display_info": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 9}}}}}}}}, "n": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}}, "df": 15, "y": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 9}, "d": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1.4142135623730951}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}}, "df": 27}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 2}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 19, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.serial": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 27, "o": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 6, "s": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 4}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}}, "df": 8, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}}, "df": 9}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 3}}}}}}}, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 4}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 12}}}, "c": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 2}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 3, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 4}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.is_active": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}, "i": {"docs": {"screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1.4142135623730951}}, "df": 4, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 26, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}}, "df": 2}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 23}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.7320508075688772}}, "df": 2}}}, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"screen_brightness_control.set_brightness": {"tf": 3.3166247903554}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.set_brightness": {"tf": 2}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1.4142135623730951}}, "df": 11, "s": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 2}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.serial": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 2.23606797749979}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}}, "df": 15}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}, "d": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.7320508075688772}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 3}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 19}}}}}, "b": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.get_brightness": {"tf": 2}, "screen_brightness_control.set_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.fade_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.__init__": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_identifier": {"tf": 2}, "screen_brightness_control.Monitor.get_info": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}}, "df": 11}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}, "r": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 2.449489742783178}}, "df": 9, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 12, "s": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 3}}}, "w": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 3, "r": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.types": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.Light.get_display_info": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}}, "df": 2}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 3}}}, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}}}, "*": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}}, "df": 2}}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 1}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 11}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 9}}}}}}}, "u": {"2": {"2": {"1": {"1": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.list_monitors": {"tf": 1}}, "df": 1}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 12, "s": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}}, "df": 2}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 2}}}, "d": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 3}, "r": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 10}}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 16}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Monitor.get_identifier": {"tf": 1}}, "df": 1}}}}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 6}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 5, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 2.8284271247461903}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_info": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 16, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 3}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}}, "df": 1}, "l": {"2": {"4": {"5": {"0": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}}, "df": 5}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors_info": {"tf": 1.7320508075688772}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 41, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}}, "df": 5}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 2}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 3}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 3.605551275463989}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 2}}, "df": 3, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 10, "s": {"docs": {"screen_brightness_control.helpers": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}, "d": {"docs": {"screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 12, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.Light.get_display_info": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.7320508075688772}, "screen_brightness_control.types": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 2.449489742783178}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 19}}}, "f": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 2}}, "df": 1}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}}, "df": 3}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1}}}}}, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}, "screen_brightness_control.linux.I2C.I2C_SLAVE": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1.4142135623730951}}, "df": 12, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}}, "df": 1}}}}}, "docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1, "n": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 2}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 16, "f": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1.7320508075688772}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 13, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 16}}}}}}}}}, "t": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 9, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}}, "df": 20}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 3}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.index": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 28}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 7}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}}}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 5}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Monitor.get_info": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}}, "df": 3}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}}, "df": 4}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 2}}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 13}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}}, "y": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}}, "df": 1}}}}, "f": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 2.23606797749979}, "screen_brightness_control.get_methods": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}}, "df": 30}, "s": {"docs": {"screen_brightness_control.set_brightness": {"tf": 2}, "screen_brightness_control.fade_brightness": {"tf": 2.23606797749979}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 2}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 28, "n": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}, "t": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 11, "e": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 2}}, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 9, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Monitor.get_identifier": {"tf": 2}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 7}}}, "y": {"docs": {"screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}}, "df": 2}}}}}}}}, "v": {"0": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 2.449489742783178}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1.4142135623730951}}, "df": 24, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 2}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}}, "df": 14}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 3}}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.exceptions.I2CValidationError": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.Display.index": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_REPLY": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 10}}}, "e": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 3, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}}, "df": 4, "s": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}}, "df": 19}}, "s": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.exceptions.ScreenBrightnessError": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 15}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.EDID": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 5}}}}}}}}}, "g": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 2}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.SET_VCP_CMD": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 12}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions.EDIDParseError": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 2.8284271247461903}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 18, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 2}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}}, "df": 6, "s": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 2.23606797749979}, "screen_brightness_control.list_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.get_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 23, "s": {"docs": {"screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}}, "df": 5}}}, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.types": {"tf": 1.4142135623730951}}, "df": 3}}}}}, "e": {"docs": {}, "df": 0, "b": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.Light.executable": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 5}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 3}}}}}}}}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 2}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 3, "n": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.4142135623730951}}, "df": 6}}, "t": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 14, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor": {"tf": 1}, "screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.set_brightness": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles.set_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C.set_brightness": {"tf": 1}, "screen_brightness_control.linux.Light.set_brightness": {"tf": 1}, "screen_brightness_control.linux.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}}, "df": 13}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1.4142135623730951}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 2.23606797749979}, "screen_brightness_control.get_methods": {"tf": 2.449489742783178}, "screen_brightness_control.Display.manufacturer": {"tf": 1}, "screen_brightness_control.Display.manufacturer_id": {"tf": 1}, "screen_brightness_control.Display.model": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 2}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1.7320508075688772}}, "df": 20, "s": {"docs": {"screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1}}, "df": 2}, "d": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.read": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.read": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 10}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 2.6457513110645907}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.get_info": {"tf": 1.7320508075688772}}, "df": 4}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 2}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 3}, "screen_brightness_control.get_methods": {"tf": 1.7320508075688772}, "screen_brightness_control.Monitor.__init__": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.7320508075688772}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 8}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Display.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1.4142135623730951}, "screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 1}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 2}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}}}, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 2, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.get_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 9, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 6}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.types.DisplayIdentifier": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 3, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCCI_ADDR": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.name": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Monitor": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_brightness": {"tf": 2}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 21}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 18, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}}, "df": 2}}}}}, "n": {"3": {"2": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 1}}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.index": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 4}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 2}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 3}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Monitor.get_info": {"tf": 1}, "screen_brightness_control.linux.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 6}}}}, "n": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_R": {"tf": 1}, "screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.cmd_max_tries": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.enable_async": {"tf": 1}}, "df": 8}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 4}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.Light.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 6}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}, "d": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"screen_brightness_control.linux.Light": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.types": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 5, "s": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.linux.I2C.HOST_ADDR_W": {"tf": 1}, "screen_brightness_control.linux.I2C.DESTINATION_ADDR_W": {"tf": 1}}, "df": 2}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.I2C.I2CDevice.write": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.I2C.DDCInterface.setvcp": {"tf": 1}}, "df": 3}}}}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 4}, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 2}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Monitor.fade_brightness": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Monitor.from_dict": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 8}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Monitor.get_info": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.Display.edid": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 3, "s": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Monitor.set_brightness": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.linux.Light": {"tf": 1}}, "df": 3}, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.linux.SysFiles.get_display_info": {"tf": 1}, "screen_brightness_control.linux.I2C.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 7, "n": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.helpers.percentage": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.linux.I2C.WAIT_TIME": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.sleep_multiplier": {"tf": 1}}, "df": 2}}}, "y": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {"screen_brightness_control.Monitor.__init__": {"tf": 1}, "screen_brightness_control.Monitor.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 6, "r": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.EDID.EDID_FORMAT": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 1}}}}, "x": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.XRandr.executable": {"tf": 1}}, "df": 2}}}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true};
// mirrored in build-search-index.js (part 1)
// Also split on html tags. this is a cheap heuristic, but good enough.
diff --git a/extras/Examples.html b/extras/Examples.html
index 59c2509..c0a53d4 100644
--- a/extras/Examples.html
+++ b/extras/Examples.html
@@ -3,7 +3,7 @@
-
+
Examples - screen_brightness_control
@@ -14,8 +14,8 @@
-
-
+
+