diff --git a/docs/0.22.2/index.html b/docs/0.22.2/index.html new file mode 100644 index 0000000..28d5bbd --- /dev/null +++ b/docs/0.22.2/index.html @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/0.22.2/screen_brightness_control.html b/docs/0.22.2/screen_brightness_control.html new file mode 100644 index 0000000..09a921d --- /dev/null +++ b/docs/0.22.2/screen_brightness_control.html @@ -0,0 +1,3347 @@ + + + + + + + screen_brightness_control API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control

+ + + + + + + 
  1import logging
+  2import platform
+  3import threading
+  4import time
+  5import traceback
+  6import warnings
+  7from dataclasses import dataclass, field, fields
+  8from types import ModuleType
+  9from typing import Callable, Dict, List, Optional, Tuple, Type, Union
+ 10
+ 11from ._version import __author__, __version__  # noqa: F401
+ 12from .exceptions import NoValidDisplayError, format_exc
+ 13from .helpers import (BrightnessMethod, ScreenBrightnessError,
+ 14                      logarithmic_range, percentage)
+ 15from .types import DisplayIdentifier, IntPercentage, Percentage
+ 16
+ 17_logger = logging.getLogger(__name__)
+ 18_logger.addHandler(logging.NullHandler())
+ 19
+ 20
+ 21def get_brightness(
+ 22    display: Optional[DisplayIdentifier] = None,
+ 23    method: Optional[str] = None,
+ 24    verbose_error: bool = False
+ 25) -> List[Union[IntPercentage, None]]:
+ 26    '''
+ 27    Returns the current brightness of one or more displays
+ 28
+ 29    Args:
+ 30        display (.types.DisplayIdentifier): the specific display to query
+ 31        method: the method to use to get the brightness. See `get_methods` for
+ 32            more info on available methods
+ 33        verbose_error: controls the level of detail in the error messages
+ 34
+ 35    Returns:
+ 36        A list of `.types.IntPercentage` values, each being the brightness of an
+ 37        individual display. Invalid displays may return None.
+ 38
+ 39    Example:
+ 40        ```python
+ 41        import screen_brightness_control as sbc
+ 42
+ 43        # get the current screen brightness (for all detected displays)
+ 44        current_brightness = sbc.get_brightness()
+ 45
+ 46        # get the brightness of the primary display
+ 47        primary_brightness = sbc.get_brightness(display=0)
+ 48
+ 49        # get the brightness of the secondary display (if connected)
+ 50        secondary_brightness = sbc.get_brightness(display=1)
+ 51        ```
+ 52    '''
+ 53    result = __brightness(display=display, method=method, meta_method='get', verbose_error=verbose_error)
+ 54    # __brightness can return None depending on the `no_return` kwarg. That obviously would never happen here
+ 55    # but the type checker doesn't see it that way.
+ 56    return [] if result is None else result
+ 57
+ 58
+ 59def set_brightness(
+ 60    value: Percentage,
+ 61    display: Optional[DisplayIdentifier] = None,
+ 62    method: Optional[str] = None,
+ 63    force: bool = False,
+ 64    verbose_error: bool = False,
+ 65    no_return: bool = True
+ 66) -> Optional[List[Union[IntPercentage, None]]]:
+ 67    '''
+ 68    Sets the brightness level of one or more displays to a given value.
+ 69
+ 70    Args:
+ 71        value (.types.Percentage): the new brightness level
+ 72        display (.types.DisplayIdentifier): the specific display to adjust
+ 73        method: the method to use to set the brightness. See `get_methods` for
+ 74            more info on available methods
+ 75        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+ 76            This is because on most displays a brightness of 0 will turn off the backlight.
+ 77            If True, this check is bypassed
+ 78        verbose_error: boolean value controls the amount of detail error messages will contain
+ 79        no_return: don't return the new brightness level(s)
+ 80
+ 81    Returns:
+ 82        If `no_return` is set to `True` (the default) then this function returns nothing.
+ 83        Otherwise, a list of `.types.IntPercentage` is returned, each item being the new
+ 84        brightness of each adjusted display (invalid displays may return None)
+ 85
+ 86    Example:
+ 87        ```python
+ 88        import screen_brightness_control as sbc
+ 89
+ 90        # set brightness to 50%
+ 91        sbc.set_brightness(50)
+ 92
+ 93        # set brightness to 0%
+ 94        sbc.set_brightness(0, force=True)
+ 95
+ 96        # increase brightness by 25%
+ 97        sbc.set_brightness('+25')
+ 98
+ 99        # decrease brightness by 30%
+100        sbc.set_brightness('-30')
+101
+102        # set the brightness of display 0 to 50%
+103        sbc.set_brightness(50, display=0)
+104        ```
+105    '''
+106    if isinstance(value, str) and ('+' in value or '-' in value):
+107        output: List[Union[IntPercentage, None]] = []
+108        for monitor in filter_monitors(display=display, method=method):
+109            identifier = Display.from_dict(monitor).get_identifier()[1]
+110
+111            current_value = get_brightness(display=identifier)[0]
+112            if current_value is None:
+113                # invalid displays can return None. In this case, assume
+114                # the brightness to be 100, which is what many displays default to.
+115                logging.warning(
+116                    'set_brightness: unable to get current brightness level for display with identifier'
+117                    f' {identifier}. Assume value to be 100'
+118                )
+119                current_value = 100
+120
+121            result = set_brightness(
+122                # don't need to calculate lower bound here because it will be
+123                # done by the other path in `set_brightness`
+124                percentage(value, current=current_value),
+125                display=identifier,
+126                force=force,
+127                verbose_error=verbose_error,
+128                no_return=no_return
+129            )
+130            if result is None:
+131                output.append(result)
+132            else:
+133                output += result
+134
+135        return output
+136
+137    if platform.system() == 'Linux' and not force:
+138        lower_bound = 1
+139    else:
+140        lower_bound = 0
+141
+142    value = percentage(value, lower_bound=lower_bound)
+143
+144    return __brightness(
+145        value, display=display, method=method,
+146        meta_method='set', no_return=no_return,
+147        verbose_error=verbose_error
+148    )
+149
+150
+151def fade_brightness(
+152    finish: Percentage,
+153    start: Optional[Percentage] = None,
+154    interval: float = 0.01,
+155    increment: int = 1,
+156    blocking: bool = True,
+157    force: bool = False,
+158    logarithmic: bool = True,
+159    **kwargs
+160) -> Union[List[threading.Thread], List[Union[IntPercentage, None]]]:
+161    '''
+162    Gradually change the brightness of one or more displays
+163
+164    Args:
+165        finish (.types.Percentage): fade to this brightness level
+166        start (.types.Percentage): where the brightness should fade from.
+167            If this arg is not specified, the fade will be started from the
+168            current brightness.
+169        interval: the time delay between each step in brightness
+170        increment: the amount to change the brightness by per step
+171        blocking: whether this should occur in the main thread (`True`) or a new daemonic thread (`False`)
+172        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+173            This is because on most displays a brightness of 0 will turn off the backlight.
+174            If True, this check is bypassed
+175        logarithmic: follow a logarithmic brightness curve when adjusting the brightness
+176        **kwargs: passed through to `filter_monitors` for display selection.
+177            Will also be passed to `get_brightness` if `blocking is True`
+178
+179    Returns:
+180        By default, this function calls `get_brightness()` to return the new
+181        brightness of any adjusted displays.
+182
+183        If `blocking` is set to `False`, then a list of threads are
+184        returned, one for each display being faded.
+185
+186    Example:
+187        ```python
+188        import screen_brightness_control as sbc
+189
+190        # fade brightness from the current brightness to 50%
+191        sbc.fade_brightness(50)
+192
+193        # fade the brightness from 25% to 75%
+194        sbc.fade_brightness(75, start=25)
+195
+196        # fade the brightness from the current value to 100% in steps of 10%
+197        sbc.fade_brightness(100, increment=10)
+198
+199        # fade the brightness from 100% to 90% with time intervals of 0.1 seconds
+200        sbc.fade_brightness(90, start=100, interval=0.1)
+201
+202        # fade the brightness to 100% in a new thread
+203        sbc.fade_brightness(100, blocking=False)
+204        ```
+205    '''
+206    # make sure only compatible kwargs are passed to filter_monitors
+207    available_monitors = filter_monitors(
+208        **{k: v for k, v in kwargs.items() if k in (
+209            'display', 'haystack', 'method', 'include'
+210        )}
+211    )
+212
+213    threads = []
+214    for i in available_monitors:
+215        display = Display.from_dict(i)
+216
+217        thread = threading.Thread(target=display.fade_brightness, args=(finish,), kwargs={
+218            'start': start,
+219            'interval': interval,
+220            'increment': increment,
+221            'force': force,
+222            'logarithmic': logarithmic
+223        })
+224        thread.start()
+225        threads.append(thread)
+226
+227    if not blocking:
+228        return threads
+229
+230    for t in threads:
+231        t.join()
+232    return get_brightness(**kwargs)
+233
+234
+235def list_monitors_info(
+236    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+237) -> List[dict]:
+238    '''
+239    List detailed information about all displays that are controllable by this library
+240
+241    Args:
+242        method: the method to use to list the available displays. See `get_methods` for
+243            more info on available methods
+244        allow_duplicates: whether to filter out duplicate displays or not
+245        unsupported: include detected displays that are invalid or unsupported
+246
+247    Returns:
+248        list: list of dictionaries containing information about the detected displays
+249
+250    Example:
+251        ```python
+252        import screen_brightness_control as sbc
+253        displays = sbc.list_monitors_info()
+254        for display in displays:
+255            print('=======================')
+256            # the manufacturer name plus the model
+257            print('Name:', display['name'])
+258            # the general model of the display
+259            print('Model:', display['model'])
+260            # the serial of the display
+261            print('Serial:', display['serial'])
+262            # the name of the brand of the display
+263            print('Manufacturer:', display['manufacturer'])
+264            # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ
+265            print('Manufacturer ID:', display['manufacturer_id'])
+266            # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES
+267            print('Index:', display['index'])
+268            # the method this display can be addressed by
+269            print('Method:', display['method'])
+270            # the EDID string associated with that display
+271            print('EDID:', display['edid'])
+272        ```
+273    '''
+274    return _OS_MODULE.list_monitors_info(
+275        method=method, allow_duplicates=allow_duplicates, unsupported=unsupported
+276    )
+277
+278
+279def list_monitors(method: Optional[str] = None) -> List[str]:
+280    '''
+281    List the names of all detected displays
+282
+283    Args:
+284        method: the method to use to list the available displays. See `get_methods` for
+285            more info on available methods
+286
+287    Example:
+288        ```python
+289        import screen_brightness_control as sbc
+290        display_names = sbc.list_monitors()
+291        # eg: ['BenQ GL2450H', 'Dell U2211H']
+292        ```
+293    '''
+294    return [i['name'] for i in list_monitors_info(method=method)]
+295
+296
+297def get_methods(name: Optional[str] = None) -> Dict[str, Type[BrightnessMethod]]:
+298    '''
+299    Returns all available brightness method names and their associated classes.
+300
+301    Args:
+302        name: if specified, return the method corresponding to this name
+303
+304    Raises:
+305        ValueError: if the given name is incorrect
+306
+307    Example:
+308        ```python
+309        import screen_brightness_control as sbc
+310
+311        all_methods = sbc.get_methods()
+312
+313        for method_name, method_class in all_methods.items():
+314            print('Method:', method_name)
+315            print('Class:', method_class)
+316            print('Associated monitors:', sbc.list_monitors(method=method_name))
+317        ```
+318    '''
+319    methods = {i.__name__.lower(): i for i in _OS_METHODS}
+320
+321    if name is None:
+322        return methods
+323
+324    if not isinstance(name, str):
+325        raise TypeError(f'name must be of type str, not {type(name)!r}')
+326
+327    name = name.lower()
+328    if name in methods:
+329        return {name: methods[name]}
+330
+331    _logger.debug(f'requested method {name!r} invalid')
+332    raise ValueError(
+333        f'invalid method {name!r}, must be one of: {list(methods)}')
+334
+335
+336@dataclass
+337class Display():
+338    '''
+339    Represents a single connected display.
+340    '''
+341    index: int
+342    '''The index of the display relative to the method it uses.
+343    So if the index is 0 and the method is `windows.VCP`, then this is the 1st
+344    display reported by `windows.VCP`, not the first display overall.'''
+345    method: Type[BrightnessMethod]
+346    '''The method by which this monitor can be addressed.
+347    This will be a class from either the windows or linux sub-module'''
+348
+349    edid: Optional[str] = None
+350    '''A 256 character hex string containing information about a display and its capabilities'''
+351    manufacturer: Optional[str] = None
+352    '''Name of the display's manufacturer'''
+353    manufacturer_id: Optional[str] = None
+354    '''3 letter code corresponding to the manufacturer name'''
+355    model: Optional[str] = None
+356    '''Model name of the display'''
+357    name: Optional[str] = None
+358    '''The name of the display, often the manufacturer name plus the model name'''
+359    serial: Optional[str] = None
+360    '''The serial number of the display or (if serial is not available) an ID assigned by the OS'''
+361
+362    _logger: logging.Logger = field(init=False, repr=False)
+363
+364    def __post_init__(self):
+365        self._logger = _logger.getChild(self.__class__.__name__).getChild(
+366            str(self.get_identifier()[1])[:20])
+367
+368    def fade_brightness(
+369        self,
+370        finish: Percentage,
+371        start: Optional[Percentage] = None,
+372        interval: float = 0.01,
+373        increment: int = 1,
+374        force: bool = False,
+375        logarithmic: bool = True
+376    ) -> IntPercentage:
+377        '''
+378        Gradually change the brightness of this display to a set value.
+379        This works by incrementally changing the brightness until the desired
+380        value is reached.
+381
+382        Args:
+383            finish (.types.Percentage): the brightness level to end up on
+384            start (.types.Percentage): where the fade should start from. Defaults
+385                to whatever the current brightness level for the display is
+386            interval: time delay between each change in brightness
+387            increment: amount to change the brightness by each time (as a percentage)
+388            force: [*Linux only*] allow the brightness to be set to 0. By default,
+389                brightness values will never be set lower than 1, since setting them to 0
+390                often turns off the backlight
+391            logarithmic: follow a logarithmic curve when setting brightness values.
+392                See `logarithmic_range` for rationale
+393
+394        Returns:
+395            The brightness of the display after the fade is complete.
+396            See `.types.IntPercentage`
+397
+398            .. warning:: Deprecated
+399               This function will return `None` in v0.23.0 and later.
+400        '''
+401        # minimum brightness value
+402        if platform.system() == 'Linux' and not force:
+403            lower_bound = 1
+404        else:
+405            lower_bound = 0
+406
+407        current = self.get_brightness()
+408
+409        finish = percentage(finish, current, lower_bound)
+410        start = percentage(
+411            current if start is None else start, current, lower_bound)
+412
+413        # mypy says "object is not callable" but range is. Ignore this
+414        range_func: Callable = logarithmic_range if logarithmic else range  # type: ignore[assignment]
+415        increment = abs(increment)
+416        if start > finish:
+417            increment = -increment
+418
+419        self._logger.debug(
+420            f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+421
+422        for value in range_func(start, finish, increment):
+423            self.set_brightness(value, force=force)
+424            time.sleep(interval)
+425
+426        if self.get_brightness() != finish:
+427            self.set_brightness(finish, force=force)
+428
+429        return self.get_brightness()
+430
+431    @classmethod
+432    def from_dict(cls, display: dict) -> 'Display':
+433        '''
+434        Initialise an instance of the class from a dictionary, ignoring
+435        any unwanted keys
+436        '''
+437        return cls(
+438            index=display['index'],
+439            method=display['method'],
+440            edid=display['edid'],
+441            manufacturer=display['manufacturer'],
+442            manufacturer_id=display['manufacturer_id'],
+443            model=display['model'],
+444            name=display['name'],
+445            serial=display['serial']
+446        )
+447
+448    def get_brightness(self) -> IntPercentage:
+449        '''
+450        Returns the brightness of this display.
+451
+452        Returns:
+453            The brightness value of the display, as a percentage.
+454            See `.types.IntPercentage`
+455        '''
+456        return self.method.get_brightness(display=self.index)[0]
+457
+458    def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+459        '''
+460        Returns the `.types.DisplayIdentifier` for this display.
+461        Will iterate through the EDID, serial, name and index and return the first
+462        value that is not equal to None
+463
+464        Returns:
+465            The name of the property returned and the value of said property.
+466            EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+467        '''
+468        for key in ('edid', 'serial', 'name'):
+469            value = getattr(self, key, None)
+470            if value is not None:
+471                return key, value
+472        # the index should surely never be `None`
+473        return 'index', self.index
+474
+475    def is_active(self) -> bool:
+476        '''
+477        Attempts to retrieve the brightness for this display. If it works the display is deemed active
+478        '''
+479        try:
+480            self.get_brightness()
+481            return True
+482        except Exception as e:
+483            self._logger.error(
+484                f'Monitor.is_active: {self.get_identifier()} failed get_brightness call'
+485                f' - {format_exc(e)}'
+486            )
+487            return False
+488
+489    def set_brightness(self, value: Percentage, force: bool = False):
+490        '''
+491        Sets the brightness for this display. See `set_brightness` for the full docs
+492
+493        Args:
+494            value (.types.Percentage): the brightness percentage to set the display to
+495            force: allow the brightness to be set to 0 on Linux. This is disabled by default
+496                because setting the brightness of 0 will often turn off the backlight
+497        '''
+498        # convert brightness value to percentage
+499        if platform.system() == 'Linux' and not force:
+500            lower_bound = 1
+501        else:
+502            lower_bound = 0
+503
+504        value = percentage(
+505            value,
+506            current=self.get_brightness,
+507            lower_bound=lower_bound
+508        )
+509
+510        self.method.set_brightness(value, display=self.index)
+511
+512
+513class Monitor(Display):
+514    '''
+515    Legacy class for managing displays.
+516
+517    .. warning:: Deprecated
+518       Deprecated for removal in v0.23.0. Please use the new `Display` class instead
+519    '''
+520
+521    def __init__(self, display: Union[int, str, dict]):
+522        '''
+523        Args:
+524            display (.types.DisplayIdentifier or dict): the display you
+525                wish to control. Is passed to `filter_monitors`
+526                to decide which display to use.
+527
+528        Example:
+529            ```python
+530            import screen_brightness_control as sbc
+531
+532            # create a class for the primary display and then a specifically named monitor
+533            primary = sbc.Monitor(0)
+534            benq_monitor = sbc.Monitor('BenQ GL2450H')
+535
+536            # check if the benq monitor is the primary one
+537            if primary.serial == benq_monitor.serial:
+538                print('BenQ GL2450H is the primary display')
+539            else:
+540                print('The primary display is', primary.name)
+541            ```
+542        '''
+543        warnings.warn(
+544            (
+545                '`Monitor` is deprecated for removal in v0.23.0.'
+546                ' Please use the new `Display` class instead'
+547            ),
+548            DeprecationWarning
+549        )
+550
+551        monitors_info = list_monitors_info(allow_duplicates=True)
+552        if isinstance(display, dict):
+553            if display in monitors_info:
+554                info = display
+555            else:
+556                info = filter_monitors(
+557                    display=self.get_identifier(display)[1],
+558                    haystack=monitors_info
+559                )[0]
+560        else:
+561            info = filter_monitors(display=display, haystack=monitors_info)[0]
+562
+563        # make a copy so that we don't alter the dict in-place
+564        info = info.copy()
+565
+566        kw = [i.name for i in fields(Display) if i.init]
+567        super().__init__(**{k: v for k, v in info.items() if k in kw})
+568
+569        # this assigns any extra info that is returned to this class
+570        # eg: the 'interface' key in XRandr monitors on Linux
+571        for key, value in info.items():
+572            if key not in kw and value is not None:
+573                setattr(self, key, value)
+574
+575    def get_identifier(self, monitor: Optional[dict] = None) -> Tuple[str, DisplayIdentifier]:
+576        '''
+577        Returns the `.types.DisplayIdentifier` for this display.
+578        Will iterate through the EDID, serial, name and index and return the first
+579        value that is not equal to None
+580
+581        Args:
+582            monitor: extract an identifier from this dict instead of the monitor class
+583
+584        Returns:
+585            A tuple containing the name of the property returned and the value of said
+586            property. EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+587
+588        Example:
+589            ```python
+590            import screen_brightness_control as sbc
+591            primary = sbc.Monitor(0)
+592            print(primary.get_identifier())  # eg: ('serial', '123abc...')
+593
+594            secondary = sbc.list_monitors_info()[1]
+595            print(primary.get_identifier(monitor=secondary))  # eg: ('serial', '456def...')
+596
+597            # you can also use the class uninitialized
+598            print(sbc.Monitor.get_identifier(secondary))  # eg: ('serial', '456def...')
+599            ```
+600        '''
+601        if monitor is None:
+602            if isinstance(self, dict):
+603                monitor = self
+604            else:
+605                return super().get_identifier()
+606
+607        for key in ('edid', 'serial', 'name'):
+608            value = monitor[key]
+609            if value is not None:
+610                return key, value
+611        return 'index', self.index
+612
+613    def set_brightness(
+614        self,
+615        value: Percentage,
+616        no_return: bool = True,
+617        force: bool = False
+618    ) -> Optional[IntPercentage]:
+619        '''
+620        Wrapper for `Display.set_brightness`
+621
+622        Args:
+623            value: see `Display.set_brightness`
+624            no_return: do not return the new brightness after it has been set
+625            force: see `Display.set_brightness`
+626        '''
+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        super().set_brightness(value, force)
+631        if no_return:
+632            return None
+633        return self.get_brightness()
+634
+635    def get_brightness(self) -> IntPercentage:
+636        # refresh display info, in case another display has been unplugged or something
+637        # which would change the index of this display
+638        self.get_info()
+639        return super().get_brightness()
+640
+641    def fade_brightness(
+642        self,
+643        *args,
+644        blocking: bool = True,
+645        **kwargs
+646    ) -> Union[threading.Thread, IntPercentage]:
+647        '''
+648        Wrapper for `Display.fade_brightness`
+649
+650        Args:
+651            *args: see `Display.fade_brightness`
+652            blocking: run this function in the current thread and block until
+653                it completes. If `False`, the fade will be run in a new daemonic
+654                thread, which will be started and returned
+655            **kwargs: see `Display.fade_brightness`
+656        '''
+657        if blocking:
+658            super().fade_brightness(*args, **kwargs)
+659            return self.get_brightness()
+660
+661        thread = threading.Thread(
+662            target=super().fade_brightness, args=args, kwargs=kwargs, daemon=True)
+663        thread.start()
+664        return thread
+665
+666    @classmethod
+667    def from_dict(cls, display) -> 'Monitor':
+668        return cls(display)
+669
+670    def get_info(self, refresh: bool = True) -> dict:
+671        '''
+672        Returns all known information about this monitor instance
+673
+674        Args:
+675            refresh: whether to refresh the information
+676                or to return the cached version
+677
+678        Example:
+679            ```python
+680            import screen_brightness_control as sbc
+681
+682            # initialize class for primary display
+683            primary = sbc.Monitor(0)
+684            # get the info
+685            info = primary.get_info()
+686            ```
+687        '''
+688        def vars_self():
+689            return {k: v for k, v in vars(self).items() if not k.startswith('_')}
+690
+691        if not refresh:
+692            return vars_self()
+693
+694        identifier = self.get_identifier()
+695
+696        if identifier is not None:
+697            # refresh the info we have on this monitor
+698            info = filter_monitors(
+699                display=identifier[1], method=self.method.__name__)[0]
+700            for key, value in info.items():
+701                if value is not None:
+702                    setattr(self, key, value)
+703
+704        return vars_self()
+705
+706
+707def filter_monitors(
+708    display: Optional[DisplayIdentifier] = None,
+709    haystack: Optional[List[dict]] = None,
+710    method: Optional[str] = None,
+711    include: List[str] = []
+712) -> List[dict]:
+713    '''
+714    Searches through the information for all detected displays
+715    and attempts to return the info matching the value given.
+716    Will attempt to match against index, name, edid, method and serial
+717
+718    Args:
+719        display (.types.DisplayIdentifier): the display you are searching for
+720        haystack: the information to filter from.
+721            If this isn't set it defaults to the return of `list_monitors_info`
+722        method: the method the monitors use. See `get_methods` for
+723            more info on available methods
+724        include: extra fields of information to sort by
+725
+726    Raises:
+727        NoValidDisplayError: if the display does not have a match
+728        TypeError: if the `display` kwarg is not `int` or `str`
+729
+730    Example:
+731        ```python
+732        import screen_brightness_control as sbc
+733
+734        search = 'GL2450H'
+735        match = sbc.filter_displays(search)
+736        print(match)
+737        # EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]
+738        ```
+739    '''
+740    if display is not None and type(display) not in (str, int):
+741        raise TypeError(
+742            f'display kwarg must be int or str, not "{type(display).__name__}"')
+743
+744    def get_monitor_list():
+745        # if we have been provided with a list of monitors to sift through then use that
+746        # otherwise, get the info ourselves
+747        if haystack is not None:
+748            monitors_with_duplicates = haystack
+749            if method is not None:
+750                method_class = next(iter(get_methods(method).values()))
+751                monitors_with_duplicates = [
+752                    i for i in haystack if i['method'] == method_class]
+753        else:
+754            monitors_with_duplicates = list_monitors_info(
+755                method=method, allow_duplicates=True)
+756
+757        return monitors_with_duplicates
+758
+759    def filter_monitor_list(to_filter):
+760        # This loop does two things:
+761        # 1. Filters out duplicate monitors
+762        # 2. Matches the display kwarg (if applicable)
+763        filtered_displays = {}
+764        for monitor in to_filter:
+765            # find a valid identifier for a monitor, excluding any which are equal to None
+766            added = False
+767            for identifier in ['edid', 'serial', 'name'] + include:
+768                if monitor.get(identifier, None) is None:
+769                    continue
+770
+771                m_id = monitor[identifier]
+772                if m_id in filtered_displays:
+773                    break
+774
+775                if isinstance(display, str) and m_id != display:
+776                    continue
+777
+778                # check we haven't already added the monitor
+779                if not added:
+780                    filtered_displays[m_id] = monitor
+781                    added = True
+782
+783                # if the display kwarg is an integer and we are currently at that index
+784                if isinstance(display, int) and len(filtered_displays) - 1 == display:
+785                    return [monitor]
+786
+787                if added:
+788                    break
+789        return list(filtered_displays.values())
+790
+791    duplicates = []
+792    for _ in range(3):
+793        duplicates = get_monitor_list()
+794        if duplicates:
+795            break
+796        time.sleep(0.4)
+797    else:
+798        msg = 'no displays detected'
+799        if method is not None:
+800            msg += f' with method: {method!r}'
+801        raise NoValidDisplayError(msg)
+802
+803    monitors = filter_monitor_list(duplicates)
+804    if not monitors:
+805        # if no displays matched the query
+806        msg = 'no displays found'
+807        if display is not None:
+808            msg += f' with name/serial/edid/index of {display!r}'
+809        if method is not None:
+810            msg += f' with method of {method!r}'
+811        raise NoValidDisplayError(msg)
+812
+813    return monitors
+814
+815
+816def __brightness(
+817    *args, display=None, method=None, meta_method='get', no_return=False,
+818    verbose_error=False, **kwargs
+819) -> Optional[List[Union[IntPercentage, None]]]:
+820    '''Internal function used to get/set brightness'''
+821    _logger.debug(
+822        f"brightness {meta_method} request display {display} with method {method}")
+823
+824    output: List[Union[int, None]] = []
+825    errors = []
+826
+827    for monitor in filter_monitors(display=display, method=method):
+828        try:
+829            if meta_method == 'set':
+830                monitor['method'].set_brightness(
+831                    *args, display=monitor['index'], **kwargs)
+832                if no_return:
+833                    output.append(None)
+834                    continue
+835
+836            output += monitor['method'].get_brightness(
+837                display=monitor['index'], **kwargs)
+838        except Exception as e:
+839            output.append(None)
+840            errors.append((
+841                monitor, e.__class__.__name__,
+842                traceback.format_exc() if verbose_error else e
+843            ))
+844
+845    if output:
+846        output_is_none = set(output) == {None}
+847        if (
+848            # can't have None output if we are trying to get the brightness
+849            (meta_method == 'get' and not output_is_none)
+850            or (
+851                # if we are setting the brightness then we CAN have a None output
+852                # but only if no_return is True.
+853                meta_method == 'set'
+854                and ((no_return and output_is_none) or not output_is_none)
+855            )
+856        ):
+857            return None if no_return else output
+858
+859    # if the function hasn't returned then it has failed
+860    msg = '\n'
+861    if errors:
+862        for monitor, exc_name, exc in errors:
+863            if isinstance(monitor, str):
+864                msg += f'\t{monitor}'
+865            else:
+866                msg += f'\t{monitor["name"]} ({monitor["serial"]})'
+867            msg += f' -> {exc_name}: '
+868            msg += str(exc).replace('\n', '\n\t\t') + '\n'
+869    else:
+870        msg += '\tno valid output was received from brightness methods'
+871
+872    raise ScreenBrightnessError(msg)
+873
+874
+875_OS_MODULE: ModuleType
+876_OS_METHODS: Tuple[Type[BrightnessMethod], ...]
+877if platform.system() == 'Windows':
+878    from . import windows
+879    _OS_MODULE = windows
+880    _OS_METHODS = windows.METHODS
+881elif platform.system() == 'Linux':
+882    from . import linux
+883    _OS_MODULE = linux
+884    _OS_METHODS = linux.METHODS
+885else:
+886    _logger.warning(
+887        f'package imported on unsupported platform ({platform.system()})')
+
+ + +
+ +
+
+ +
+ + def + get_brightness( display: Union[str, int, NoneType] = None, method: Optional[str] = None, verbose_error: bool = False) -> List[Optional[int]]: + + + +
+ + 
22def get_brightness(
+23    display: Optional[DisplayIdentifier] = None,
+24    method: Optional[str] = None,
+25    verbose_error: bool = False
+26) -> List[Union[IntPercentage, None]]:
+27    '''
+28    Returns the current brightness of one or more displays
+29
+30    Args:
+31        display (.types.DisplayIdentifier): the specific display to query
+32        method: the method to use to get the brightness. See `get_methods` for
+33            more info on available methods
+34        verbose_error: controls the level of detail in the error messages
+35
+36    Returns:
+37        A list of `.types.IntPercentage` values, each being the brightness of an
+38        individual display. Invalid displays may return None.
+39
+40    Example:
+41        ```python
+42        import screen_brightness_control as sbc
+43
+44        # get the current screen brightness (for all detected displays)
+45        current_brightness = sbc.get_brightness()
+46
+47        # get the brightness of the primary display
+48        primary_brightness = sbc.get_brightness(display=0)
+49
+50        # get the brightness of the secondary display (if connected)
+51        secondary_brightness = sbc.get_brightness(display=1)
+52        ```
+53    '''
+54    result = __brightness(display=display, method=method, meta_method='get', verbose_error=verbose_error)
+55    # __brightness can return None depending on the `no_return` kwarg. That obviously would never happen here
+56    # but the type checker doesn't see it that way.
+57    return [] if result is None else result
+
+ + +

Returns the current brightness of one or more displays

+ +
Arguments:
+ + + +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, each being the brightness of an + individual display. Invalid displays may return None.

+
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+# get the current screen brightness (for all detected displays)
+current_brightness = sbc.get_brightness()
+
+# get the brightness of the primary display
+primary_brightness = sbc.get_brightness(display=0)
+
+# get the brightness of the secondary display (if connected)
+secondary_brightness = sbc.get_brightness(display=1)
+
+
+
+
+ + +
+
+ +
+ + 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[Optional[int]]]: + + + +
+ + 
 60def set_brightness(
+ 61    value: Percentage,
+ 62    display: Optional[DisplayIdentifier] = None,
+ 63    method: Optional[str] = None,
+ 64    force: bool = False,
+ 65    verbose_error: bool = False,
+ 66    no_return: bool = True
+ 67) -> Optional[List[Union[IntPercentage, None]]]:
+ 68    '''
+ 69    Sets the brightness level of one or more displays to a given value.
+ 70
+ 71    Args:
+ 72        value (.types.Percentage): the new brightness level
+ 73        display (.types.DisplayIdentifier): the specific display to adjust
+ 74        method: the method to use to set the brightness. See `get_methods` for
+ 75            more info on available methods
+ 76        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+ 77            This is because on most displays a brightness of 0 will turn off the backlight.
+ 78            If True, this check is bypassed
+ 79        verbose_error: boolean value controls the amount of detail error messages will contain
+ 80        no_return: don't return the new brightness level(s)
+ 81
+ 82    Returns:
+ 83        If `no_return` is set to `True` (the default) then this function returns nothing.
+ 84        Otherwise, a list of `.types.IntPercentage` is returned, each item being the new
+ 85        brightness of each adjusted display (invalid displays may return None)
+ 86
+ 87    Example:
+ 88        ```python
+ 89        import screen_brightness_control as sbc
+ 90
+ 91        # set brightness to 50%
+ 92        sbc.set_brightness(50)
+ 93
+ 94        # set brightness to 0%
+ 95        sbc.set_brightness(0, force=True)
+ 96
+ 97        # increase brightness by 25%
+ 98        sbc.set_brightness('+25')
+ 99
+100        # decrease brightness by 30%
+101        sbc.set_brightness('-30')
+102
+103        # set the brightness of display 0 to 50%
+104        sbc.set_brightness(50, display=0)
+105        ```
+106    '''
+107    if isinstance(value, str) and ('+' in value or '-' in value):
+108        output: List[Union[IntPercentage, None]] = []
+109        for monitor in filter_monitors(display=display, method=method):
+110            identifier = Display.from_dict(monitor).get_identifier()[1]
+111
+112            current_value = get_brightness(display=identifier)[0]
+113            if current_value is None:
+114                # invalid displays can return None. In this case, assume
+115                # the brightness to be 100, which is what many displays default to.
+116                logging.warning(
+117                    'set_brightness: unable to get current brightness level for display with identifier'
+118                    f' {identifier}. Assume value to be 100'
+119                )
+120                current_value = 100
+121
+122            result = set_brightness(
+123                # don't need to calculate lower bound here because it will be
+124                # done by the other path in `set_brightness`
+125                percentage(value, current=current_value),
+126                display=identifier,
+127                force=force,
+128                verbose_error=verbose_error,
+129                no_return=no_return
+130            )
+131            if result is None:
+132                output.append(result)
+133            else:
+134                output += result
+135
+136        return output
+137
+138    if platform.system() == 'Linux' and not force:
+139        lower_bound = 1
+140    else:
+141        lower_bound = 0
+142
+143    value = percentage(value, lower_bound=lower_bound)
+144
+145    return __brightness(
+146        value, display=display, method=method,
+147        meta_method='set', no_return=no_return,
+148        verbose_error=verbose_error
+149    )
+
+ + +

Sets the brightness level of one or more displays to a given value.

+ +
Arguments:
+ +
    +
  • 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. +This is because on most displays a brightness of 0 will turn off the backlight. +If True, this check is bypassed
    • +
  • verbose_error: boolean value controls the amount of detail error messages will contain
    • +
  • no_return: don't return the new brightness level(s)
    • +
+ +
Returns:
+ +
+

If no_return is set to True (the default) then this function returns nothing. + 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)

+
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+# set brightness to 50%
+sbc.set_brightness(50)
+
+# set brightness to 0%
+sbc.set_brightness(0, force=True)
+
+# increase brightness by 25%
+sbc.set_brightness('+25')
+
+# decrease brightness by 30%
+sbc.set_brightness('-30')
+
+# set the brightness of display 0 to 50%
+sbc.set_brightness(50, display=0)
+
+
+
+
+ + +
+
+ +
+ + 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[Optional[int]]]: + + + +
+ + 
152def fade_brightness(
+153    finish: Percentage,
+154    start: Optional[Percentage] = None,
+155    interval: float = 0.01,
+156    increment: int = 1,
+157    blocking: bool = True,
+158    force: bool = False,
+159    logarithmic: bool = True,
+160    **kwargs
+161) -> Union[List[threading.Thread], List[Union[IntPercentage, None]]]:
+162    '''
+163    Gradually change the brightness of one or more displays
+164
+165    Args:
+166        finish (.types.Percentage): fade to this brightness level
+167        start (.types.Percentage): where the brightness should fade from.
+168            If this arg is not specified, the fade will be started from the
+169            current brightness.
+170        interval: the time delay between each step in brightness
+171        increment: the amount to change the brightness by per step
+172        blocking: whether this should occur in the main thread (`True`) or a new daemonic thread (`False`)
+173        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+174            This is because on most displays a brightness of 0 will turn off the backlight.
+175            If True, this check is bypassed
+176        logarithmic: follow a logarithmic brightness curve when adjusting the brightness
+177        **kwargs: passed through to `filter_monitors` for display selection.
+178            Will also be passed to `get_brightness` if `blocking is True`
+179
+180    Returns:
+181        By default, this function calls `get_brightness()` to return the new
+182        brightness of any adjusted displays.
+183
+184        If `blocking` is set to `False`, then a list of threads are
+185        returned, one for each display being faded.
+186
+187    Example:
+188        ```python
+189        import screen_brightness_control as sbc
+190
+191        # fade brightness from the current brightness to 50%
+192        sbc.fade_brightness(50)
+193
+194        # fade the brightness from 25% to 75%
+195        sbc.fade_brightness(75, start=25)
+196
+197        # fade the brightness from the current value to 100% in steps of 10%
+198        sbc.fade_brightness(100, increment=10)
+199
+200        # fade the brightness from 100% to 90% with time intervals of 0.1 seconds
+201        sbc.fade_brightness(90, start=100, interval=0.1)
+202
+203        # fade the brightness to 100% in a new thread
+204        sbc.fade_brightness(100, blocking=False)
+205        ```
+206    '''
+207    # make sure only compatible kwargs are passed to filter_monitors
+208    available_monitors = filter_monitors(
+209        **{k: v for k, v in kwargs.items() if k in (
+210            'display', 'haystack', 'method', 'include'
+211        )}
+212    )
+213
+214    threads = []
+215    for i in available_monitors:
+216        display = Display.from_dict(i)
+217
+218        thread = threading.Thread(target=display.fade_brightness, args=(finish,), kwargs={
+219            'start': start,
+220            'interval': interval,
+221            'increment': increment,
+222            'force': force,
+223            'logarithmic': logarithmic
+224        })
+225        thread.start()
+226        threads.append(thread)
+227
+228    if not blocking:
+229        return threads
+230
+231    for t in threads:
+232        t.join()
+233    return get_brightness(**kwargs)
+
+ + +

Gradually change the brightness of one or more displays

+ +
Arguments:
+ +
    +
  • finish (screen_brightness_control.types.Percentage): fade to this brightness level
    • +
  • start (screen_brightness_control.types.Percentage): where the brightness should fade from. +If this arg is not specified, the fade will be started from the +current brightness.
    • +
  • interval: the time delay between each step in brightness
    • +
  • increment: the amount to change the brightness by per step
    • +
  • blocking: whether this should occur in the main thread (True) or a new daemonic thread (False)
    • +
  • force: [Linux Only] if False the brightness will never be set lower than 1. +This is because on most displays a brightness of 0 will turn off the backlight. +If True, this check is bypassed
    • +
  • logarithmic: follow a logarithmic brightness curve when adjusting the brightness
    • +
  • **kwargs: passed through to filter_monitors for display selection. +Will also be passed to get_brightness if blocking is True
    • +
+ +
Returns:
+ +
+

By default, this function calls get_brightness() to return the new + brightness of any adjusted displays.

+ +

If blocking is set to False, then a list of threads are + returned, one for each display being faded.

+
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+# fade brightness from the current brightness to 50%
+sbc.fade_brightness(50)
+
+# fade the brightness from 25% to 75%
+sbc.fade_brightness(75, start=25)
+
+# fade the brightness from the current value to 100% in steps of 10%
+sbc.fade_brightness(100, increment=10)
+
+# fade the brightness from 100% to 90% with time intervals of 0.1 seconds
+sbc.fade_brightness(90, start=100, interval=0.1)
+
+# fade the brightness to 100% in a new thread
+sbc.fade_brightness(100, blocking=False)
+
+
+
+
+ + +
+
+ +
+ + def + list_monitors_info( method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False) -> List[dict]: + + + +
+ + 
236def list_monitors_info(
+237    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+238) -> List[dict]:
+239    '''
+240    List detailed information about all displays that are controllable by this library
+241
+242    Args:
+243        method: the method to use to list the available displays. See `get_methods` for
+244            more info on available methods
+245        allow_duplicates: whether to filter out duplicate displays or not
+246        unsupported: include detected displays that are invalid or unsupported
+247
+248    Returns:
+249        list: list of dictionaries containing information about the detected displays
+250
+251    Example:
+252        ```python
+253        import screen_brightness_control as sbc
+254        displays = sbc.list_monitors_info()
+255        for display in displays:
+256            print('=======================')
+257            # the manufacturer name plus the model
+258            print('Name:', display['name'])
+259            # the general model of the display
+260            print('Model:', display['model'])
+261            # the serial of the display
+262            print('Serial:', display['serial'])
+263            # the name of the brand of the display
+264            print('Manufacturer:', display['manufacturer'])
+265            # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ
+266            print('Manufacturer ID:', display['manufacturer_id'])
+267            # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES
+268            print('Index:', display['index'])
+269            # the method this display can be addressed by
+270            print('Method:', display['method'])
+271            # the EDID string associated with that display
+272            print('EDID:', display['edid'])
+273        ```
+274    '''
+275    return _OS_MODULE.list_monitors_info(
+276        method=method, allow_duplicates=allow_duplicates, unsupported=unsupported
+277    )
+
+ + +

List detailed information about all displays that are controllable by this library

+ +
Arguments:
+ +
    +
  • method: the method to use to list the available displays. See get_methods for +more info on available methods
    • +
  • allow_duplicates: whether to filter out duplicate displays or not
    • +
  • unsupported: include detected displays that are invalid or unsupported
    • +
+ +
Returns:
+ +
+

list: list of dictionaries containing information about the detected displays

+
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+displays = sbc.list_monitors_info()
+for display in displays:
+    print('=======================')
+    # the manufacturer name plus the model
+    print('Name:', display['name'])
+    # the general model of the display
+    print('Model:', display['model'])
+    # the serial of the display
+    print('Serial:', display['serial'])
+    # the name of the brand of the display
+    print('Manufacturer:', display['manufacturer'])
+    # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ
+    print('Manufacturer ID:', display['manufacturer_id'])
+    # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES
+    print('Index:', display['index'])
+    # the method this display can be addressed by
+    print('Method:', display['method'])
+    # the EDID string associated with that display
+    print('EDID:', display['edid'])
+
+
+
+
+ + +
+
+ +
+ + def + list_monitors(method: Optional[str] = None) -> List[str]: + + + +
+ + 
280def list_monitors(method: Optional[str] = None) -> List[str]:
+281    '''
+282    List the names of all detected displays
+283
+284    Args:
+285        method: the method to use to list the available displays. See `get_methods` for
+286            more info on available methods
+287
+288    Example:
+289        ```python
+290        import screen_brightness_control as sbc
+291        display_names = sbc.list_monitors()
+292        # eg: ['BenQ GL2450H', 'Dell U2211H']
+293        ```
+294    '''
+295    return [i['name'] for i in list_monitors_info(method=method)]
+
+ + +

List the names of all detected displays

+ +
Arguments:
+ +
    +
  • method: the method to use to list the available displays. See get_methods for +more info on available methods
    • +
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+display_names = sbc.list_monitors()
+# eg: ['BenQ GL2450H', 'Dell U2211H']
+
+
+
+
+ + +
+
+ +
+ + def + get_methods( name: Optional[str] = None) -> Dict[str, Type[screen_brightness_control.helpers.BrightnessMethod]]: + + + +
+ + 
298def get_methods(name: Optional[str] = None) -> Dict[str, Type[BrightnessMethod]]:
+299    '''
+300    Returns all available brightness method names and their associated classes.
+301
+302    Args:
+303        name: if specified, return the method corresponding to this name
+304
+305    Raises:
+306        ValueError: if the given name is incorrect
+307
+308    Example:
+309        ```python
+310        import screen_brightness_control as sbc
+311
+312        all_methods = sbc.get_methods()
+313
+314        for method_name, method_class in all_methods.items():
+315            print('Method:', method_name)
+316            print('Class:', method_class)
+317            print('Associated monitors:', sbc.list_monitors(method=method_name))
+318        ```
+319    '''
+320    methods = {i.__name__.lower(): i for i in _OS_METHODS}
+321
+322    if name is None:
+323        return methods
+324
+325    if not isinstance(name, str):
+326        raise TypeError(f'name must be of type str, not {type(name)!r}')
+327
+328    name = name.lower()
+329    if name in methods:
+330        return {name: methods[name]}
+331
+332    _logger.debug(f'requested method {name!r} invalid')
+333    raise ValueError(
+334        f'invalid method {name!r}, must be one of: {list(methods)}')
+
+ + +

Returns all available brightness method names and their associated classes.

+ +
Arguments:
+ +
    +
  • name: if specified, return the method corresponding to this name
    • +
+ +
Raises:
+ +
    +
  • ValueError: if the given name is incorrect
    • +
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+all_methods = sbc.get_methods()
+
+for method_name, method_class in all_methods.items():
+    print('Method:', method_name)
+    print('Class:', method_class)
+    print('Associated monitors:', sbc.list_monitors(method=method_name))
+
+
+
+
+ + +
+
+ +
+
@dataclass
+ + class + Display: + + + +
+ + 
337@dataclass
+338class Display():
+339    '''
+340    Represents a single connected display.
+341    '''
+342    index: int
+343    '''The index of the display relative to the method it uses.
+344    So if the index is 0 and the method is `windows.VCP`, then this is the 1st
+345    display reported by `windows.VCP`, not the first display overall.'''
+346    method: Type[BrightnessMethod]
+347    '''The method by which this monitor can be addressed.
+348    This will be a class from either the windows or linux sub-module'''
+349
+350    edid: Optional[str] = None
+351    '''A 256 character hex string containing information about a display and its capabilities'''
+352    manufacturer: Optional[str] = None
+353    '''Name of the display's manufacturer'''
+354    manufacturer_id: Optional[str] = None
+355    '''3 letter code corresponding to the manufacturer name'''
+356    model: Optional[str] = None
+357    '''Model name of the display'''
+358    name: Optional[str] = None
+359    '''The name of the display, often the manufacturer name plus the model name'''
+360    serial: Optional[str] = None
+361    '''The serial number of the display or (if serial is not available) an ID assigned by the OS'''
+362
+363    _logger: logging.Logger = field(init=False, repr=False)
+364
+365    def __post_init__(self):
+366        self._logger = _logger.getChild(self.__class__.__name__).getChild(
+367            str(self.get_identifier()[1])[:20])
+368
+369    def fade_brightness(
+370        self,
+371        finish: Percentage,
+372        start: Optional[Percentage] = None,
+373        interval: float = 0.01,
+374        increment: int = 1,
+375        force: bool = False,
+376        logarithmic: bool = True
+377    ) -> IntPercentage:
+378        '''
+379        Gradually change the brightness of this display to a set value.
+380        This works by incrementally changing the brightness until the desired
+381        value is reached.
+382
+383        Args:
+384            finish (.types.Percentage): the brightness level to end up on
+385            start (.types.Percentage): where the fade should start from. Defaults
+386                to whatever the current brightness level for the display is
+387            interval: time delay between each change in brightness
+388            increment: amount to change the brightness by each time (as a percentage)
+389            force: [*Linux only*] allow the brightness to be set to 0. By default,
+390                brightness values will never be set lower than 1, since setting them to 0
+391                often turns off the backlight
+392            logarithmic: follow a logarithmic curve when setting brightness values.
+393                See `logarithmic_range` for rationale
+394
+395        Returns:
+396            The brightness of the display after the fade is complete.
+397            See `.types.IntPercentage`
+398
+399            .. warning:: Deprecated
+400               This function will return `None` in v0.23.0 and later.
+401        '''
+402        # minimum brightness value
+403        if platform.system() == 'Linux' and not force:
+404            lower_bound = 1
+405        else:
+406            lower_bound = 0
+407
+408        current = self.get_brightness()
+409
+410        finish = percentage(finish, current, lower_bound)
+411        start = percentage(
+412            current if start is None else start, current, lower_bound)
+413
+414        # mypy says "object is not callable" but range is. Ignore this
+415        range_func: Callable = logarithmic_range if logarithmic else range  # type: ignore[assignment]
+416        increment = abs(increment)
+417        if start > finish:
+418            increment = -increment
+419
+420        self._logger.debug(
+421            f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+422
+423        for value in range_func(start, finish, increment):
+424            self.set_brightness(value, force=force)
+425            time.sleep(interval)
+426
+427        if self.get_brightness() != finish:
+428            self.set_brightness(finish, force=force)
+429
+430        return self.get_brightness()
+431
+432    @classmethod
+433    def from_dict(cls, display: dict) -> 'Display':
+434        '''
+435        Initialise an instance of the class from a dictionary, ignoring
+436        any unwanted keys
+437        '''
+438        return cls(
+439            index=display['index'],
+440            method=display['method'],
+441            edid=display['edid'],
+442            manufacturer=display['manufacturer'],
+443            manufacturer_id=display['manufacturer_id'],
+444            model=display['model'],
+445            name=display['name'],
+446            serial=display['serial']
+447        )
+448
+449    def get_brightness(self) -> IntPercentage:
+450        '''
+451        Returns the brightness of this display.
+452
+453        Returns:
+454            The brightness value of the display, as a percentage.
+455            See `.types.IntPercentage`
+456        '''
+457        return self.method.get_brightness(display=self.index)[0]
+458
+459    def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+460        '''
+461        Returns the `.types.DisplayIdentifier` for this display.
+462        Will iterate through the EDID, serial, name and index and return the first
+463        value that is not equal to None
+464
+465        Returns:
+466            The name of the property returned and the value of said property.
+467            EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+468        '''
+469        for key in ('edid', 'serial', 'name'):
+470            value = getattr(self, key, None)
+471            if value is not None:
+472                return key, value
+473        # the index should surely never be `None`
+474        return 'index', self.index
+475
+476    def is_active(self) -> bool:
+477        '''
+478        Attempts to retrieve the brightness for this display. If it works the display is deemed active
+479        '''
+480        try:
+481            self.get_brightness()
+482            return True
+483        except Exception as e:
+484            self._logger.error(
+485                f'Monitor.is_active: {self.get_identifier()} failed get_brightness call'
+486                f' - {format_exc(e)}'
+487            )
+488            return False
+489
+490    def set_brightness(self, value: Percentage, force: bool = False):
+491        '''
+492        Sets the brightness for this display. See `set_brightness` for the full docs
+493
+494        Args:
+495            value (.types.Percentage): the brightness percentage to set the display to
+496            force: allow the brightness to be set to 0 on Linux. This is disabled by default
+497                because setting the brightness of 0 will often turn off the backlight
+498        '''
+499        # convert brightness value to percentage
+500        if platform.system() == 'Linux' and not force:
+501            lower_bound = 1
+502        else:
+503            lower_bound = 0
+504
+505        value = percentage(
+506            value,
+507            current=self.get_brightness,
+508            lower_bound=lower_bound
+509        )
+510
+511        self.method.set_brightness(value, display=self.index)
+
+ + +

Represents a single connected display.

+
+ + +
+
+ + 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) + + +
+ + + + +
+
+
+ index: int + + +
+ + +

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.

+
+ + +
+
+
+ method: Type[screen_brightness_control.helpers.BrightnessMethod] + + +
+ + +

The method by which this monitor can be addressed. +This will be a class from either the windows or linux sub-module

+
+ + +
+
+
+ edid: Optional[str] = +None + + +
+ + +

A 256 character hex string containing information about a display and its capabilities

+
+ + +
+
+
+ manufacturer: Optional[str] = +None + + +
+ + +

Name of the display's manufacturer

+
+ + +
+
+
+ manufacturer_id: Optional[str] = +None + + +
+ + +

3 letter code corresponding to the manufacturer name

+
+ + +
+
+
+ model: Optional[str] = +None + + +
+ + +

Model name of the display

+
+ + +
+
+
+ name: Optional[str] = +None + + +
+ + +

The name of the display, often the manufacturer name plus the model name

+
+ + +
+
+
+ serial: Optional[str] = +None + + +
+ + +

The serial number of the display or (if serial is not available) an ID assigned by the OS

+
+ + +
+
+ +
+ + def + fade_brightness( self, finish: Union[int, str], start: Union[str, int, NoneType] = None, interval: float = 0.01, increment: int = 1, force: bool = False, logarithmic: bool = True) -> int: + + + +
+ + 
369    def fade_brightness(
+370        self,
+371        finish: Percentage,
+372        start: Optional[Percentage] = None,
+373        interval: float = 0.01,
+374        increment: int = 1,
+375        force: bool = False,
+376        logarithmic: bool = True
+377    ) -> IntPercentage:
+378        '''
+379        Gradually change the brightness of this display to a set value.
+380        This works by incrementally changing the brightness until the desired
+381        value is reached.
+382
+383        Args:
+384            finish (.types.Percentage): the brightness level to end up on
+385            start (.types.Percentage): where the fade should start from. Defaults
+386                to whatever the current brightness level for the display is
+387            interval: time delay between each change in brightness
+388            increment: amount to change the brightness by each time (as a percentage)
+389            force: [*Linux only*] allow the brightness to be set to 0. By default,
+390                brightness values will never be set lower than 1, since setting them to 0
+391                often turns off the backlight
+392            logarithmic: follow a logarithmic curve when setting brightness values.
+393                See `logarithmic_range` for rationale
+394
+395        Returns:
+396            The brightness of the display after the fade is complete.
+397            See `.types.IntPercentage`
+398
+399            .. warning:: Deprecated
+400               This function will return `None` in v0.23.0 and later.
+401        '''
+402        # minimum brightness value
+403        if platform.system() == 'Linux' and not force:
+404            lower_bound = 1
+405        else:
+406            lower_bound = 0
+407
+408        current = self.get_brightness()
+409
+410        finish = percentage(finish, current, lower_bound)
+411        start = percentage(
+412            current if start is None else start, current, lower_bound)
+413
+414        # mypy says "object is not callable" but range is. Ignore this
+415        range_func: Callable = logarithmic_range if logarithmic else range  # type: ignore[assignment]
+416        increment = abs(increment)
+417        if start > finish:
+418            increment = -increment
+419
+420        self._logger.debug(
+421            f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+422
+423        for value in range_func(start, finish, increment):
+424            self.set_brightness(value, force=force)
+425            time.sleep(interval)
+426
+427        if self.get_brightness() != finish:
+428            self.set_brightness(finish, force=force)
+429
+430        return self.get_brightness()
+
+ + +

Gradually change the brightness of this display to a set value. +This works by incrementally changing the brightness until the desired +value is reached.

+ +
Arguments:
+ +
    +
  • finish (screen_brightness_control.types.Percentage): the brightness level to end up on
    • +
  • start (screen_brightness_control.types.Percentage): where the fade should start from. Defaults +to whatever the current brightness level for the display is
    • +
  • interval: time delay between each change in brightness
    • +
  • increment: amount to change the brightness by each time (as a percentage)
    • +
  • force: [Linux only] allow the brightness to be set to 0. By default, +brightness values will never be set lower than 1, since setting them to 0 +often turns off the backlight
    • +
  • logarithmic: follow a logarithmic curve when setting brightness values. +See logarithmic_range for rationale
    • +
+ +
Returns:
+ +
+

The brightness of the display after the fade is complete. + See screen_brightness_control.types.IntPercentage

+ +
+ +
Deprecated
+ +

This function will return None in v0.23.0 and later.

+ +
+
+
+ + +
+
+ +
+
@classmethod
+ + def + from_dict(cls, display: dict) -> Display: + + + +
+ + 
432    @classmethod
+433    def from_dict(cls, display: dict) -> 'Display':
+434        '''
+435        Initialise an instance of the class from a dictionary, ignoring
+436        any unwanted keys
+437        '''
+438        return cls(
+439            index=display['index'],
+440            method=display['method'],
+441            edid=display['edid'],
+442            manufacturer=display['manufacturer'],
+443            manufacturer_id=display['manufacturer_id'],
+444            model=display['model'],
+445            name=display['name'],
+446            serial=display['serial']
+447        )
+
+ + +

Initialise an instance of the class from a dictionary, ignoring +any unwanted keys

+
+ + +
+
+ +
+ + def + get_brightness(self) -> int: + + + +
+ + 
449    def get_brightness(self) -> IntPercentage:
+450        '''
+451        Returns the brightness of this display.
+452
+453        Returns:
+454            The brightness value of the display, as a percentage.
+455            See `.types.IntPercentage`
+456        '''
+457        return self.method.get_brightness(display=self.index)[0]
+
+ + +

Returns the brightness of this display.

+ +
Returns:
+ +
+

The brightness value of the display, as a percentage. + See screen_brightness_control.types.IntPercentage

+
+
+ + +
+
+ +
+ + def + get_identifier(self) -> Tuple[str, Union[int, str]]: + + + +
+ + 
459    def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+460        '''
+461        Returns the `.types.DisplayIdentifier` for this display.
+462        Will iterate through the EDID, serial, name and index and return the first
+463        value that is not equal to None
+464
+465        Returns:
+466            The name of the property returned and the value of said property.
+467            EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+468        '''
+469        for key in ('edid', 'serial', 'name'):
+470            value = getattr(self, key, None)
+471            if value is not None:
+472                return key, value
+473        # the index should surely never be `None`
+474        return 'index', self.index
+
+ + +

Returns the screen_brightness_control.types.DisplayIdentifier for this display. +Will iterate through the EDID, serial, name and index and return the first +value that is not equal to None

+ +
Returns:
+ +
+

The name of the property returned and the value of said property. + EG: ('serial', '123abc...') or ('name', 'BenQ GL2450H')

+
+
+ + +
+
+ +
+ + def + is_active(self) -> bool: + + + +
+ + 
476    def is_active(self) -> bool:
+477        '''
+478        Attempts to retrieve the brightness for this display. If it works the display is deemed active
+479        '''
+480        try:
+481            self.get_brightness()
+482            return True
+483        except Exception as e:
+484            self._logger.error(
+485                f'Monitor.is_active: {self.get_identifier()} failed get_brightness call'
+486                f' - {format_exc(e)}'
+487            )
+488            return False
+
+ + +

Attempts to retrieve the brightness for this display. If it works the display is deemed active

+
+ + +
+
+ +
+ + def + set_brightness(self, value: Union[int, str], force: bool = False): + + + +
+ + 
490    def set_brightness(self, value: Percentage, force: bool = False):
+491        '''
+492        Sets the brightness for this display. See `set_brightness` for the full docs
+493
+494        Args:
+495            value (.types.Percentage): the brightness percentage to set the display to
+496            force: allow the brightness to be set to 0 on Linux. This is disabled by default
+497                because setting the brightness of 0 will often turn off the backlight
+498        '''
+499        # convert brightness value to percentage
+500        if platform.system() == 'Linux' and not force:
+501            lower_bound = 1
+502        else:
+503            lower_bound = 0
+504
+505        value = percentage(
+506            value,
+507            current=self.get_brightness,
+508            lower_bound=lower_bound
+509        )
+510
+511        self.method.set_brightness(value, display=self.index)
+
+ + +

Sets the brightness for this display. See set_brightness for the full docs

+ +
Arguments:
+ +
    +
  • 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
    • +
+
+ + +
+
+
+ +
+ + class + Monitor(Display): + + + +
+ + 
514class Monitor(Display):
+515    '''
+516    Legacy class for managing displays.
+517
+518    .. warning:: Deprecated
+519       Deprecated for removal in v0.23.0. Please use the new `Display` class instead
+520    '''
+521
+522    def __init__(self, display: Union[int, str, dict]):
+523        '''
+524        Args:
+525            display (.types.DisplayIdentifier or dict): the display you
+526                wish to control. Is passed to `filter_monitors`
+527                to decide which display to use.
+528
+529        Example:
+530            ```python
+531            import screen_brightness_control as sbc
+532
+533            # create a class for the primary display and then a specifically named monitor
+534            primary = sbc.Monitor(0)
+535            benq_monitor = sbc.Monitor('BenQ GL2450H')
+536
+537            # check if the benq monitor is the primary one
+538            if primary.serial == benq_monitor.serial:
+539                print('BenQ GL2450H is the primary display')
+540            else:
+541                print('The primary display is', primary.name)
+542            ```
+543        '''
+544        warnings.warn(
+545            (
+546                '`Monitor` is deprecated for removal in v0.23.0.'
+547                ' Please use the new `Display` class instead'
+548            ),
+549            DeprecationWarning
+550        )
+551
+552        monitors_info = list_monitors_info(allow_duplicates=True)
+553        if isinstance(display, dict):
+554            if display in monitors_info:
+555                info = display
+556            else:
+557                info = filter_monitors(
+558                    display=self.get_identifier(display)[1],
+559                    haystack=monitors_info
+560                )[0]
+561        else:
+562            info = filter_monitors(display=display, haystack=monitors_info)[0]
+563
+564        # make a copy so that we don't alter the dict in-place
+565        info = info.copy()
+566
+567        kw = [i.name for i in fields(Display) if i.init]
+568        super().__init__(**{k: v for k, v in info.items() if k in kw})
+569
+570        # this assigns any extra info that is returned to this class
+571        # eg: the 'interface' key in XRandr monitors on Linux
+572        for key, value in info.items():
+573            if key not in kw and value is not None:
+574                setattr(self, key, value)
+575
+576    def get_identifier(self, monitor: Optional[dict] = None) -> Tuple[str, DisplayIdentifier]:
+577        '''
+578        Returns the `.types.DisplayIdentifier` for this display.
+579        Will iterate through the EDID, serial, name and index and return the first
+580        value that is not equal to None
+581
+582        Args:
+583            monitor: extract an identifier from this dict instead of the monitor class
+584
+585        Returns:
+586            A tuple containing the name of the property returned and the value of said
+587            property. EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+588
+589        Example:
+590            ```python
+591            import screen_brightness_control as sbc
+592            primary = sbc.Monitor(0)
+593            print(primary.get_identifier())  # eg: ('serial', '123abc...')
+594
+595            secondary = sbc.list_monitors_info()[1]
+596            print(primary.get_identifier(monitor=secondary))  # eg: ('serial', '456def...')
+597
+598            # you can also use the class uninitialized
+599            print(sbc.Monitor.get_identifier(secondary))  # eg: ('serial', '456def...')
+600            ```
+601        '''
+602        if monitor is None:
+603            if isinstance(self, dict):
+604                monitor = self
+605            else:
+606                return super().get_identifier()
+607
+608        for key in ('edid', 'serial', 'name'):
+609            value = monitor[key]
+610            if value is not None:
+611                return key, value
+612        return 'index', self.index
+613
+614    def set_brightness(
+615        self,
+616        value: Percentage,
+617        no_return: bool = True,
+618        force: bool = False
+619    ) -> Optional[IntPercentage]:
+620        '''
+621        Wrapper for `Display.set_brightness`
+622
+623        Args:
+624            value: see `Display.set_brightness`
+625            no_return: do not return the new brightness after it has been set
+626            force: see `Display.set_brightness`
+627        '''
+628        # refresh display info, in case another display has been unplugged or something
+629        # which would change the index of this display
+630        self.get_info()
+631        super().set_brightness(value, force)
+632        if no_return:
+633            return None
+634        return self.get_brightness()
+635
+636    def get_brightness(self) -> IntPercentage:
+637        # refresh display info, in case another display has been unplugged or something
+638        # which would change the index of this display
+639        self.get_info()
+640        return super().get_brightness()
+641
+642    def fade_brightness(
+643        self,
+644        *args,
+645        blocking: bool = True,
+646        **kwargs
+647    ) -> Union[threading.Thread, IntPercentage]:
+648        '''
+649        Wrapper for `Display.fade_brightness`
+650
+651        Args:
+652            *args: see `Display.fade_brightness`
+653            blocking: run this function in the current thread and block until
+654                it completes. If `False`, the fade will be run in a new daemonic
+655                thread, which will be started and returned
+656            **kwargs: see `Display.fade_brightness`
+657        '''
+658        if blocking:
+659            super().fade_brightness(*args, **kwargs)
+660            return self.get_brightness()
+661
+662        thread = threading.Thread(
+663            target=super().fade_brightness, args=args, kwargs=kwargs, daemon=True)
+664        thread.start()
+665        return thread
+666
+667    @classmethod
+668    def from_dict(cls, display) -> 'Monitor':
+669        return cls(display)
+670
+671    def get_info(self, refresh: bool = True) -> dict:
+672        '''
+673        Returns all known information about this monitor instance
+674
+675        Args:
+676            refresh: whether to refresh the information
+677                or to return the cached version
+678
+679        Example:
+680            ```python
+681            import screen_brightness_control as sbc
+682
+683            # initialize class for primary display
+684            primary = sbc.Monitor(0)
+685            # get the info
+686            info = primary.get_info()
+687            ```
+688        '''
+689        def vars_self():
+690            return {k: v for k, v in vars(self).items() if not k.startswith('_')}
+691
+692        if not refresh:
+693            return vars_self()
+694
+695        identifier = self.get_identifier()
+696
+697        if identifier is not None:
+698            # refresh the info we have on this monitor
+699            info = filter_monitors(
+700                display=identifier[1], method=self.method.__name__)[0]
+701            for key, value in info.items():
+702                if value is not None:
+703                    setattr(self, key, value)
+704
+705        return vars_self()
+
+ + +

Legacy class for managing displays.

+ +
+ +
Deprecated
+ +

Deprecated for removal in v0.23.0. Please use the new Display class instead

+ +
+
+ + +
+ +
+ + Monitor(display: Union[int, str, dict]) + + + +
+ + 
522    def __init__(self, display: Union[int, str, dict]):
+523        '''
+524        Args:
+525            display (.types.DisplayIdentifier or dict): the display you
+526                wish to control. Is passed to `filter_monitors`
+527                to decide which display to use.
+528
+529        Example:
+530            ```python
+531            import screen_brightness_control as sbc
+532
+533            # create a class for the primary display and then a specifically named monitor
+534            primary = sbc.Monitor(0)
+535            benq_monitor = sbc.Monitor('BenQ GL2450H')
+536
+537            # check if the benq monitor is the primary one
+538            if primary.serial == benq_monitor.serial:
+539                print('BenQ GL2450H is the primary display')
+540            else:
+541                print('The primary display is', primary.name)
+542            ```
+543        '''
+544        warnings.warn(
+545            (
+546                '`Monitor` is deprecated for removal in v0.23.0.'
+547                ' Please use the new `Display` class instead'
+548            ),
+549            DeprecationWarning
+550        )
+551
+552        monitors_info = list_monitors_info(allow_duplicates=True)
+553        if isinstance(display, dict):
+554            if display in monitors_info:
+555                info = display
+556            else:
+557                info = filter_monitors(
+558                    display=self.get_identifier(display)[1],
+559                    haystack=monitors_info
+560                )[0]
+561        else:
+562            info = filter_monitors(display=display, haystack=monitors_info)[0]
+563
+564        # make a copy so that we don't alter the dict in-place
+565        info = info.copy()
+566
+567        kw = [i.name for i in fields(Display) if i.init]
+568        super().__init__(**{k: v for k, v in info.items() if k in kw})
+569
+570        # this assigns any extra info that is returned to this class
+571        # eg: the 'interface' key in XRandr monitors on Linux
+572        for key, value in info.items():
+573            if key not in kw and value is not None:
+574                setattr(self, key, value)
+
+ + +
Arguments:
+ + + +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+# create a class for the primary display and then a specifically named monitor
+primary = sbc.Monitor(0)
+benq_monitor = sbc.Monitor('BenQ GL2450H')
+
+# check if the benq monitor is the primary one
+if primary.serial == benq_monitor.serial:
+    print('BenQ GL2450H is the primary display')
+else:
+    print('The primary display is', primary.name)
+
+
+
+
+ + +
+
+ +
+ + def + get_identifier(self, monitor: Optional[dict] = None) -> Tuple[str, Union[int, str]]: + + + +
+ + 
576    def get_identifier(self, monitor: Optional[dict] = None) -> Tuple[str, DisplayIdentifier]:
+577        '''
+578        Returns the `.types.DisplayIdentifier` for this display.
+579        Will iterate through the EDID, serial, name and index and return the first
+580        value that is not equal to None
+581
+582        Args:
+583            monitor: extract an identifier from this dict instead of the monitor class
+584
+585        Returns:
+586            A tuple containing the name of the property returned and the value of said
+587            property. EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+588
+589        Example:
+590            ```python
+591            import screen_brightness_control as sbc
+592            primary = sbc.Monitor(0)
+593            print(primary.get_identifier())  # eg: ('serial', '123abc...')
+594
+595            secondary = sbc.list_monitors_info()[1]
+596            print(primary.get_identifier(monitor=secondary))  # eg: ('serial', '456def...')
+597
+598            # you can also use the class uninitialized
+599            print(sbc.Monitor.get_identifier(secondary))  # eg: ('serial', '456def...')
+600            ```
+601        '''
+602        if monitor is None:
+603            if isinstance(self, dict):
+604                monitor = self
+605            else:
+606                return super().get_identifier()
+607
+608        for key in ('edid', 'serial', 'name'):
+609            value = monitor[key]
+610            if value is not None:
+611                return key, value
+612        return 'index', self.index
+
+ + +

Returns the screen_brightness_control.types.DisplayIdentifier for this display. +Will iterate through the EDID, serial, name and index and return the first +value that is not equal to None

+ +
Arguments:
+ +
    +
  • monitor: extract an identifier from this dict instead of the monitor class
    • +
+ +
Returns:
+ +
+

A tuple containing the name of the property returned and the value of said + property. EG: ('serial', '123abc...') or ('name', 'BenQ GL2450H')

+
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+primary = sbc.Monitor(0)
+print(primary.get_identifier())  # eg: ('serial', '123abc...')
+
+secondary = sbc.list_monitors_info()[1]
+print(primary.get_identifier(monitor=secondary))  # eg: ('serial', '456def...')
+
+# you can also use the class uninitialized
+print(sbc.Monitor.get_identifier(secondary))  # eg: ('serial', '456def...')
+
+
+
+
+ + +
+
+ +
+ + def + set_brightness( self, value: Union[int, str], no_return: bool = True, force: bool = False) -> Optional[int]: + + + +
+ + 
614    def set_brightness(
+615        self,
+616        value: Percentage,
+617        no_return: bool = True,
+618        force: bool = False
+619    ) -> Optional[IntPercentage]:
+620        '''
+621        Wrapper for `Display.set_brightness`
+622
+623        Args:
+624            value: see `Display.set_brightness`
+625            no_return: do not return the new brightness after it has been set
+626            force: see `Display.set_brightness`
+627        '''
+628        # refresh display info, in case another display has been unplugged or something
+629        # which would change the index of this display
+630        self.get_info()
+631        super().set_brightness(value, force)
+632        if no_return:
+633            return None
+634        return self.get_brightness()
+
+ + +

Wrapper for Display.set_brightness

+ +
Arguments:
+ + +
+ + +
+
+ +
+ + def + get_brightness(self) -> int: + + + +
+ + 
636    def get_brightness(self) -> IntPercentage:
+637        # refresh display info, in case another display has been unplugged or something
+638        # which would change the index of this display
+639        self.get_info()
+640        return super().get_brightness()
+
+ + +

Returns the brightness of this display.

+ +
Returns:
+ +
+

The brightness value of the display, as a percentage. + See screen_brightness_control.types.IntPercentage

+
+
+ + +
+
+ +
+ + def + fade_brightness( self, *args, blocking: bool = True, **kwargs) -> Union[threading.Thread, int]: + + + +
+ + 
642    def fade_brightness(
+643        self,
+644        *args,
+645        blocking: bool = True,
+646        **kwargs
+647    ) -> Union[threading.Thread, IntPercentage]:
+648        '''
+649        Wrapper for `Display.fade_brightness`
+650
+651        Args:
+652            *args: see `Display.fade_brightness`
+653            blocking: run this function in the current thread and block until
+654                it completes. If `False`, the fade will be run in a new daemonic
+655                thread, which will be started and returned
+656            **kwargs: see `Display.fade_brightness`
+657        '''
+658        if blocking:
+659            super().fade_brightness(*args, **kwargs)
+660            return self.get_brightness()
+661
+662        thread = threading.Thread(
+663            target=super().fade_brightness, args=args, kwargs=kwargs, daemon=True)
+664        thread.start()
+665        return thread
+
+ + +

Wrapper for Display.fade_brightness

+ +
Arguments:
+ +
    +
  • *args: see Display.fade_brightness
    • +
  • blocking: run this function in the current thread and block until +it completes. If False, the fade will be run in a new daemonic +thread, which will be started and returned
    • +
  • **kwargs: see Display.fade_brightness
    • +
+
+ + +
+
+ +
+
@classmethod
+ + def + from_dict(cls, display) -> Monitor: + + + +
+ + 
667    @classmethod
+668    def from_dict(cls, display) -> 'Monitor':
+669        return cls(display)
+
+ + +

Initialise an instance of the class from a dictionary, ignoring +any unwanted keys

+
+ + +
+
+ +
+ + def + get_info(self, refresh: bool = True) -> dict: + + + +
+ + 
671    def get_info(self, refresh: bool = True) -> dict:
+672        '''
+673        Returns all known information about this monitor instance
+674
+675        Args:
+676            refresh: whether to refresh the information
+677                or to return the cached version
+678
+679        Example:
+680            ```python
+681            import screen_brightness_control as sbc
+682
+683            # initialize class for primary display
+684            primary = sbc.Monitor(0)
+685            # get the info
+686            info = primary.get_info()
+687            ```
+688        '''
+689        def vars_self():
+690            return {k: v for k, v in vars(self).items() if not k.startswith('_')}
+691
+692        if not refresh:
+693            return vars_self()
+694
+695        identifier = self.get_identifier()
+696
+697        if identifier is not None:
+698            # refresh the info we have on this monitor
+699            info = filter_monitors(
+700                display=identifier[1], method=self.method.__name__)[0]
+701            for key, value in info.items():
+702                if value is not None:
+703                    setattr(self, key, value)
+704
+705        return vars_self()
+
+ + +

Returns all known information about this monitor instance

+ +
Arguments:
+ +
    +
  • refresh: whether to refresh the information +or to return the cached version
    • +
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+# initialize class for primary display
+primary = sbc.Monitor(0)
+# get the info
+info = primary.get_info()
+
+
+
+
+ + +
+
+
Inherited Members
+
+
Display
+
index
+
method
+
edid
+
manufacturer
+
manufacturer_id
+
model
+
name
+
serial
+
is_active
+ +
+
+
+
+
+ +
+ + def + filter_monitors( display: Union[str, int, NoneType] = None, haystack: Optional[List[dict]] = None, method: Optional[str] = None, include: List[str] = []) -> List[dict]: + + + +
+ + 
708def filter_monitors(
+709    display: Optional[DisplayIdentifier] = None,
+710    haystack: Optional[List[dict]] = None,
+711    method: Optional[str] = None,
+712    include: List[str] = []
+713) -> List[dict]:
+714    '''
+715    Searches through the information for all detected displays
+716    and attempts to return the info matching the value given.
+717    Will attempt to match against index, name, edid, method and serial
+718
+719    Args:
+720        display (.types.DisplayIdentifier): the display you are searching for
+721        haystack: the information to filter from.
+722            If this isn't set it defaults to the return of `list_monitors_info`
+723        method: the method the monitors use. See `get_methods` for
+724            more info on available methods
+725        include: extra fields of information to sort by
+726
+727    Raises:
+728        NoValidDisplayError: if the display does not have a match
+729        TypeError: if the `display` kwarg is not `int` or `str`
+730
+731    Example:
+732        ```python
+733        import screen_brightness_control as sbc
+734
+735        search = 'GL2450H'
+736        match = sbc.filter_displays(search)
+737        print(match)
+738        # EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]
+739        ```
+740    '''
+741    if display is not None and type(display) not in (str, int):
+742        raise TypeError(
+743            f'display kwarg must be int or str, not "{type(display).__name__}"')
+744
+745    def get_monitor_list():
+746        # if we have been provided with a list of monitors to sift through then use that
+747        # otherwise, get the info ourselves
+748        if haystack is not None:
+749            monitors_with_duplicates = haystack
+750            if method is not None:
+751                method_class = next(iter(get_methods(method).values()))
+752                monitors_with_duplicates = [
+753                    i for i in haystack if i['method'] == method_class]
+754        else:
+755            monitors_with_duplicates = list_monitors_info(
+756                method=method, allow_duplicates=True)
+757
+758        return monitors_with_duplicates
+759
+760    def filter_monitor_list(to_filter):
+761        # This loop does two things:
+762        # 1. Filters out duplicate monitors
+763        # 2. Matches the display kwarg (if applicable)
+764        filtered_displays = {}
+765        for monitor in to_filter:
+766            # find a valid identifier for a monitor, excluding any which are equal to None
+767            added = False
+768            for identifier in ['edid', 'serial', 'name'] + include:
+769                if monitor.get(identifier, None) is None:
+770                    continue
+771
+772                m_id = monitor[identifier]
+773                if m_id in filtered_displays:
+774                    break
+775
+776                if isinstance(display, str) and m_id != display:
+777                    continue
+778
+779                # check we haven't already added the monitor
+780                if not added:
+781                    filtered_displays[m_id] = monitor
+782                    added = True
+783
+784                # if the display kwarg is an integer and we are currently at that index
+785                if isinstance(display, int) and len(filtered_displays) - 1 == display:
+786                    return [monitor]
+787
+788                if added:
+789                    break
+790        return list(filtered_displays.values())
+791
+792    duplicates = []
+793    for _ in range(3):
+794        duplicates = get_monitor_list()
+795        if duplicates:
+796            break
+797        time.sleep(0.4)
+798    else:
+799        msg = 'no displays detected'
+800        if method is not None:
+801            msg += f' with method: {method!r}'
+802        raise NoValidDisplayError(msg)
+803
+804    monitors = filter_monitor_list(duplicates)
+805    if not monitors:
+806        # if no displays matched the query
+807        msg = 'no displays found'
+808        if display is not None:
+809            msg += f' with name/serial/edid/index of {display!r}'
+810        if method is not None:
+811            msg += f' with method of {method!r}'
+812        raise NoValidDisplayError(msg)
+813
+814    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, edid, method and serial

+ +
Arguments:
+ + + +
Raises:
+ +
    +
  • NoValidDisplayError: if the display does not have a match
    • +
  • TypeError: if the display kwarg is not int or str
    • +
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+search = 'GL2450H'
+match = sbc.filter_displays(search)
+print(match)
+# EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]
+
+
+
+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/0.22.2/screen_brightness_control/exceptions.html b/docs/0.22.2/screen_brightness_control/exceptions.html new file mode 100644 index 0000000..b55f374 --- /dev/null +++ b/docs/0.22.2/screen_brightness_control/exceptions.html @@ -0,0 +1,618 @@ + + + + + + + screen_brightness_control.exceptions API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control.exceptions

+ + + + + + + 
 1import subprocess
+ 2
+ 3
+ 4def format_exc(e: Exception) -> str:
+ 5    '''@private'''
+ 6    return f'{type(e).__name__}: {e}'
+ 7
+ 8
+ 9class ScreenBrightnessError(Exception):
+10    '''
+11    Generic error class designed to make catching errors under one umbrella easy.
+12    '''
+13    ...
+14
+15
+16class EDIDParseError(ScreenBrightnessError):
+17    '''Unparsable/invalid EDID'''
+18    ...
+19
+20
+21class NoValidDisplayError(ScreenBrightnessError, LookupError):
+22    '''Could not find a valid display'''
+23    ...
+24
+25
+26class I2CValidationError(ScreenBrightnessError):
+27    '''I2C data validation failed'''
+28    ...
+29
+30
+31class MaxRetriesExceededError(ScreenBrightnessError, subprocess.CalledProcessError):
+32    '''
+33    The command has been retried too many times.
+34
+35    Example:
+36        ```python
+37        try:
+38            subprocess.check_output(['exit', '1'])
+39        except subprocess.CalledProcessError as e:
+40            raise MaxRetriesExceededError('failed after 1 try', e)
+41        ```
+42    '''
+43    def __init__(self, message: str, exc: subprocess.CalledProcessError):
+44        self.message: str = message
+45        ScreenBrightnessError.__init__(self, message)
+46        super().__init__(exc.returncode, exc.cmd, exc.stdout, exc.stderr)
+47
+48    def __str__(self):
+49        string = super().__str__()
+50        string += f'\n\t-> {self.message}'
+51        return string
+
+ + +
+ +
+
+ +
+ + class + ScreenBrightnessError(builtins.Exception): + + + +
+ + 
10class ScreenBrightnessError(Exception):
+11    '''
+12    Generic error class designed to make catching errors under one umbrella easy.
+13    '''
+14    ...
+
+ + +

Generic error class designed to make catching errors under one umbrella easy.

+
+ + +
+
Inherited Members
+
+
builtins.Exception
+
Exception
+ +
+
builtins.BaseException
+
with_traceback
+
add_note
+
args
+ +
+
+
+
+
+ +
+ + class + EDIDParseError(ScreenBrightnessError): + + + +
+ + 
17class EDIDParseError(ScreenBrightnessError):
+18    '''Unparsable/invalid EDID'''
+19    ...
+
+ + +

Unparsable/invalid EDID

+
+ + +
+
Inherited Members
+
+
builtins.Exception
+
Exception
+ +
+
builtins.BaseException
+
with_traceback
+
add_note
+
args
+ +
+
+
+
+
+ +
+ + class + NoValidDisplayError(ScreenBrightnessError, builtins.LookupError): + + + +
+ + 
22class NoValidDisplayError(ScreenBrightnessError, LookupError):
+23    '''Could not find a valid display'''
+24    ...
+
+ + +

Could not find a valid display

+
+ + +
+
Inherited Members
+
+
builtins.LookupError
+
LookupError
+ +
+
builtins.BaseException
+
with_traceback
+
add_note
+
args
+ +
+
+
+
+
+ +
+ + class + I2CValidationError(ScreenBrightnessError): + + + +
+ + 
27class I2CValidationError(ScreenBrightnessError):
+28    '''I2C data validation failed'''
+29    ...
+
+ + +

I2C data validation failed

+
+ + +
+
Inherited Members
+
+
builtins.Exception
+
Exception
+ +
+
builtins.BaseException
+
with_traceback
+
add_note
+
args
+ +
+
+
+
+
+ +
+ + class + MaxRetriesExceededError(ScreenBrightnessError, subprocess.CalledProcessError): + + + +
+ + 
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
+
+ + +

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
+
returncode
+
cmd
+
output
+
stderr
+
stdout
+ +
+
builtins.BaseException
+
with_traceback
+
add_note
+
args
+ +
+
+
+
+
+ + \ No newline at end of file diff --git a/docs/0.22.2/screen_brightness_control/helpers.html b/docs/0.22.2/screen_brightness_control/helpers.html new file mode 100644 index 0000000..a545924 --- /dev/null +++ b/docs/0.22.2/screen_brightness_control/helpers.html @@ -0,0 +1,1770 @@ + + + + + + + screen_brightness_control.helpers API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control.helpers

+ +

Helper functions for the library

+
+ + + + + + 
  1'''
+  2Helper functions for the library
+  3'''
+  4from __future__ import annotations
+  5
+  6import logging
+  7import struct
+  8import subprocess
+  9import time
+ 10from abc import ABC, abstractmethod
+ 11from functools import lru_cache
+ 12from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+ 13
+ 14from .exceptions import (EDIDParseError, MaxRetriesExceededError,  # noqa:F401
+ 15                         ScreenBrightnessError, format_exc)
+ 16from .types import DisplayIdentifier, IntPercentage, Percentage, Generator
+ 17
+ 18_logger = logging.getLogger(__name__)
+ 19
+ 20MONITOR_MANUFACTURER_CODES = {
+ 21    "AAC": "AcerView",
+ 22    "ACI": "Asus (ASUSTeK Computer Inc.)",
+ 23    "ACR": "Acer",
+ 24    "ACT": "Targa",
+ 25    "ADI": "ADI Corporation",
+ 26    "AIC": "AG Neovo",
+ 27    "ALX": "Anrecson",
+ 28    "AMW": "AMW",
+ 29    "AOC": "AOC",
+ 30    "API": "Acer America Corp.",
+ 31    "APP": "Apple Computer",
+ 32    "ART": "ArtMedia",
+ 33    "AST": "AST Research",
+ 34    "AUO": "Asus",
+ 35    "BMM": "BMM",
+ 36    "BNQ": "BenQ",
+ 37    "BOE": "BOE Display Technology",
+ 38    "CMO": "Acer",
+ 39    "CPL": "Compal",
+ 40    "CPQ": "Compaq",
+ 41    "CPT": "Chunghwa Picture Tubes, Ltd.",
+ 42    "CTX": "CTX",
+ 43    "DEC": "DEC",
+ 44    "DEL": "Dell",
+ 45    "DPC": "Delta",
+ 46    "DWE": "Daewoo",
+ 47    "ECS": "ELITEGROUP Computer Systems",
+ 48    "EIZ": "EIZO",
+ 49    "ELS": "ELSA",
+ 50    "ENC": "EIZO",
+ 51    "EPI": "Envision",
+ 52    "FCM": "Funai",
+ 53    "FUJ": "Fujitsu",
+ 54    "FUS": "Fujitsu-Siemens",
+ 55    "GSM": "LG Electronics",
+ 56    "GWY": "Gateway 2000",
+ 57    "GBT": "Gigabyte",
+ 58    "HEI": "Hyundai",
+ 59    "HIQ": "Hyundai ImageQuest",
+ 60    "HIT": "Hyundai",
+ 61    "HPN": "HP",
+ 62    "HSD": "Hannspree Inc",
+ 63    "HSL": "Hansol",
+ 64    "HTC": "Hitachi/Nissei",
+ 65    "HWP": "HP",
+ 66    "IBM": "IBM",
+ 67    "ICL": "Fujitsu ICL",
+ 68    "IFS": "InFocus",
+ 69    "IQT": "Hyundai",
+ 70    "IVM": "Iiyama",
+ 71    "KDS": "Korea Data Systems",
+ 72    "KFC": "KFC Computek",
+ 73    "LEN": "Lenovo",
+ 74    "LGD": "Asus",
+ 75    "LKM": "ADLAS / AZALEA",
+ 76    "LNK": "LINK Technologies, Inc.",
+ 77    "LPL": "Fujitsu",
+ 78    "LTN": "Lite-On",
+ 79    "MAG": "MAG InnoVision",
+ 80    "MAX": "Belinea",
+ 81    "MEI": "Panasonic",
+ 82    "MEL": "Mitsubishi Electronics",
+ 83    "MIR": "miro Computer Products AG",
+ 84    "MSI": "MSI",
+ 85    "MS_": "Panasonic",
+ 86    "MTC": "MITAC",
+ 87    "NAN": "Nanao",
+ 88    "NEC": "NEC",
+ 89    "NOK": "Nokia Data",
+ 90    "NVD": "Fujitsu",
+ 91    "OPT": "Optoma",
+ 92    "OQI": "OPTIQUEST",
+ 93    "PBN": "Packard Bell",
+ 94    "PCK": "Daewoo",
+ 95    "PDC": "Polaroid",
+ 96    "PGS": "Princeton Graphic Systems",
+ 97    "PHL": "Philips",
+ 98    "PRT": "Princeton",
+ 99    "REL": "Relisys",
+100    "SAM": "Samsung",
+101    "SAN": "Samsung",
+102    "SBI": "Smarttech",
+103    "SEC": "Hewlett-Packard",
+104    "SGI": "SGI",
+105    "SMC": "Samtron",
+106    "SMI": "Smile",
+107    "SNI": "Siemens Nixdorf",
+108    "SNY": "Sony",
+109    "SPT": "Sceptre",
+110    "SRC": "Shamrock",
+111    "STN": "Samtron",
+112    "STP": "Sceptre",
+113    "SUN": "Sun Microsystems",
+114    "TAT": "Tatung",
+115    "TOS": "Toshiba",
+116    "TRL": "Royal Information Company",
+117    "TSB": "Toshiba",
+118    "UNK": "Unknown",
+119    "UNM": "Unisys Corporation",
+120    "VSC": "ViewSonic",
+121    "WTC": "Wen Technology",
+122    "ZCM": "Zenith",
+123    "_YV": "Fujitsu"
+124}
+125
+126
+127class BrightnessMethod(ABC):
+128    @classmethod
+129    @abstractmethod
+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    @classmethod
+153    @abstractmethod
+154    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+155        '''
+156        Args:
+157            display: the index of the specific display to query.
+158                If unspecified, all detected displays are queried
+159
+160        Returns:
+161            A list of `.types.IntPercentage` values, one for each
+162            queried display
+163        '''
+164        ...
+165
+166    @classmethod
+167    @abstractmethod
+168    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+169        '''
+170        Args:
+171            value (.types.IntPercentage): the new brightness value
+172            display: the index of the specific display to adjust.
+173                If unspecified, all detected displays are adjusted
+174        '''
+175        ...
+176
+177
+178class BrightnessMethodAdv(BrightnessMethod):
+179    @classmethod
+180    @abstractmethod
+181    def _gdi(cls) -> List[dict]:
+182        '''
+183        Similar to `BrightnessMethod.get_display_info` except this method will also
+184        return unsupported displays, indicated by an `unsupported: bool` property
+185        in the returned dict
+186        '''
+187        ...
+188
+189
+190class __Cache:
+191    '''class to cache data with a short shelf life'''
+192
+193    def __init__(self):
+194        self.logger = _logger.getChild(f'{self.__class__.__name__}_{id(self)}')
+195        self.enabled = True
+196        self._store: Dict[str, Tuple[Any, float]] = {}
+197
+198    def expire(self, key: Optional[str] = None, startswith: Optional[str] = None):
+199        '''
+200        @private
+201
+202        Runs through all keys in the cache and removes any expired items.
+203        Can optionally specify additional keys that should be removed.
+204
+205        Args:
+206            key: a specific key to remove. `KeyError` exceptions are suppressed if this key doesn't exist.
+207            startswith: remove any keys that start with this string
+208        '''
+209        if key is not None:
+210            try:
+211                del self._store[key]
+212                self.logger.debug(f'delete key {key!r}')
+213            except KeyError:
+214                pass
+215
+216        for k, v in tuple(self._store.items()):
+217            if startswith is not None and k.startswith(startswith):
+218                del self._store[k]
+219                self.logger.debug(f'delete keys {startswith=}')
+220                continue
+221            if v[1] < time.time():
+222                del self._store[k]
+223                self.logger.debug(f'delete expired key {k}')
+224
+225    def get(self, key: str) -> Any:
+226        if not self.enabled:
+227            return None
+228        self.expire()
+229        if key not in self._store:
+230            self.logger.debug(f'{key!r} not present in cache')
+231            return None
+232        return self._store[key][0]
+233
+234    def store(self, key: str, value: Any, expires: float = 1):
+235        if not self.enabled:
+236            return
+237        self.logger.debug(f'cache set {key!r}, {expires=}')
+238        self._store[key] = (value, expires + time.time())
+239
+240
+241class EDID:
+242    '''
+243    Simple structure and method to extract display serial and name from an EDID string.
+244    '''
+245    EDID_FORMAT: str = (
+246        ">"     # big-endian
+247        "8s"    # constant header (8 bytes)
+248        "H"     # manufacturer id (2 bytes)
+249        "H"     # product id (2 bytes)
+250        "I"     # serial number (4 bytes)
+251        "B"     # manufactoring week (1 byte)
+252        "B"     # manufactoring year (1 byte)
+253        "B"     # edid version (1 byte)
+254        "B"     # edid revision (1 byte)
+255        "B"     # video input type (1 byte)
+256        "B"     # horizontal size in cm (1 byte)
+257        "B"     # vertical size in cm (1 byte)
+258        "B"     # display gamma (1 byte)
+259        "B"     # supported features (1 byte)
+260        "10s"   # colour characteristics (10 bytes)
+261        "H"     # supported timings (2 bytes)
+262        "B"     # reserved timing (1 byte)
+263        "16s"   # EDID supported timings (16 bytes)
+264        "18s"   # timing / display descriptor block 1 (18 bytes)
+265        "18s"   # timing / display descriptor block 2 (18 bytes)
+266        "18s"   # timing / display descriptor block 3 (18 bytes)
+267        "18s"   # timing / display descriptor block 4 (18 bytes)
+268        "B"     # extension flag (1 byte)
+269        "B"     # checksum (1 byte)
+270    )
+271    '''
+272    The byte structure for EDID strings, taken from
+273    [pyedid](https://github.com/jojonas/pyedid/blob/2382910d968b2fa8de1fab495fbbdfebcdb39f19/pyedid/edid.py#L21),
+274    [Copyright 2019-2020 Jonas Lieb, Davydov Denis](https://github.com/jojonas/pyedid/blob/master/LICENSE).
+275    '''
+276    SERIAL_DESCRIPTOR = bytes.fromhex('00 00 00 ff 00')
+277    NAME_DESCRIPTOR = bytes.fromhex('00 00 00 fc 00')
+278
+279    @classmethod
+280    def parse(cls, edid: Union[bytes, str]) -> Tuple[Union[str, None], ...]:
+281        '''
+282        Takes an EDID string and parses some relevant information from it according to the
+283        [EDID 1.4](https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format)
+284        specification on Wikipedia.
+285
+286        Args:
+287            edid (bytes or str): the EDID, can either be raw bytes or
+288                a hex formatted string (00 ff ff ff ff...)
+289
+290        Returns:
+291            tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID,
+292                manufacturer, model, name, serial in that order.
+293                If any of these values are unable to be determined, they will be None.
+294                Otherwise, expect a string
+295
+296        Raises:
+297            EDIDParseError: if the EDID info cannot be unpacked
+298            TypeError: if `edid` is not `str` or `bytes`
+299
+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 isinstance(edid, str):
+314            edid = bytes.fromhex(edid)
+315        elif not isinstance(edid, bytes):
+316            raise TypeError(f'edid must be of type bytes or str, not {type(edid)!r}')
+317
+318        try:
+319            blocks = struct.unpack(cls.EDID_FORMAT, edid)
+320        except struct.error as e:
+321            raise EDIDParseError('cannot unpack edid') from e
+322
+323        # split mfg_id (2 bytes) into 3 letters, 5 bits each (ignoring reserved bit)
+324        mfg_id_chars = (
+325            blocks[1] >> 10,             # First 6 bits (reserved bit at start is always 0)
+326            (blocks[1] >> 5) & 0b11111,  # isolate next 5 bits from first 11 using bitwise AND
+327            blocks[1] & 0b11111          # Last five bits
+328        )
+329        # turn numbers into ascii
+330        mfg_id = ''.join(chr(i + 64) for i in mfg_id_chars)
+331
+332        # now grab the manufacturer name
+333        mfg_lookup = _monitor_brand_lookup(mfg_id)
+334        if mfg_lookup is not None:
+335            manufacturer = mfg_lookup[1]
+336        else:
+337            manufacturer = None
+338
+339        serial = None
+340        name = None
+341        for descriptor_block in blocks[17:21]:
+342            # decode the serial
+343            if descriptor_block.startswith(cls.SERIAL_DESCRIPTOR):
+344                # strip descriptor bytes and trailing whitespace
+345                serial_bytes = descriptor_block[len(cls.SERIAL_DESCRIPTOR):].rstrip()
+346                serial = serial_bytes.decode()
+347
+348            # decode the monitor name
+349            elif descriptor_block.startswith(cls.NAME_DESCRIPTOR):
+350                # strip descriptor bytes and trailing whitespace
+351                name_bytes = descriptor_block[len(cls.NAME_DESCRIPTOR):].rstrip()
+352                name = name_bytes.decode()
+353
+354        # now try to figure out what model the display is
+355        model = None
+356        if name is not None:
+357            if manufacturer is not None and name.startswith(manufacturer):
+358                # eg: 'BenQ GL2450H' -> 'GL2450H'
+359                model = name.replace(manufacturer, '', 1).strip()
+360
+361            # if previous method did not work (or if we don't know the manufacturer),
+362            # try taking last word of name
+363            if not model:
+364                try:
+365                    # eg: 'BenQ GL2450H' -> ['BenQ', 'GL2450H']
+366                    model = name.strip().rsplit(' ', 1)[1]
+367                except IndexError:
+368                    # If the name does not include model information then
+369                    # give it something generic
+370                    model = 'Generic Monitor'
+371
+372        return mfg_id, manufacturer, model, name, serial
+373
+374    @staticmethod
+375    def hexdump(file: str) -> str:
+376        '''
+377        Returns a hexadecimal string of binary data from a file
+378
+379        Args:
+380            file (str): the file to read
+381
+382        Returns:
+383            str: one long hex string
+384
+385        Example:
+386            ```python
+387            from screen_brightness_control import EDID
+388
+389            print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
+390            # '00ffffffffffff00...'
+391            ```
+392        '''
+393        with open(file, 'rb') as f:
+394            hex_str = ''.join(f'{char:02x}' for char in f.read())
+395
+396        return hex_str
+397
+398
+399def check_output(command: List[str], max_tries: int = 1) -> bytes:
+400    '''
+401    Run a command with retry management built in.
+402
+403    Args:
+404        command: the command to run
+405        max_tries: the maximum number of retries to allow before raising an error
+406
+407    Returns:
+408        The output from the command
+409    '''
+410    tries = 1
+411    while True:
+412        try:
+413            output = subprocess.check_output(command, stderr=subprocess.PIPE)
+414        except subprocess.CalledProcessError as e:
+415            if tries >= max_tries:
+416                raise MaxRetriesExceededError(f'process failed after {tries} tries', e) from e
+417            tries += 1
+418            time.sleep(0.04 if tries < 5 else 0.5)
+419        else:
+420            if tries > 1:
+421                _logger.debug(f'command {command} took {tries}/{max_tries} tries')
+422            return output
+423
+424
+425def logarithmic_range(start: int, stop: int, step: int = 1) -> Generator[int, None, None]:
+426    '''
+427    A `range`-like function that yields a sequence of integers following
+428    a logarithmic curve (`y = 10 ^ (x / 50)`) from `start` (inclusive) to
+429    `stop` (inclusive).
+430
+431    This is useful because it skips many of the higher percentages in the
+432    sequence where single percent brightness changes are hard to notice.
+433
+434    This function is designed to deal with brightness percentages, and so
+435    will never return a value less than 0 or greater than 100.
+436
+437    Args:
+438        start: the start of your percentage range
+439        stop: the end of your percentage range
+440        step: the increment per iteration through the sequence
+441
+442    Yields:
+443        int
+444    '''
+445    start = int(max(0, start))
+446    stop = int(min(100, stop))
+447
+448    if start == stop or abs(stop - start) <= 1:
+449        yield start
+450    else:
+451        value_range = stop - start
+452
+453        def direction(x):
+454            return x if step > 0 else 100 - x
+455
+456        last_yielded = None
+457        x: float
+458        for x in range(start, stop + 1, step):
+459            # get difference from base point
+460            x -= start
+461            # calculate progress through our range as a percentage
+462            x = (x / value_range) * 100
+463            # convert along logarithmic curve (inverse of y = 50log(x)) to another percentage
+464            x = 10 ** (direction(x) / 50)
+465            # apply this percentage to our range and add back starting offset
+466            x = int(((direction(x) / 100) * value_range) + start)
+467
+468            if x == last_yielded:
+469                continue
+470            yield x
+471            last_yielded = x
+472
+473
+474@lru_cache(maxsize=None)
+475def _monitor_brand_lookup(search: str) -> Union[Tuple[str, str], None]:
+476    '''internal function to search the monitor manufacturer codes dict'''
+477    keys = tuple(MONITOR_MANUFACTURER_CODES.keys())
+478    keys_lower = tuple(map(str.lower, keys))
+479    values = tuple(MONITOR_MANUFACTURER_CODES.values())
+480    search = search.lower()
+481
+482    if search in keys_lower:
+483        index = keys_lower.index(search)
+484    else:
+485        values_lower = tuple(map(str.lower, values))
+486        if search in values_lower:
+487            index = values_lower.index(search)
+488        else:
+489            return None
+490    return keys[index], values[index]
+491
+492
+493def percentage(
+494    value: Percentage,
+495    current: Optional[Union[int, Callable[[], int]]] = None,
+496    lower_bound: int = 0
+497) -> IntPercentage:
+498    '''
+499    Convenience function to convert a brightness value into a percentage. Can handle
+500    integers, floats and strings. Also can handle relative strings (eg: `'+10'` or `'-10'`)
+501
+502    Args:
+503        value: the brightness value to convert
+504        current: the current brightness value or a function that returns the current brightness
+505            value. Used when dealing with relative brightness values
+506        lower_bound: the minimum value the brightness can be set to
+507
+508    Returns:
+509        `.types.IntPercentage`: The new brightness percentage, between `lower_bound` and 100
+510    '''
+511    if isinstance(value, str) and ('+' in value or '-' in value):
+512        if callable(current):
+513            current = current()
+514        value = int(float(value)) + int(float(str(current)))
+515    else:
+516        value = int(float(str(value)))
+517
+518    return min(100, max(lower_bound, value))
+
+ + +
+ +
+
+
+ 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 Picture 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'} + + +
+ + + + +
+
+ +
+ + class + BrightnessMethod(abc.ABC): + + + +
+ + 
128class BrightnessMethod(ABC):
+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        ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+ +
+
@classmethod
+
@abstractmethod
+ + def + get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]: + + + +
+ + 
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        ...
+
+ + +

Return information about detected displays.

+ +
Arguments:
+ + + +
Returns:
+ +
+

A list of dictionaries, each representing a detected display. + Each returned dictionary will have the following keys:

+ +
    +
  • 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)
    • +
  • 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
    • +
  • index (int): the index of the display, relative to the brightness method
    • +
+
+
+ + +
+
+ +
+
@classmethod
+
@abstractmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
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        ...
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
+ +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, one for each + queried display

+
+
+ + +
+
+ +
+
@classmethod
+
@abstractmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None): + + + +
+ + 
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:
+ + +
+ + +
+
+
+ +
+ + class + BrightnessMethodAdv(BrightnessMethod): + + + +
+ + 
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        ...
+
+ + +

Helper class that provides a standard way to create an ABC using +inheritance.

+
+ + +
+
Inherited Members
+
+
BrightnessMethod
+
get_display_info
+
get_brightness
+
set_brightness
+ +
+
+
+
+
+ +
+ + class + 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"   # colour 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        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: if the EDID info cannot be unpacked
+299            TypeError: if `edid` is not `str` or `bytes`
+300
+301        Example:
+302            ```python
+303            import screen_brightness_control as sbc
+304
+305            edid = sbc.list_monitors_info()[0]['edid']
+306            manufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)
+307
+308            print('Manufacturer:', manufacturer_id or 'Unknown')
+309            print('Model:', model or 'Unknown')
+310            print('Name:', name or 'Unknown')
+311            ```
+312        '''
+313        # see https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format
+314        if isinstance(edid, str):
+315            edid = bytes.fromhex(edid)
+316        elif not isinstance(edid, bytes):
+317            raise TypeError(f'edid must be of type bytes or str, not {type(edid)!r}')
+318
+319        try:
+320            blocks = struct.unpack(cls.EDID_FORMAT, edid)
+321        except struct.error as e:
+322            raise EDIDParseError('cannot unpack edid') from e
+323
+324        # split mfg_id (2 bytes) into 3 letters, 5 bits each (ignoring reserved bit)
+325        mfg_id_chars = (
+326            blocks[1] >> 10,             # First 6 bits (reserved bit at start is always 0)
+327            (blocks[1] >> 5) & 0b11111,  # isolate next 5 bits from first 11 using bitwise AND
+328            blocks[1] & 0b11111          # Last five bits
+329        )
+330        # turn numbers into ascii
+331        mfg_id = ''.join(chr(i + 64) for i in mfg_id_chars)
+332
+333        # now grab the manufacturer name
+334        mfg_lookup = _monitor_brand_lookup(mfg_id)
+335        if mfg_lookup is not None:
+336            manufacturer = mfg_lookup[1]
+337        else:
+338            manufacturer = None
+339
+340        serial = None
+341        name = None
+342        for descriptor_block in blocks[17:21]:
+343            # decode the serial
+344            if descriptor_block.startswith(cls.SERIAL_DESCRIPTOR):
+345                # strip descriptor bytes and trailing whitespace
+346                serial_bytes = descriptor_block[len(cls.SERIAL_DESCRIPTOR):].rstrip()
+347                serial = serial_bytes.decode()
+348
+349            # decode the monitor name
+350            elif descriptor_block.startswith(cls.NAME_DESCRIPTOR):
+351                # strip descriptor bytes and trailing whitespace
+352                name_bytes = descriptor_block[len(cls.NAME_DESCRIPTOR):].rstrip()
+353                name = name_bytes.decode()
+354
+355        # now try to figure out what model the display is
+356        model = None
+357        if name is not None:
+358            if manufacturer is not None and name.startswith(manufacturer):
+359                # eg: 'BenQ GL2450H' -> 'GL2450H'
+360                model = name.replace(manufacturer, '', 1).strip()
+361
+362            # if previous method did not work (or if we don't know the manufacturer),
+363            # try taking last word of name
+364            if not model:
+365                try:
+366                    # eg: 'BenQ GL2450H' -> ['BenQ', 'GL2450H']
+367                    model = name.strip().rsplit(' ', 1)[1]
+368                except IndexError:
+369                    # If the name does not include model information then
+370                    # give it something generic
+371                    model = 'Generic Monitor'
+372
+373        return mfg_id, manufacturer, model, name, serial
+374
+375    @staticmethod
+376    def hexdump(file: str) -> str:
+377        '''
+378        Returns a hexadecimal string of binary data from a file
+379
+380        Args:
+381            file (str): the file to read
+382
+383        Returns:
+384            str: one long hex string
+385
+386        Example:
+387            ```python
+388            from screen_brightness_control import EDID
+389
+390            print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
+391            # '00ffffffffffff00...'
+392            ```
+393        '''
+394        with open(file, 'rb') as f:
+395            hex_str = ''.join(f'{char:02x}' for char in f.read())
+396
+397        return hex_str
+
+ + +

Simple structure and method to extract display serial and name from an EDID string.

+
+ + +
+
+ EDID_FORMAT: str = +'>8sHHIBBBBBBBBB10sHB16s18s18s18s18sBB' + + +
+ + +

The byte structure for EDID strings, taken from +pyedid, +Copyright 2019-2020 Jonas Lieb, Davydov Denis.

+
+ + +
+
+
+ SERIAL_DESCRIPTOR = +b'\x00\x00\x00\xff\x00' + + +
+ + + + +
+
+
+ NAME_DESCRIPTOR = +b'\x00\x00\x00\xfc\x00' + + +
+ + + + +
+
+ +
+
@classmethod
+ + def + parse(cls, edid: Union[bytes, str]) -> Tuple[Optional[str], ...]: + + + +
+ + 
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        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: if the EDID info cannot be unpacked
+299            TypeError: if `edid` is not `str` or `bytes`
+300
+301        Example:
+302            ```python
+303            import screen_brightness_control as sbc
+304
+305            edid = sbc.list_monitors_info()[0]['edid']
+306            manufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)
+307
+308            print('Manufacturer:', manufacturer_id or 'Unknown')
+309            print('Model:', model or 'Unknown')
+310            print('Name:', name or 'Unknown')
+311            ```
+312        '''
+313        # see https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format
+314        if isinstance(edid, str):
+315            edid = bytes.fromhex(edid)
+316        elif not isinstance(edid, bytes):
+317            raise TypeError(f'edid must be of type bytes or str, not {type(edid)!r}')
+318
+319        try:
+320            blocks = struct.unpack(cls.EDID_FORMAT, edid)
+321        except struct.error as e:
+322            raise EDIDParseError('cannot unpack edid') from e
+323
+324        # split mfg_id (2 bytes) into 3 letters, 5 bits each (ignoring reserved bit)
+325        mfg_id_chars = (
+326            blocks[1] >> 10,             # First 6 bits (reserved bit at start is always 0)
+327            (blocks[1] >> 5) & 0b11111,  # isolate next 5 bits from first 11 using bitwise AND
+328            blocks[1] & 0b11111          # Last five bits
+329        )
+330        # turn numbers into ascii
+331        mfg_id = ''.join(chr(i + 64) for i in mfg_id_chars)
+332
+333        # now grab the manufacturer name
+334        mfg_lookup = _monitor_brand_lookup(mfg_id)
+335        if mfg_lookup is not None:
+336            manufacturer = mfg_lookup[1]
+337        else:
+338            manufacturer = None
+339
+340        serial = None
+341        name = None
+342        for descriptor_block in blocks[17:21]:
+343            # decode the serial
+344            if descriptor_block.startswith(cls.SERIAL_DESCRIPTOR):
+345                # strip descriptor bytes and trailing whitespace
+346                serial_bytes = descriptor_block[len(cls.SERIAL_DESCRIPTOR):].rstrip()
+347                serial = serial_bytes.decode()
+348
+349            # decode the monitor name
+350            elif descriptor_block.startswith(cls.NAME_DESCRIPTOR):
+351                # strip descriptor bytes and trailing whitespace
+352                name_bytes = descriptor_block[len(cls.NAME_DESCRIPTOR):].rstrip()
+353                name = name_bytes.decode()
+354
+355        # now try to figure out what model the display is
+356        model = None
+357        if name is not None:
+358            if manufacturer is not None and name.startswith(manufacturer):
+359                # eg: 'BenQ GL2450H' -> 'GL2450H'
+360                model = name.replace(manufacturer, '', 1).strip()
+361
+362            # if previous method did not work (or if we don't know the manufacturer),
+363            # try taking last word of name
+364            if not model:
+365                try:
+366                    # eg: 'BenQ GL2450H' -> ['BenQ', 'GL2450H']
+367                    model = name.strip().rsplit(' ', 1)[1]
+368                except IndexError:
+369                    # If the name does not include model information then
+370                    # give it something generic
+371                    model = 'Generic Monitor'
+372
+373        return mfg_id, manufacturer, model, name, serial
+
+ + +

Takes an EDID string and parses some relevant information from it according to the +EDID 1.4 +specification on Wikipedia.

+ +
Arguments:
+ +
    +
  • edid (bytes or str): the EDID, can either be raw bytes or +a hex formatted string (00 ff ff ff ff...)
    • +
+ +
Returns:
+ +
+

tuple[str | None]: A tuple of 5 items representing the display's manufacturer ID, + manufacturer, model, name, serial in that order. + If any of these values are unable to be determined, they will be None. + Otherwise, expect a string

+
+ +
Raises:
+ +
    +
  • EDIDParseError: if the EDID info cannot be unpacked
    • +
  • TypeError: if edid is not str or bytes
    • +
+ +
Example:
+ +
+
+
import screen_brightness_control as sbc
+
+edid = sbc.list_monitors_info()[0]['edid']
+manufacturer_id, manufacturer, model, name, serial = sbc.EDID.parse(edid)
+
+print('Manufacturer:', manufacturer_id or 'Unknown')
+print('Model:', model or 'Unknown')
+print('Name:', name or 'Unknown')
+
+
+
+
+ + +
+
+ +
+
@staticmethod
+ + def + hexdump(file: str) -> str: + + + +
+ + 
375    @staticmethod
+376    def hexdump(file: str) -> str:
+377        '''
+378        Returns a hexadecimal string of binary data from a file
+379
+380        Args:
+381            file (str): the file to read
+382
+383        Returns:
+384            str: one long hex string
+385
+386        Example:
+387            ```python
+388            from screen_brightness_control import EDID
+389
+390            print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
+391            # '00ffffffffffff00...'
+392            ```
+393        '''
+394        with open(file, 'rb') as f:
+395            hex_str = ''.join(f'{char:02x}' for char in f.read())
+396
+397        return hex_str
+
+ + +

Returns a hexadecimal string of binary data from a file

+ +
Arguments:
+ +
    +
  • file (str): the file to read
    • +
+ +
Returns:
+ +
+

str: one long hex string

+
+ +
Example:
+ +
+
+
from screen_brightness_control import EDID
+
+print(EDID.hexdump('/sys/class/backlight/intel_backlight/device/edid'))
+# '00ffffffffffff00...'
+
+
+
+
+ + +
+
+
+ +
+ + def + check_output(command: List[str], max_tries: int = 1) -> bytes: + + + +
+ + 
400def check_output(command: List[str], max_tries: int = 1) -> bytes:
+401    '''
+402    Run a command with retry management built in.
+403
+404    Args:
+405        command: the command to run
+406        max_tries: the maximum number of retries to allow before raising an error
+407
+408    Returns:
+409        The output from the command
+410    '''
+411    tries = 1
+412    while True:
+413        try:
+414            output = subprocess.check_output(command, stderr=subprocess.PIPE)
+415        except subprocess.CalledProcessError as e:
+416            if tries >= max_tries:
+417                raise MaxRetriesExceededError(f'process failed after {tries} tries', e) from e
+418            tries += 1
+419            time.sleep(0.04 if tries < 5 else 0.5)
+420        else:
+421            if tries > 1:
+422                _logger.debug(f'command {command} took {tries}/{max_tries} tries')
+423            return output
+
+ + +

Run a command with retry management built in.

+ +
Arguments:
+ +
    +
  • command: the command to run
    • +
  • max_tries: the maximum number of retries to allow before raising an error
    • +
+ +
Returns:
+ +
+

The output from the command

+
+
+ + +
+
+ +
+ + def + logarithmic_range( start: int, stop: int, step: int = 1) -> collections.abc.Generator[int, None, None]: + + + +
+ + 
426def logarithmic_range(start: int, stop: int, step: int = 1) -> Generator[int, None, None]:
+427    '''
+428    A `range`-like function that yields a sequence of integers following
+429    a logarithmic curve (`y = 10 ^ (x / 50)`) from `start` (inclusive) to
+430    `stop` (inclusive).
+431
+432    This is useful because it skips many of the higher percentages in the
+433    sequence where single percent brightness changes are hard to notice.
+434
+435    This function is designed to deal with brightness percentages, and so
+436    will never return a value less than 0 or greater than 100.
+437
+438    Args:
+439        start: the start of your percentage range
+440        stop: the end of your percentage range
+441        step: the increment per iteration through the sequence
+442
+443    Yields:
+444        int
+445    '''
+446    start = int(max(0, start))
+447    stop = int(min(100, stop))
+448
+449    if start == stop or abs(stop - start) <= 1:
+450        yield start
+451    else:
+452        value_range = stop - start
+453
+454        def direction(x):
+455            return x if step > 0 else 100 - x
+456
+457        last_yielded = None
+458        x: float
+459        for x in range(start, stop + 1, step):
+460            # get difference from base point
+461            x -= start
+462            # calculate progress through our range as a percentage
+463            x = (x / value_range) * 100
+464            # convert along logarithmic curve (inverse of y = 50log(x)) to another percentage
+465            x = 10 ** (direction(x) / 50)
+466            # apply this percentage to our range and add back starting offset
+467            x = int(((direction(x) / 100) * value_range) + start)
+468
+469            if x == last_yielded:
+470                continue
+471            yield x
+472            last_yielded = x
+
+ + +

A range-like function that yields a sequence of integers following +a logarithmic curve (y = 10 ^ (x / 50)) from start (inclusive) to +stop (inclusive).

+ +

This is useful because it skips many of the higher percentages in the +sequence where single percent brightness changes are hard to notice.

+ +

This function is designed to deal with brightness percentages, and so +will never return a value less than 0 or greater than 100.

+ +
Arguments:
+ +
    +
  • start: the start of your percentage range
    • +
  • stop: the end of your percentage range
    • +
  • step: the increment per iteration through the sequence
    • +
+ +
Yields:
+ +
+

int

+
+
+ + +
+
+ +
+ + def + percentage( value: Union[int, str], current: Union[int, Callable[[], int], NoneType] = None, lower_bound: int = 0) -> int: + + + +
+ + 
494def percentage(
+495    value: Percentage,
+496    current: Optional[Union[int, Callable[[], int]]] = None,
+497    lower_bound: int = 0
+498) -> IntPercentage:
+499    '''
+500    Convenience function to convert a brightness value into a percentage. Can handle
+501    integers, floats and strings. Also can handle relative strings (eg: `'+10'` or `'-10'`)
+502
+503    Args:
+504        value: the brightness value to convert
+505        current: the current brightness value or a function that returns the current brightness
+506            value. Used when dealing with relative brightness values
+507        lower_bound: the minimum value the brightness can be set to
+508
+509    Returns:
+510        `.types.IntPercentage`: The new brightness percentage, between `lower_bound` and 100
+511    '''
+512    if isinstance(value, str) and ('+' in value or '-' in value):
+513        if callable(current):
+514            current = current()
+515        value = int(float(value)) + int(float(str(current)))
+516    else:
+517        value = int(float(str(value)))
+518
+519    return min(100, max(lower_bound, value))
+
+ + +

Convenience function to convert a brightness value into a percentage. Can handle +integers, floats and strings. Also can handle relative strings (eg: '+10' or '-10')

+ +
Arguments:
+ +
    +
  • value: the brightness value to convert
    • +
  • current: the current brightness value or a function that returns the current brightness +value. Used when dealing with relative brightness values
    • +
  • lower_bound: the minimum value the brightness can be set to
    • +
+ +
Returns:
+ +
+

screen_brightness_control.types.IntPercentage: The new brightness percentage, between lower_bound and 100

+
+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/0.22.2/screen_brightness_control/linux.html b/docs/0.22.2/screen_brightness_control/linux.html new file mode 100644 index 0000000..b476faa --- /dev/null +++ b/docs/0.22.2/screen_brightness_control/linux.html @@ -0,0 +1,3945 @@ + + + + + + + screen_brightness_control.linux API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control.linux

+ + + + + + + 
  1import fcntl
+  2import functools
+  3import glob
+  4import logging
+  5import operator
+  6import os
+  7import re
+  8import time
+  9from typing import List, Optional, Tuple
+ 10
+ 11from . import filter_monitors, get_methods
+ 12from .exceptions import I2CValidationError, NoValidDisplayError, format_exc
+ 13from .helpers import (EDID, BrightnessMethod, BrightnessMethodAdv, __Cache,
+ 14                      _monitor_brand_lookup, check_output)
+ 15from .types import DisplayIdentifier, IntPercentage
+ 16
+ 17__cache__ = __Cache()
+ 18_logger = logging.getLogger(__name__)
+ 19
+ 20
+ 21class SysFiles(BrightnessMethod):
+ 22    '''
+ 23    A way of getting display information and adjusting the brightness
+ 24    that does not rely on any 3rd party software.
+ 25
+ 26    This class works with displays that show up in the `/sys/class/backlight`
+ 27    directory (so usually laptop displays).
+ 28
+ 29    To set the brightness, your user will need write permissions for
+ 30    `/sys/class/backlight/*/brightness` or you will need to run the program
+ 31    as root.
+ 32    '''
+ 33    _logger = _logger.getChild('SysFiles')
+ 34
+ 35    @classmethod
+ 36    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+ 37        subsystems = set()
+ 38        for folder in os.listdir('/sys/class/backlight'):
+ 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        displays_by_edid = {}
+ 43        index = 0
+ 44
+ 45        for subsystem in subsystems:
+ 46
+ 47            device: dict = {
+ 48                'name': subsystem[0],
+ 49                'path': f'/sys/class/backlight/{subsystem[0]}',
+ 50                'method': cls,
+ 51                'index': index,
+ 52                'model': None,
+ 53                'serial': None,
+ 54                'manufacturer': None,
+ 55                'manufacturer_id': None,
+ 56                'edid': None,
+ 57                'scale': None
+ 58            }
+ 59
+ 60            for folder in subsystem:
+ 61                # subsystems like intel_backlight usually have an acpi_video0
+ 62                # counterpart, which we don't want so lets find the 'best' candidate
+ 63                try:
+ 64                    with open(f'/sys/class/backlight/{folder}/max_brightness') as f:
+ 65                        # scale for SysFiles is just a multiplier for the set/get brightness values
+ 66                        scale = int(f.read().rstrip(' \n')) / 100
+ 67
+ 68                    # use the display with the highest resolution scale
+ 69                    if device['scale'] is None or scale > device['scale']:
+ 70                        device['name'] = folder
+ 71                        device['path'] = f'/sys/class/backlight/{folder}'
+ 72                        device['scale'] = scale
+ 73                except (FileNotFoundError, TypeError) as e:
+ 74                    cls._logger.error(
+ 75                        f'error getting highest resolution scale for {folder}'
+ 76                        f' - {format_exc(e)}'
+ 77                    )
+ 78                    continue
+ 79
+ 80            if os.path.isfile('%s/device/edid' % device['path']):
+ 81                device['edid'] = EDID.hexdump('%s/device/edid' % device['path'])
+ 82
+ 83                for key, value in zip(
+ 84                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+ 85                    EDID.parse(device['edid'])
+ 86                ):
+ 87                    if value is None:
+ 88                        continue
+ 89                    device[key] = value
+ 90
+ 91            displays_by_edid[device['edid']] = device
+ 92            index += 1
+ 93
+ 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'])
+ 98        return all_displays
+ 99
+100    @classmethod
+101    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+102        info = cls.get_display_info()
+103        if display is not None:
+104            info = [info[display]]
+105
+106        results = []
+107        for device in info:
+108            with open(os.path.join(device['path'], 'brightness'), 'r') as f:
+109                brightness = int(f.read().rstrip('\n'))
+110            results.append(int(brightness / device['scale']))
+111
+112        return results
+113
+114    @classmethod
+115    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+116        info = cls.get_display_info()
+117        if display is not None:
+118            info = [info[display]]
+119
+120        for device in info:
+121            with open(os.path.join(device['path'], 'brightness'), 'w') as f:
+122                f.write(str(int(value * device['scale'])))
+123
+124
+125class I2C(BrightnessMethod):
+126    '''
+127    In the same spirit as `SysFiles`, this class serves as a way of getting
+128    display information and adjusting the brightness without relying on any
+129    3rd party software.
+130
+131    Usage of this class requires read and write permission for `/dev/i2c-*`.
+132
+133    This class works over the I2C bus, primarily with desktop monitors as I
+134    haven't tested any e-DP displays yet.
+135
+136    Massive thanks to [siemer](https://github.com/siemer) for
+137    his work on the [ddcci.py](https://github.com/siemer/ddcci) project,
+138    which served as a my main reference for this.
+139
+140    References:
+141        * [ddcci.py](https://github.com/siemer/ddcci)
+142        * [DDCCI Spec](https://milek7.pl/ddcbacklight/ddcci.pdf)
+143    '''
+144    _logger = _logger.getChild('I2C')
+145
+146    # vcp commands
+147    GET_VCP_CMD = 0x01
+148    '''VCP command to get the value of a feature (eg: brightness)'''
+149    GET_VCP_REPLY = 0x02
+150    '''VCP feature reply op code'''
+151    SET_VCP_CMD = 0x03
+152    '''VCP command to set the value of a feature (eg: brightness)'''
+153
+154    # addresses
+155    DDCCI_ADDR = 0x37
+156    '''DDC packets are transmittred using this I2C address'''
+157    HOST_ADDR_R = 0x50
+158    '''Packet source address (the computer) when reading data'''
+159    HOST_ADDR_W = 0x51
+160    '''Packet source address (the computer) when writing data'''
+161    DESTINATION_ADDR_W = 0x6e
+162    '''Packet destination address (the monitor) when writing data'''
+163    I2C_SLAVE = 0x0703
+164    '''The I2C slave address'''
+165
+166    # timings
+167    WAIT_TIME = 0.05
+168    '''How long to wait between I2C commands'''
+169
+170    _max_brightness_cache: dict = {}
+171
+172    class I2CDevice():
+173        '''
+174        Class to read and write data to an I2C bus,
+175        based on the `I2CDev` class from [ddcci.py](https://github.com/siemer/ddcci)
+176        '''
+177
+178        def __init__(self, fname: str, slave_addr: int):
+179            '''
+180            Args:
+181                fname: the I2C path, eg: `/dev/i2c-2`
+182                slave_addr: not entirely sure what this is meant to be
+183            '''
+184            self.device = os.open(fname, os.O_RDWR)
+185            # I2C_SLAVE address setup
+186            fcntl.ioctl(self.device, I2C.I2C_SLAVE, slave_addr)
+187
+188        def read(self, length: int) -> bytes:
+189            '''
+190            Read a certain number of bytes from the I2C bus
+191
+192            Args:
+193                length: the number of bytes to read
+194
+195            Returns:
+196                bytes
+197            '''
+198            return os.read(self.device, length)
+199
+200        def write(self, data: bytes) -> int:
+201            '''
+202            Writes data to the I2C bus
+203
+204            Args:
+205                data: the data to write
+206
+207            Returns:
+208                The number of bytes written
+209            '''
+210            return os.write(self.device, data)
+211
+212    class DDCInterface(I2CDevice):
+213        '''
+214        Class to send DDC (Display Data Channel) commands to an I2C device,
+215        based on the `Ddcci` and `Mccs` classes from [ddcci.py](https://github.com/siemer/ddcci)
+216        '''
+217
+218        PROTOCOL_FLAG = 0x80
+219
+220        def __init__(self, i2c_path: str):
+221            '''
+222            Args:
+223                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+224            '''
+225            self.logger = _logger.getChild(
+226                self.__class__.__name__).getChild(i2c_path)
+227            super().__init__(i2c_path, I2C.DDCCI_ADDR)
+228
+229        def write(self, *args) -> int:
+230            '''
+231            Write some data to the I2C device.
+232
+233            It is recommended to use `setvcp` to set VCP values on the DDC device
+234            instead of using this function directly.
+235
+236            Args:
+237                *args: variable length list of arguments. This will be put
+238                    into a `bytearray` and wrapped up in various flags and
+239                    checksums before being written to the I2C device
+240
+241            Returns:
+242                The number of bytes that were written
+243            '''
+244            time.sleep(I2C.WAIT_TIME)
+245
+246            ba = bytearray(args)
+247            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+248            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+249            ba.append(functools.reduce(operator.xor, ba,
+250                      I2C.DESTINATION_ADDR_W))  # checksum
+251
+252            return super().write(ba)
+253
+254        def setvcp(self, vcp_code: int, value: int) -> int:
+255            '''
+256            Set a VCP value on the device
+257
+258            Args:
+259                vcp_code: the VCP command to send, eg: `0x10` is brightness
+260                value: what to set the value to
+261
+262            Returns:
+263                The number of bytes written to the device
+264            '''
+265            return self.write(I2C.SET_VCP_CMD, vcp_code, *value.to_bytes(2, 'big'))
+266
+267        def read(self, amount: int) -> bytes:
+268            '''
+269            Reads data from the DDC device.
+270
+271            It is recommended to use `getvcp` to retrieve VCP values from the
+272            DDC device instead of using this function directly.
+273
+274            Args:
+275                amount: the number of bytes to read
+276
+277            Raises:
+278                ValueError: if the read data is deemed invalid
+279            '''
+280            time.sleep(I2C.WAIT_TIME)
+281
+282            ba = super().read(amount + 3)
+283
+284            # check the bytes read
+285            checks = {
+286                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+287                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+288                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+289            }
+290            if False in checks.values():
+291                self.logger.error('i2c read check failed: ' + repr(checks))
+292                raise I2CValidationError(
+293                    'i2c read check failed: ' + repr(checks))
+294
+295            return ba[2:-1]
+296
+297        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+298            '''
+299            Retrieves a VCP value from the DDC device.
+300
+301            Args:
+302                vcp_code: the VCP value to read, eg: `0x10` is brightness
+303
+304            Returns:
+305                The current and maximum value respectively
+306
+307            Raises:
+308                ValueError: if the read data is deemed invalid
+309            '''
+310            self.write(I2C.GET_VCP_CMD, vcp_code)
+311            ba = self.read(8)
+312
+313            checks = {
+314                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+315                'supported VCP opcode': ba[1] == 0,
+316                'answer matches request': ba[2] == vcp_code
+317            }
+318            if False in checks.values():
+319                self.logger.error('i2c read check failed: ' + repr(checks))
+320                raise I2CValidationError(
+321                    'i2c read check failed: ' + repr(checks))
+322
+323            # current and max values
+324            return int.from_bytes(ba[6:8], 'big'), int.from_bytes(ba[4:6], 'big')
+325
+326    @classmethod
+327    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+328        all_displays = __cache__.get('i2c_display_info')
+329        if all_displays is None:
+330            all_displays = []
+331            index = 0
+332
+333            for i2c_path in glob.glob('/dev/i2c-*'):
+334                if not os.path.exists(i2c_path):
+335                    continue
+336
+337                try:
+338                    # open the I2C device using the host read address
+339                    device = cls.I2CDevice(i2c_path, cls.HOST_ADDR_R)
+340                    # read some 512 bytes from the device
+341                    data = device.read(512)
+342                except IOError as e:
+343                    cls._logger.error(
+344                        f'IOError reading from device {i2c_path}: {e}')
+345                    continue
+346
+347                # search for the EDID header within our 512 read bytes
+348                start = data.find(bytes.fromhex('00 FF FF FF FF FF FF 00'))
+349                if start < 0:
+350                    continue
+351
+352                # grab 128 bytes of the edid
+353                edid = data[start: start + 128]
+354                # parse the EDID
+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
+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            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)
+434
+435
+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        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]
+502
+503
+504class XRandr(BrightnessMethodAdv):
+505    '''collection of screen brightness related methods using the xrandr executable'''
+506
+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        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', '').replace(' ', '') 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        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])
+612
+613
+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            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 '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        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 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            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            )
+808
+809
+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 `.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    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 []
+843
+844
+845METHODS = (SysFiles, I2C, XRandr, DDCUtil, Light)
+
+ + +
+ +
+
+ +
+ + class + SysFiles(screen_brightness_control.helpers.BrightnessMethod): + + + +
+ + 
 22class SysFiles(BrightnessMethod):
+ 23    '''
+ 24    A way of getting display information and adjusting the brightness
+ 25    that does not rely on any 3rd party software.
+ 26
+ 27    This class works with displays that show up in the `/sys/class/backlight`
+ 28    directory (so usually laptop displays).
+ 29
+ 30    To set the brightness, your user will need write permissions for
+ 31    `/sys/class/backlight/*/brightness` or you will need to run the program
+ 32    as root.
+ 33    '''
+ 34    _logger = _logger.getChild('SysFiles')
+ 35
+ 36    @classmethod
+ 37    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+ 38        subsystems = set()
+ 39        for folder in os.listdir('/sys/class/backlight'):
+ 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        displays_by_edid = {}
+ 44        index = 0
+ 45
+ 46        for subsystem in subsystems:
+ 47
+ 48            device: dict = {
+ 49                'name': subsystem[0],
+ 50                'path': f'/sys/class/backlight/{subsystem[0]}',
+ 51                'method': cls,
+ 52                'index': index,
+ 53                'model': None,
+ 54                'serial': None,
+ 55                'manufacturer': None,
+ 56                'manufacturer_id': None,
+ 57                'edid': None,
+ 58                'scale': None
+ 59            }
+ 60
+ 61            for folder in subsystem:
+ 62                # subsystems like intel_backlight usually have an acpi_video0
+ 63                # counterpart, which we don't want so lets find the 'best' candidate
+ 64                try:
+ 65                    with open(f'/sys/class/backlight/{folder}/max_brightness') as f:
+ 66                        # scale for SysFiles is just a multiplier for the set/get brightness values
+ 67                        scale = int(f.read().rstrip(' \n')) / 100
+ 68
+ 69                    # use the display with the highest resolution scale
+ 70                    if device['scale'] is None or scale > device['scale']:
+ 71                        device['name'] = folder
+ 72                        device['path'] = f'/sys/class/backlight/{folder}'
+ 73                        device['scale'] = scale
+ 74                except (FileNotFoundError, TypeError) as e:
+ 75                    cls._logger.error(
+ 76                        f'error getting highest resolution scale for {folder}'
+ 77                        f' - {format_exc(e)}'
+ 78                    )
+ 79                    continue
+ 80
+ 81            if os.path.isfile('%s/device/edid' % device['path']):
+ 82                device['edid'] = EDID.hexdump('%s/device/edid' % device['path'])
+ 83
+ 84                for key, value in zip(
+ 85                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+ 86                    EDID.parse(device['edid'])
+ 87                ):
+ 88                    if value is None:
+ 89                        continue
+ 90                    device[key] = value
+ 91
+ 92            displays_by_edid[device['edid']] = device
+ 93            index += 1
+ 94
+ 95        all_displays = list(displays_by_edid.values())
+ 96        if display is not None:
+ 97            all_displays = filter_monitors(
+ 98                display=display, haystack=all_displays, include=['path'])
+ 99        return all_displays
+100
+101    @classmethod
+102    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+103        info = cls.get_display_info()
+104        if display is not None:
+105            info = [info[display]]
+106
+107        results = []
+108        for device in info:
+109            with open(os.path.join(device['path'], 'brightness'), 'r') as f:
+110                brightness = int(f.read().rstrip('\n'))
+111            results.append(int(brightness / device['scale']))
+112
+113        return results
+114
+115    @classmethod
+116    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+117        info = cls.get_display_info()
+118        if display is not None:
+119            info = [info[display]]
+120
+121        for device in info:
+122            with open(os.path.join(device['path'], 'brightness'), 'w') as f:
+123                f.write(str(int(value * device['scale'])))
+
+ + +

A way of getting display information and adjusting the brightness +that does not rely on any 3rd party software.

+ +

This class works with displays that show up in the /sys/class/backlight +directory (so usually laptop displays).

+ +

To set the brightness, your user will need write permissions for +/sys/class/backlight/*/brightness or you will need to run the program +as root.

+
+ + +
+ +
+
@classmethod
+ + def + get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]: + + + +
+ + 
36    @classmethod
+37    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+38        subsystems = set()
+39        for folder in os.listdir('/sys/class/backlight'):
+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        displays_by_edid = {}
+44        index = 0
+45
+46        for subsystem in subsystems:
+47
+48            device: dict = {
+49                'name': subsystem[0],
+50                'path': f'/sys/class/backlight/{subsystem[0]}',
+51                'method': cls,
+52                'index': index,
+53                'model': None,
+54                'serial': None,
+55                'manufacturer': None,
+56                'manufacturer_id': None,
+57                'edid': None,
+58                'scale': None
+59            }
+60
+61            for folder in subsystem:
+62                # subsystems like intel_backlight usually have an acpi_video0
+63                # counterpart, which we don't want so lets find the 'best' candidate
+64                try:
+65                    with open(f'/sys/class/backlight/{folder}/max_brightness') as f:
+66                        # scale for SysFiles is just a multiplier for the set/get brightness values
+67                        scale = int(f.read().rstrip(' \n')) / 100
+68
+69                    # use the display with the highest resolution scale
+70                    if device['scale'] is None or scale > device['scale']:
+71                        device['name'] = folder
+72                        device['path'] = f'/sys/class/backlight/{folder}'
+73                        device['scale'] = scale
+74                except (FileNotFoundError, TypeError) as e:
+75                    cls._logger.error(
+76                        f'error getting highest resolution scale for {folder}'
+77                        f' - {format_exc(e)}'
+78                    )
+79                    continue
+80
+81            if os.path.isfile('%s/device/edid' % device['path']):
+82                device['edid'] = EDID.hexdump('%s/device/edid' % device['path'])
+83
+84                for key, value in zip(
+85                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+86                    EDID.parse(device['edid'])
+87                ):
+88                    if value is None:
+89                        continue
+90                    device[key] = value
+91
+92            displays_by_edid[device['edid']] = device
+93            index += 1
+94
+95        all_displays = list(displays_by_edid.values())
+96        if display is not None:
+97            all_displays = filter_monitors(
+98                display=display, haystack=all_displays, include=['path'])
+99        return all_displays
+
+ + +

Return information about detected displays.

+ +
Arguments:
+ + + +
Returns:
+ +
+

A list of dictionaries, each representing a detected display. + Each returned dictionary will have the following keys:

+ +
    +
  • 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)
    • +
  • 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
    • +
  • index (int): the index of the display, relative to the brightness method
    • +
+
+
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
101    @classmethod
+102    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+103        info = cls.get_display_info()
+104        if display is not None:
+105            info = [info[display]]
+106
+107        results = []
+108        for device in info:
+109            with open(os.path.join(device['path'], 'brightness'), 'r') as f:
+110                brightness = int(f.read().rstrip('\n'))
+111            results.append(int(brightness / device['scale']))
+112
+113        return results
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
+ +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, one for each + queried display

+
+
+ + +
+
+ +
+
@classmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None): + + + +
+ + 
115    @classmethod
+116    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+117        info = cls.get_display_info()
+118        if display is not None:
+119            info = [info[display]]
+120
+121        for device in info:
+122            with open(os.path.join(device['path'], 'brightness'), 'w') as f:
+123                f.write(str(int(value * device['scale'])))
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + class + I2C(screen_brightness_control.helpers.BrightnessMethod): + + + +
+ + 
126class I2C(BrightnessMethod):
+127    '''
+128    In the same spirit as `SysFiles`, this class serves as a way of getting
+129    display information and adjusting the brightness without relying on any
+130    3rd party software.
+131
+132    Usage of this class requires read and write permission for `/dev/i2c-*`.
+133
+134    This class works over the I2C bus, primarily with desktop monitors as I
+135    haven't tested any e-DP displays yet.
+136
+137    Massive thanks to [siemer](https://github.com/siemer) for
+138    his work on the [ddcci.py](https://github.com/siemer/ddcci) project,
+139    which served as a my main reference for this.
+140
+141    References:
+142        * [ddcci.py](https://github.com/siemer/ddcci)
+143        * [DDCCI Spec](https://milek7.pl/ddcbacklight/ddcci.pdf)
+144    '''
+145    _logger = _logger.getChild('I2C')
+146
+147    # vcp commands
+148    GET_VCP_CMD = 0x01
+149    '''VCP command to get the value of a feature (eg: brightness)'''
+150    GET_VCP_REPLY = 0x02
+151    '''VCP feature reply op code'''
+152    SET_VCP_CMD = 0x03
+153    '''VCP command to set the value of a feature (eg: brightness)'''
+154
+155    # addresses
+156    DDCCI_ADDR = 0x37
+157    '''DDC packets are transmittred using this I2C address'''
+158    HOST_ADDR_R = 0x50
+159    '''Packet source address (the computer) when reading data'''
+160    HOST_ADDR_W = 0x51
+161    '''Packet source address (the computer) when writing data'''
+162    DESTINATION_ADDR_W = 0x6e
+163    '''Packet destination address (the monitor) when writing data'''
+164    I2C_SLAVE = 0x0703
+165    '''The I2C slave address'''
+166
+167    # timings
+168    WAIT_TIME = 0.05
+169    '''How long to wait between I2C commands'''
+170
+171    _max_brightness_cache: dict = {}
+172
+173    class I2CDevice():
+174        '''
+175        Class to read and write data to an I2C bus,
+176        based on the `I2CDev` class from [ddcci.py](https://github.com/siemer/ddcci)
+177        '''
+178
+179        def __init__(self, fname: str, slave_addr: int):
+180            '''
+181            Args:
+182                fname: the I2C path, eg: `/dev/i2c-2`
+183                slave_addr: not entirely sure what this is meant to be
+184            '''
+185            self.device = os.open(fname, os.O_RDWR)
+186            # I2C_SLAVE address setup
+187            fcntl.ioctl(self.device, I2C.I2C_SLAVE, slave_addr)
+188
+189        def read(self, length: int) -> bytes:
+190            '''
+191            Read a certain number of bytes from the I2C bus
+192
+193            Args:
+194                length: the number of bytes to read
+195
+196            Returns:
+197                bytes
+198            '''
+199            return os.read(self.device, length)
+200
+201        def write(self, data: bytes) -> int:
+202            '''
+203            Writes data to the I2C bus
+204
+205            Args:
+206                data: the data to write
+207
+208            Returns:
+209                The number of bytes written
+210            '''
+211            return os.write(self.device, data)
+212
+213    class DDCInterface(I2CDevice):
+214        '''
+215        Class to send DDC (Display Data Channel) commands to an I2C device,
+216        based on the `Ddcci` and `Mccs` classes from [ddcci.py](https://github.com/siemer/ddcci)
+217        '''
+218
+219        PROTOCOL_FLAG = 0x80
+220
+221        def __init__(self, i2c_path: str):
+222            '''
+223            Args:
+224                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+225            '''
+226            self.logger = _logger.getChild(
+227                self.__class__.__name__).getChild(i2c_path)
+228            super().__init__(i2c_path, I2C.DDCCI_ADDR)
+229
+230        def write(self, *args) -> int:
+231            '''
+232            Write some data to the I2C device.
+233
+234            It is recommended to use `setvcp` to set VCP values on the DDC device
+235            instead of using this function directly.
+236
+237            Args:
+238                *args: variable length list of arguments. This will be put
+239                    into a `bytearray` and wrapped up in various flags and
+240                    checksums before being written to the I2C device
+241
+242            Returns:
+243                The number of bytes that were written
+244            '''
+245            time.sleep(I2C.WAIT_TIME)
+246
+247            ba = bytearray(args)
+248            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+249            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+250            ba.append(functools.reduce(operator.xor, ba,
+251                      I2C.DESTINATION_ADDR_W))  # checksum
+252
+253            return super().write(ba)
+254
+255        def setvcp(self, vcp_code: int, value: int) -> int:
+256            '''
+257            Set a VCP value on the device
+258
+259            Args:
+260                vcp_code: the VCP command to send, eg: `0x10` is brightness
+261                value: what to set the value to
+262
+263            Returns:
+264                The number of bytes written to the device
+265            '''
+266            return self.write(I2C.SET_VCP_CMD, vcp_code, *value.to_bytes(2, 'big'))
+267
+268        def read(self, amount: int) -> bytes:
+269            '''
+270            Reads data from the DDC device.
+271
+272            It is recommended to use `getvcp` to retrieve VCP values from the
+273            DDC device instead of using this function directly.
+274
+275            Args:
+276                amount: the number of bytes to read
+277
+278            Raises:
+279                ValueError: if the read data is deemed invalid
+280            '''
+281            time.sleep(I2C.WAIT_TIME)
+282
+283            ba = super().read(amount + 3)
+284
+285            # check the bytes read
+286            checks = {
+287                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+288                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+289                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+290            }
+291            if False in checks.values():
+292                self.logger.error('i2c read check failed: ' + repr(checks))
+293                raise I2CValidationError(
+294                    'i2c read check failed: ' + repr(checks))
+295
+296            return ba[2:-1]
+297
+298        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+299            '''
+300            Retrieves a VCP value from the DDC device.
+301
+302            Args:
+303                vcp_code: the VCP value to read, eg: `0x10` is brightness
+304
+305            Returns:
+306                The current and maximum value respectively
+307
+308            Raises:
+309                ValueError: if the read data is deemed invalid
+310            '''
+311            self.write(I2C.GET_VCP_CMD, vcp_code)
+312            ba = self.read(8)
+313
+314            checks = {
+315                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+316                'supported VCP opcode': ba[1] == 0,
+317                'answer matches request': ba[2] == vcp_code
+318            }
+319            if False in checks.values():
+320                self.logger.error('i2c read check failed: ' + repr(checks))
+321                raise I2CValidationError(
+322                    'i2c read check failed: ' + repr(checks))
+323
+324            # current and max values
+325            return int.from_bytes(ba[6:8], 'big'), int.from_bytes(ba[4:6], 'big')
+326
+327    @classmethod
+328    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+329        all_displays = __cache__.get('i2c_display_info')
+330        if all_displays is None:
+331            all_displays = []
+332            index = 0
+333
+334            for i2c_path in glob.glob('/dev/i2c-*'):
+335                if not os.path.exists(i2c_path):
+336                    continue
+337
+338                try:
+339                    # open the I2C device using the host read address
+340                    device = cls.I2CDevice(i2c_path, cls.HOST_ADDR_R)
+341                    # read some 512 bytes from the device
+342                    data = device.read(512)
+343                except IOError as e:
+344                    cls._logger.error(
+345                        f'IOError reading from device {i2c_path}: {e}')
+346                    continue
+347
+348                # search for the EDID header within our 512 read bytes
+349                start = data.find(bytes.fromhex('00 FF FF FF FF FF FF 00'))
+350                if start < 0:
+351                    continue
+352
+353                # grab 128 bytes of the edid
+354                edid = data[start: start + 128]
+355                # parse the EDID
+356                (
+357                    manufacturer_id,
+358                    manufacturer,
+359                    model,
+360                    name,
+361                    serial
+362                ) = EDID.parse(edid)
+363
+364                all_displays.append(
+365                    {
+366                        'name': name,
+367                        'model': model,
+368                        'manufacturer': manufacturer,
+369                        'manufacturer_id': manufacturer_id,
+370                        'serial': serial,
+371                        'method': cls,
+372                        'index': index,
+373                        # convert edid to hex string
+374                        'edid': ''.join(f'{i:02x}' for i in edid),
+375                        'i2c_bus': i2c_path
+376                    }
+377                )
+378                index += 1
+379
+380            if all_displays:
+381                __cache__.store('i2c_display_info', all_displays, expires=2)
+382
+383        if display is not None:
+384            return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+385        return all_displays
+386
+387    @classmethod
+388    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+389        all_displays = cls.get_display_info()
+390        if display is not None:
+391            all_displays = [all_displays[display]]
+392
+393        results = []
+394        for device in all_displays:
+395            interface = cls.DDCInterface(device['i2c_bus'])
+396            value, max_value = interface.getvcp(0x10)
+397
+398            # make sure display's max brighness is cached
+399            cache_ident = '%s-%s-%s' % (device['name'],
+400                                        device['model'], device['serial'])
+401            if cache_ident not in cls._max_brightness_cache:
+402                cls._max_brightness_cache[cache_ident] = max_value
+403                cls._logger.info(
+404                    f'{cache_ident} max brightness:{max_value} (current: {value})')
+405
+406            if max_value != 100:
+407                # if max value is not 100 then we have to adjust the scale to be
+408                # a percentage
+409                value = int((value / max_value) * 100)
+410
+411            results.append(value)
+412
+413        return results
+414
+415    @classmethod
+416    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+417        all_displays = cls.get_display_info()
+418        if display is not None:
+419            all_displays = [all_displays[display]]
+420
+421        for device in all_displays:
+422            # make sure display brightness max value is cached
+423            cache_ident = '%s-%s-%s' % (device['name'],
+424                                        device['model'], device['serial'])
+425            if cache_ident not in cls._max_brightness_cache:
+426                cls.get_brightness(display=device['index'])
+427
+428            # scale the brightness value according to the max brightness
+429            max_value = cls._max_brightness_cache[cache_ident]
+430            if max_value != 100:
+431                value = int((value / 100) * max_value)
+432
+433            interface = cls.DDCInterface(device['i2c_bus'])
+434            interface.setvcp(0x10, value)
+
+ + +

In the same spirit as SysFiles, this class serves as a way of getting +display information and adjusting the brightness without relying on any +3rd party software.

+ +

Usage of this class requires read and write permission for /dev/i2c-*.

+ +

This class works over the I2C bus, primarily with desktop monitors as I +haven't tested any e-DP displays yet.

+ +

Massive thanks to siemer for +his work on the ddcci.py project, +which served as a my main reference for this.

+ +
References:
+ +
+ +
+
+ + +
+
+ GET_VCP_CMD = +1 + + +
+ + +

VCP command to get the value of a feature (eg: brightness)

+
+ + +
+
+
+ GET_VCP_REPLY = +2 + + +
+ + +

VCP feature reply op code

+
+ + +
+
+
+ SET_VCP_CMD = +3 + + +
+ + +

VCP command to set the value of a feature (eg: brightness)

+
+ + +
+
+
+ DDCCI_ADDR = +55 + + +
+ + +

DDC packets are transmittred using this I2C address

+
+ + +
+
+
+ HOST_ADDR_R = +80 + + +
+ + +

Packet source address (the computer) when reading data

+
+ + +
+
+
+ HOST_ADDR_W = +81 + + +
+ + +

Packet source address (the computer) when writing data

+
+ + +
+
+
+ DESTINATION_ADDR_W = +110 + + +
+ + +

Packet destination address (the monitor) when writing data

+
+ + +
+
+
+ I2C_SLAVE = +1795 + + +
+ + +

The I2C slave address

+
+ + +
+
+
+ WAIT_TIME = +0.05 + + +
+ + +

How long to wait between I2C commands

+
+ + +
+
+ +
+
@classmethod
+ + def + get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]: + + + +
+ + 
327    @classmethod
+328    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+329        all_displays = __cache__.get('i2c_display_info')
+330        if all_displays is None:
+331            all_displays = []
+332            index = 0
+333
+334            for i2c_path in glob.glob('/dev/i2c-*'):
+335                if not os.path.exists(i2c_path):
+336                    continue
+337
+338                try:
+339                    # open the I2C device using the host read address
+340                    device = cls.I2CDevice(i2c_path, cls.HOST_ADDR_R)
+341                    # read some 512 bytes from the device
+342                    data = device.read(512)
+343                except IOError as e:
+344                    cls._logger.error(
+345                        f'IOError reading from device {i2c_path}: {e}')
+346                    continue
+347
+348                # search for the EDID header within our 512 read bytes
+349                start = data.find(bytes.fromhex('00 FF FF FF FF FF FF 00'))
+350                if start < 0:
+351                    continue
+352
+353                # grab 128 bytes of the edid
+354                edid = data[start: start + 128]
+355                # parse the EDID
+356                (
+357                    manufacturer_id,
+358                    manufacturer,
+359                    model,
+360                    name,
+361                    serial
+362                ) = EDID.parse(edid)
+363
+364                all_displays.append(
+365                    {
+366                        'name': name,
+367                        'model': model,
+368                        'manufacturer': manufacturer,
+369                        'manufacturer_id': manufacturer_id,
+370                        'serial': serial,
+371                        'method': cls,
+372                        'index': index,
+373                        # convert edid to hex string
+374                        'edid': ''.join(f'{i:02x}' for i in edid),
+375                        'i2c_bus': i2c_path
+376                    }
+377                )
+378                index += 1
+379
+380            if all_displays:
+381                __cache__.store('i2c_display_info', all_displays, expires=2)
+382
+383        if display is not None:
+384            return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+385        return all_displays
+
+ + +

Return information about detected displays.

+ +
Arguments:
+ + + +
Returns:
+ +
+

A list of dictionaries, each representing a detected display. + Each returned dictionary will have the following keys:

+ +
    +
  • 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)
    • +
  • 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
    • +
  • index (int): the index of the display, relative to the brightness method
    • +
+
+
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
387    @classmethod
+388    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+389        all_displays = cls.get_display_info()
+390        if display is not None:
+391            all_displays = [all_displays[display]]
+392
+393        results = []
+394        for device in all_displays:
+395            interface = cls.DDCInterface(device['i2c_bus'])
+396            value, max_value = interface.getvcp(0x10)
+397
+398            # make sure display's max brighness is cached
+399            cache_ident = '%s-%s-%s' % (device['name'],
+400                                        device['model'], device['serial'])
+401            if cache_ident not in cls._max_brightness_cache:
+402                cls._max_brightness_cache[cache_ident] = max_value
+403                cls._logger.info(
+404                    f'{cache_ident} max brightness:{max_value} (current: {value})')
+405
+406            if max_value != 100:
+407                # if max value is not 100 then we have to adjust the scale to be
+408                # a percentage
+409                value = int((value / max_value) * 100)
+410
+411            results.append(value)
+412
+413        return results
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
+ +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, one for each + queried display

+
+
+ + +
+
+ +
+
@classmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None): + + + +
+ + 
415    @classmethod
+416    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+417        all_displays = cls.get_display_info()
+418        if display is not None:
+419            all_displays = [all_displays[display]]
+420
+421        for device in all_displays:
+422            # make sure display brightness max value is cached
+423            cache_ident = '%s-%s-%s' % (device['name'],
+424                                        device['model'], device['serial'])
+425            if cache_ident not in cls._max_brightness_cache:
+426                cls.get_brightness(display=device['index'])
+427
+428            # scale the brightness value according to the max brightness
+429            max_value = cls._max_brightness_cache[cache_ident]
+430            if max_value != 100:
+431                value = int((value / 100) * max_value)
+432
+433            interface = cls.DDCInterface(device['i2c_bus'])
+434            interface.setvcp(0x10, value)
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + class + I2C.I2CDevice: + + + +
+ + 
173    class I2CDevice():
+174        '''
+175        Class to read and write data to an I2C bus,
+176        based on the `I2CDev` class from [ddcci.py](https://github.com/siemer/ddcci)
+177        '''
+178
+179        def __init__(self, fname: str, slave_addr: int):
+180            '''
+181            Args:
+182                fname: the I2C path, eg: `/dev/i2c-2`
+183                slave_addr: not entirely sure what this is meant to be
+184            '''
+185            self.device = os.open(fname, os.O_RDWR)
+186            # I2C_SLAVE address setup
+187            fcntl.ioctl(self.device, I2C.I2C_SLAVE, slave_addr)
+188
+189        def read(self, length: int) -> bytes:
+190            '''
+191            Read a certain number of bytes from the I2C bus
+192
+193            Args:
+194                length: the number of bytes to read
+195
+196            Returns:
+197                bytes
+198            '''
+199            return os.read(self.device, length)
+200
+201        def write(self, data: bytes) -> int:
+202            '''
+203            Writes data to the I2C bus
+204
+205            Args:
+206                data: the data to write
+207
+208            Returns:
+209                The number of bytes written
+210            '''
+211            return os.write(self.device, data)
+
+ + +

Class to read and write data to an I2C bus, +based on the I2CDev class from ddcci.py

+
+ + +
+ +
+ + I2C.I2CDevice(fname: str, slave_addr: int) + + + +
+ + 
179        def __init__(self, fname: str, slave_addr: int):
+180            '''
+181            Args:
+182                fname: the I2C path, eg: `/dev/i2c-2`
+183                slave_addr: not entirely sure what this is meant to be
+184            '''
+185            self.device = os.open(fname, os.O_RDWR)
+186            # I2C_SLAVE address setup
+187            fcntl.ioctl(self.device, I2C.I2C_SLAVE, slave_addr)
+
+ + +
Arguments:
+ +
    +
  • fname: the I2C path, eg: /dev/i2c-2
    • +
  • slave_addr: not entirely sure what this is meant to be
    • +
+
+ + +
+
+
+ device + + +
+ + + + +
+
+ +
+ + def + read(self, length: int) -> bytes: + + + +
+ + 
189        def read(self, length: int) -> bytes:
+190            '''
+191            Read a certain number of bytes from the I2C bus
+192
+193            Args:
+194                length: the number of bytes to read
+195
+196            Returns:
+197                bytes
+198            '''
+199            return os.read(self.device, length)
+
+ + +

Read a certain number of bytes from the I2C bus

+ +
Arguments:
+ +
    +
  • length: the number of bytes to read
    • +
+ +
Returns:
+ +
+

bytes

+
+
+ + +
+
+ +
+ + def + write(self, data: bytes) -> int: + + + +
+ + 
201        def write(self, data: bytes) -> int:
+202            '''
+203            Writes data to the I2C bus
+204
+205            Args:
+206                data: the data to write
+207
+208            Returns:
+209                The number of bytes written
+210            '''
+211            return os.write(self.device, data)
+
+ + +

Writes data to the I2C bus

+ +
Arguments:
+ +
    +
  • data: the data to write
    • +
+ +
Returns:
+ +
+

The number of bytes written

+
+
+ + +
+
+
+ +
+ + class + I2C.DDCInterface(I2C.I2CDevice): + + + +
+ + 
213    class DDCInterface(I2CDevice):
+214        '''
+215        Class to send DDC (Display Data Channel) commands to an I2C device,
+216        based on the `Ddcci` and `Mccs` classes from [ddcci.py](https://github.com/siemer/ddcci)
+217        '''
+218
+219        PROTOCOL_FLAG = 0x80
+220
+221        def __init__(self, i2c_path: str):
+222            '''
+223            Args:
+224                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+225            '''
+226            self.logger = _logger.getChild(
+227                self.__class__.__name__).getChild(i2c_path)
+228            super().__init__(i2c_path, I2C.DDCCI_ADDR)
+229
+230        def write(self, *args) -> int:
+231            '''
+232            Write some data to the I2C device.
+233
+234            It is recommended to use `setvcp` to set VCP values on the DDC device
+235            instead of using this function directly.
+236
+237            Args:
+238                *args: variable length list of arguments. This will be put
+239                    into a `bytearray` and wrapped up in various flags and
+240                    checksums before being written to the I2C device
+241
+242            Returns:
+243                The number of bytes that were written
+244            '''
+245            time.sleep(I2C.WAIT_TIME)
+246
+247            ba = bytearray(args)
+248            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+249            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+250            ba.append(functools.reduce(operator.xor, ba,
+251                      I2C.DESTINATION_ADDR_W))  # checksum
+252
+253            return super().write(ba)
+254
+255        def setvcp(self, vcp_code: int, value: int) -> int:
+256            '''
+257            Set a VCP value on the device
+258
+259            Args:
+260                vcp_code: the VCP command to send, eg: `0x10` is brightness
+261                value: what to set the value to
+262
+263            Returns:
+264                The number of bytes written to the device
+265            '''
+266            return self.write(I2C.SET_VCP_CMD, vcp_code, *value.to_bytes(2, 'big'))
+267
+268        def read(self, amount: int) -> bytes:
+269            '''
+270            Reads data from the DDC device.
+271
+272            It is recommended to use `getvcp` to retrieve VCP values from the
+273            DDC device instead of using this function directly.
+274
+275            Args:
+276                amount: the number of bytes to read
+277
+278            Raises:
+279                ValueError: if the read data is deemed invalid
+280            '''
+281            time.sleep(I2C.WAIT_TIME)
+282
+283            ba = super().read(amount + 3)
+284
+285            # check the bytes read
+286            checks = {
+287                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+288                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+289                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+290            }
+291            if False in checks.values():
+292                self.logger.error('i2c read check failed: ' + repr(checks))
+293                raise I2CValidationError(
+294                    'i2c read check failed: ' + repr(checks))
+295
+296            return ba[2:-1]
+297
+298        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+299            '''
+300            Retrieves a VCP value from the DDC device.
+301
+302            Args:
+303                vcp_code: the VCP value to read, eg: `0x10` is brightness
+304
+305            Returns:
+306                The current and maximum value respectively
+307
+308            Raises:
+309                ValueError: if the read data is deemed invalid
+310            '''
+311            self.write(I2C.GET_VCP_CMD, vcp_code)
+312            ba = self.read(8)
+313
+314            checks = {
+315                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+316                'supported VCP opcode': ba[1] == 0,
+317                'answer matches request': ba[2] == vcp_code
+318            }
+319            if False in checks.values():
+320                self.logger.error('i2c read check failed: ' + repr(checks))
+321                raise I2CValidationError(
+322                    'i2c read check failed: ' + repr(checks))
+323
+324            # current and max values
+325            return int.from_bytes(ba[6:8], 'big'), int.from_bytes(ba[4:6], 'big')
+
+ + +

Class to send DDC (Display Data Channel) commands to an I2C device, +based on the Ddcci and Mccs classes from ddcci.py

+
+ + +
+ +
+ + I2C.DDCInterface(i2c_path: str) + + + +
+ + 
221        def __init__(self, i2c_path: str):
+222            '''
+223            Args:
+224                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+225            '''
+226            self.logger = _logger.getChild(
+227                self.__class__.__name__).getChild(i2c_path)
+228            super().__init__(i2c_path, I2C.DDCCI_ADDR)
+
+ + +
Arguments:
+ +
    +
  • i2c_path: the path to the I2C device, eg: /dev/i2c-2
    • +
+
+ + +
+
+
+ PROTOCOL_FLAG = +128 + + +
+ + + + +
+
+
+ logger + + +
+ + + + +
+
+ +
+ + def + write(self, *args) -> int: + + + +
+ + 
230        def write(self, *args) -> int:
+231            '''
+232            Write some data to the I2C device.
+233
+234            It is recommended to use `setvcp` to set VCP values on the DDC device
+235            instead of using this function directly.
+236
+237            Args:
+238                *args: variable length list of arguments. This will be put
+239                    into a `bytearray` and wrapped up in various flags and
+240                    checksums before being written to the I2C device
+241
+242            Returns:
+243                The number of bytes that were written
+244            '''
+245            time.sleep(I2C.WAIT_TIME)
+246
+247            ba = bytearray(args)
+248            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+249            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+250            ba.append(functools.reduce(operator.xor, ba,
+251                      I2C.DESTINATION_ADDR_W))  # checksum
+252
+253            return super().write(ba)
+
+ + +

Write some data to the I2C device.

+ +

It is recommended to use setvcp to set VCP values on the DDC device +instead of using this function directly.

+ +
Arguments:
+ +
    +
  • *args: variable length list of arguments. This will be put +into a bytearray and wrapped up in various flags and +checksums before being written to the I2C device
    • +
+ +
Returns:
+ +
+

The number of bytes that were written

+
+
+ + +
+
+ +
+ + def + setvcp(self, vcp_code: int, value: int) -> int: + + + +
+ + 
255        def setvcp(self, vcp_code: int, value: int) -> int:
+256            '''
+257            Set a VCP value on the device
+258
+259            Args:
+260                vcp_code: the VCP command to send, eg: `0x10` is brightness
+261                value: what to set the value to
+262
+263            Returns:
+264                The number of bytes written to the device
+265            '''
+266            return self.write(I2C.SET_VCP_CMD, vcp_code, *value.to_bytes(2, 'big'))
+
+ + +

Set a VCP value on the device

+ +
Arguments:
+ +
    +
  • vcp_code: the VCP command to send, eg: 0x10 is brightness
    • +
  • value: what to set the value to
    • +
+ +
Returns:
+ +
+

The number of bytes written to the device

+
+
+ + +
+
+ +
+ + def + read(self, amount: int) -> bytes: + + + +
+ + 
268        def read(self, amount: int) -> bytes:
+269            '''
+270            Reads data from the DDC device.
+271
+272            It is recommended to use `getvcp` to retrieve VCP values from the
+273            DDC device instead of using this function directly.
+274
+275            Args:
+276                amount: the number of bytes to read
+277
+278            Raises:
+279                ValueError: if the read data is deemed invalid
+280            '''
+281            time.sleep(I2C.WAIT_TIME)
+282
+283            ba = super().read(amount + 3)
+284
+285            # check the bytes read
+286            checks = {
+287                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+288                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+289                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+290            }
+291            if False in checks.values():
+292                self.logger.error('i2c read check failed: ' + repr(checks))
+293                raise I2CValidationError(
+294                    'i2c read check failed: ' + repr(checks))
+295
+296            return ba[2:-1]
+
+ + +

Reads data from the DDC device.

+ +

It is recommended to use getvcp to retrieve VCP values from the +DDC device instead of using this function directly.

+ +
Arguments:
+ +
    +
  • amount: the number of bytes to read
    • +
+ +
Raises:
+ +
    +
  • ValueError: if the read data is deemed invalid
    • +
+
+ + +
+
+ +
+ + def + getvcp(self, vcp_code: int) -> Tuple[int, int]: + + + +
+ + 
298        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+299            '''
+300            Retrieves a VCP value from the DDC device.
+301
+302            Args:
+303                vcp_code: the VCP value to read, eg: `0x10` is brightness
+304
+305            Returns:
+306                The current and maximum value respectively
+307
+308            Raises:
+309                ValueError: if the read data is deemed invalid
+310            '''
+311            self.write(I2C.GET_VCP_CMD, vcp_code)
+312            ba = self.read(8)
+313
+314            checks = {
+315                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+316                'supported VCP opcode': ba[1] == 0,
+317                'answer matches request': ba[2] == vcp_code
+318            }
+319            if False in checks.values():
+320                self.logger.error('i2c read check failed: ' + repr(checks))
+321                raise I2CValidationError(
+322                    'i2c read check failed: ' + repr(checks))
+323
+324            # current and max values
+325            return int.from_bytes(ba[6:8], 'big'), int.from_bytes(ba[4:6], 'big')
+
+ + +

Retrieves a VCP value from the DDC device.

+ +
Arguments:
+ +
    +
  • vcp_code: the VCP value to read, eg: 0x10 is brightness
    • +
+ +
Returns:
+ +
+

The current and maximum value respectively

+
+ +
Raises:
+ +
    +
  • ValueError: if the read data is deemed invalid
    • +
+
+ + +
+
+
Inherited Members
+
+
I2C.I2CDevice
+
device
+ +
+
+
+
+
+ +
+ + class + Light(screen_brightness_control.helpers.BrightnessMethod): + + + +
+ + 
437class Light(BrightnessMethod):
+438    '''
+439    Wraps around [light](https://github.com/haikarainen/light), an external
+440    3rd party tool that can control brightness levels for e-DP displays.
+441
+442    .. warning::
+443       As of April 2nd 2023, the official repository for the light project has
+444       [been archived](https://github.com/haikarainen/light/issues/147) and
+445       will no longer receive any updates unless another maintainer picks it
+446       up.
+447    '''
+448
+449    executable: str = 'light'
+450    '''the light executable to be called'''
+451
+452    @classmethod
+453    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+454        '''
+455        Implements `BrightnessMethod.get_display_info`.
+456
+457        Works by taking the output of `SysFiles.get_display_info` and
+458        filtering out any displays that aren't supported by Light
+459        '''
+460        light_output = check_output([cls.executable, '-L']).decode()
+461        displays = []
+462        index = 0
+463        for device in SysFiles.get_display_info():
+464            # SysFiles scrapes info from the same place that Light used to
+465            # so it makes sense to use that output
+466            if device['path'].replace('/sys/class', 'sysfs') in light_output:
+467                del device['scale']
+468                device['light_path'] = device['path'].replace(
+469                    '/sys/class', 'sysfs')
+470                device['method'] = cls
+471                device['index'] = index
+472
+473                displays.append(device)
+474                index += 1
+475
+476        if display is not None:
+477            displays = filter_monitors(display=display, haystack=displays, include=[
+478                                       'path', 'light_path'])
+479        return displays
+480
+481    @classmethod
+482    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+483        info = cls.get_display_info()
+484        if display is not None:
+485            info = [info[display]]
+486
+487        for i in info:
+488            check_output(
+489                f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
+490
+491    @classmethod
+492    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+493        info = cls.get_display_info()
+494        if display is not None:
+495            info = [info[display]]
+496
+497        results = []
+498        for i in info:
+499            results.append(
+500                check_output([cls.executable, '-G', '-s', i['light_path']])
+501            )
+502        return [int(round(float(i.decode()), 0)) for i in results]
+
+ + +

Wraps around light, an external +3rd party tool that can control brightness levels for e-DP displays.

+ +
+ +

As of April 2nd 2023, the official repository for the light project has +been archived and +will no longer receive any updates unless another maintainer picks it +up.

+ +
+
+ + +
+
+ executable: str = +'light' + + +
+ + +

the light executable to be called

+
+ + +
+
+ +
+
@classmethod
+ + def + get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]: + + + +
+ + 
452    @classmethod
+453    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+454        '''
+455        Implements `BrightnessMethod.get_display_info`.
+456
+457        Works by taking the output of `SysFiles.get_display_info` and
+458        filtering out any displays that aren't supported by Light
+459        '''
+460        light_output = check_output([cls.executable, '-L']).decode()
+461        displays = []
+462        index = 0
+463        for device in SysFiles.get_display_info():
+464            # SysFiles scrapes info from the same place that Light used to
+465            # so it makes sense to use that output
+466            if device['path'].replace('/sys/class', 'sysfs') in light_output:
+467                del device['scale']
+468                device['light_path'] = device['path'].replace(
+469                    '/sys/class', 'sysfs')
+470                device['method'] = cls
+471                device['index'] = index
+472
+473                displays.append(device)
+474                index += 1
+475
+476        if display is not None:
+477            displays = filter_monitors(display=display, haystack=displays, include=[
+478                                       'path', 'light_path'])
+479        return displays
+
+ + +

Implements BrightnessMethod.get_display_info.

+ +

Works by taking the output of SysFiles.get_display_info and +filtering out any displays that aren't supported by Light

+
+ + +
+
+ +
+
@classmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None): + + + +
+ + 
481    @classmethod
+482    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+483        info = cls.get_display_info()
+484        if display is not None:
+485            info = [info[display]]
+486
+487        for i in info:
+488            check_output(
+489                f'{cls.executable} -S {value} -s {i["light_path"]}'.split(" "))
+
+ + +
Arguments:
+ + +
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
491    @classmethod
+492    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+493        info = cls.get_display_info()
+494        if display is not None:
+495            info = [info[display]]
+496
+497        results = []
+498        for i in info:
+499            results.append(
+500                check_output([cls.executable, '-G', '-s', i['light_path']])
+501            )
+502        return [int(round(float(i.decode()), 0)) for i in results]
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
+ +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, one for each + queried display

+
+
+ + +
+
+
+ +
+ + class + XRandr(screen_brightness_control.helpers.BrightnessMethodAdv): + + + +
+ + 
505class XRandr(BrightnessMethodAdv):
+506    '''collection of screen brightness related methods using the xrandr executable'''
+507
+508    executable: str = 'xrandr'
+509    '''the xrandr executable to be called'''
+510
+511    @classmethod
+512    def _gdi(cls):
+513        '''
+514        .. warning:: Don't use this
+515           This function isn't final and I will probably make breaking changes to it.
+516           You have been warned
+517
+518        Gets all displays reported by XRandr even if they're not supported
+519        '''
+520        xrandr_output = check_output(
+521            [cls.executable, '--verbose']).decode().split('\n')
+522
+523        display_count = 0
+524        tmp_display: dict = {}
+525
+526        for line_index, line in enumerate(xrandr_output):
+527            if line == '':
+528                continue
+529
+530            if not line.startswith((' ', '\t')) and 'connected' in line and 'disconnected' not in line:
+531                if tmp_display:
+532                    yield tmp_display
+533
+534                tmp_display = {
+535                    'name': line.split(' ')[0],
+536                    'interface': line.split(' ')[0],
+537                    'method': cls,
+538                    'index': display_count,
+539                    'model': None,
+540                    'serial': None,
+541                    'manufacturer': None,
+542                    'manufacturer_id': None,
+543                    'edid': None,
+544                    'unsupported': line.startswith('XWAYLAND')
+545                }
+546                display_count += 1
+547
+548            elif 'EDID:' in line:
+549                # extract the edid from the chunk of the output that will contain the edid
+550                edid = ''.join(
+551                    i.replace('\t', '').replace(' ', '') for i in xrandr_output[line_index + 1: line_index + 9]
+552                )
+553                tmp_display['edid'] = edid
+554
+555                for key, value in zip(
+556                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+557                    EDID.parse(tmp_display['edid'])
+558                ):
+559                    if value is None:
+560                        continue
+561                    tmp_display[key] = value
+562
+563            elif 'Brightness:' in line:
+564                tmp_display['brightness'] = int(
+565                    float(line.replace('Brightness:', '')) * 100)
+566
+567        if tmp_display:
+568            yield tmp_display
+569
+570    @classmethod
+571    def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+572        '''
+573        Implements `BrightnessMethod.get_display_info`.
+574
+575        Args:
+576            display: the index of the specific display to query.
+577                If unspecified, all detected displays are queried
+578            brightness: whether to include the current brightness
+579                in the returned info
+580        '''
+581        valid_displays = []
+582        for item in cls._gdi():
+583            if item['unsupported']:
+584                continue
+585            if not brightness:
+586                del item['brightness']
+587            del item['unsupported']
+588            valid_displays.append(item)
+589        if display is not None:
+590            valid_displays = filter_monitors(
+591                display=display, haystack=valid_displays, include=['interface'])
+592        return valid_displays
+593
+594    @classmethod
+595    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+596        monitors = cls.get_display_info(brightness=True)
+597        if display is not None:
+598            monitors = [monitors[display]]
+599        brightness = [i['brightness'] for i in monitors]
+600
+601        return brightness
+602
+603    @classmethod
+604    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+605        value_as_str = str(float(value) / 100)
+606        info = cls.get_display_info()
+607        if display is not None:
+608            info = [info[display]]
+609
+610        for i in info:
+611            check_output([cls.executable, '--output',
+612                         i['interface'], '--brightness', value_as_str])
+
+ + +

collection of screen brightness related methods using the xrandr executable

+
+ + +
+
+ executable: str = +'xrandr' + + +
+ + +

the xrandr executable to be called

+
+ + +
+
+ +
+
@classmethod
+ + def + get_display_info( cls, display: Union[str, int, NoneType] = None, brightness: bool = False) -> List[dict]: + + + +
+ + 
570    @classmethod
+571    def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+572        '''
+573        Implements `BrightnessMethod.get_display_info`.
+574
+575        Args:
+576            display: the index of the specific display to query.
+577                If unspecified, all detected displays are queried
+578            brightness: whether to include the current brightness
+579                in the returned info
+580        '''
+581        valid_displays = []
+582        for item in cls._gdi():
+583            if item['unsupported']:
+584                continue
+585            if not brightness:
+586                del item['brightness']
+587            del item['unsupported']
+588            valid_displays.append(item)
+589        if display is not None:
+590            valid_displays = filter_monitors(
+591                display=display, haystack=valid_displays, include=['interface'])
+592        return valid_displays
+
+ + +

Implements BrightnessMethod.get_display_info.

+ +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
  • brightness: whether to include the current brightness +in the returned info
    • +
+
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
594    @classmethod
+595    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+596        monitors = cls.get_display_info(brightness=True)
+597        if display is not None:
+598            monitors = [monitors[display]]
+599        brightness = [i['brightness'] for i in monitors]
+600
+601        return brightness
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
+ +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, one for each + queried display

+
+
+ + +
+
+ +
+
@classmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None): + + + +
+ + 
603    @classmethod
+604    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+605        value_as_str = str(float(value) / 100)
+606        info = cls.get_display_info()
+607        if display is not None:
+608            info = [info[display]]
+609
+610        for i in info:
+611            check_output([cls.executable, '--output',
+612                         i['interface'], '--brightness', value_as_str])
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + class + DDCUtil(screen_brightness_control.helpers.BrightnessMethodAdv): + + + +
+ + 
615class DDCUtil(BrightnessMethodAdv):
+616    '''collection of screen brightness related methods using the ddcutil executable'''
+617    _logger = _logger.getChild('DDCUtil')
+618
+619    executable: str = 'ddcutil'
+620    '''The ddcutil executable to be called'''
+621    sleep_multiplier: float = 0.5
+622    '''
+623    How long ddcutil should sleep between each DDC request (lower is shorter).
+624    See [the ddcutil docs](https://www.ddcutil.com/performance_options/#option-sleep-multiplier).
+625    '''
+626    cmd_max_tries: int = 10
+627    '''Max number of retries when calling the ddcutil'''
+628    enable_async = True
+629    '''
+630    Use the `--async` flag when calling ddcutil.
+631    See [ddcutil docs](https://www.ddcutil.com/performance_options/#option-async)
+632    '''
+633    _max_brightness_cache: dict = {}
+634    '''Cache for displays and their maximum brightness values'''
+635
+636    @classmethod
+637    def _gdi(cls):
+638        '''
+639        .. warning:: Don't use this
+640           This function isn't final and I will probably make breaking changes to it.
+641           You have been warned
+642
+643        Gets all displays reported by DDCUtil even if they're not supported
+644        '''
+645        raw_ddcutil_output = str(
+646            check_output(
+647                [
+648                    cls.executable, 'detect', '-v',
+649                    f'--sleep-multiplier={cls.sleep_multiplier}'
+650                ] + ['--async'] if cls.enable_async else [], max_tries=cls.cmd_max_tries
+651            )
+652        )[2:-1].split('\\n')
+653        # Use -v to get EDID string but this means output cannot be decoded.
+654        # Or maybe it can. I don't know the encoding though, so let's assume it cannot be decoded.
+655        # Use str()[2:-1] workaround
+656
+657        # include "Invalid display" sections because they tell us where one displays metadata ends
+658        # and another begins. We filter out invalid displays later on
+659        ddcutil_output = [i for i in raw_ddcutil_output if i.startswith(
+660            ('Invalid display', 'Display', '\t', ' '))]
+661        tmp_display: dict = {}
+662        display_count = 0
+663
+664        for line_index, line in enumerate(ddcutil_output):
+665            if not line.startswith(('\t', ' ')):
+666                if tmp_display:
+667                    yield tmp_display
+668
+669                tmp_display = {
+670                    'method': cls,
+671                    'index': display_count,
+672                    'model': None,
+673                    'serial': None,
+674                    'bin_serial': None,
+675                    'manufacturer': None,
+676                    'manufacturer_id': None,
+677                    'edid': None,
+678                    'unsupported': 'invalid display' in line.lower()
+679                }
+680                display_count += 1
+681
+682            elif 'I2C bus' in line:
+683                tmp_display['i2c_bus'] = line[line.index('/'):]
+684                tmp_display['bus_number'] = int(
+685                    tmp_display['i2c_bus'].replace('/dev/i2c-', ''))
+686
+687            elif 'Mfg id' in line:
+688                # Recently ddcutil has started reporting manufacturer IDs like
+689                # 'BNQ - UNK' or 'MSI - Microstep' so we have to split the line
+690                # into chunks of alpha chars and check for a valid mfg id
+691                for code in re.split(r'[^A-Za-z]', line.replace('Mfg id:', '').replace(' ', '')):
+692                    if len(code) != 3:
+693                        # all mfg ids are 3 chars long
+694                        continue
+695
+696                    if (brand := _monitor_brand_lookup(code)):
+697                        tmp_display['manufacturer_id'], tmp_display['manufacturer'] = brand
+698                        break
+699
+700            elif 'Model' in line:
+701                # the split() removes extra spaces
+702                name = line.replace('Model:', '').split()
+703                try:
+704                    tmp_display['model'] = name[1]
+705                except IndexError:
+706                    pass
+707                tmp_display['name'] = ' '.join(name)
+708
+709            elif 'Serial number' in line:
+710                tmp_display['serial'] = line.replace(
+711                    'Serial number:', '').replace(' ', '') or None
+712
+713            elif 'Binary serial number:' in line:
+714                tmp_display['bin_serial'] = line.split(' ')[-1][3:-1]
+715
+716            elif 'EDID hex dump:' in line:
+717                try:
+718                    tmp_display['edid'] = ''.join(
+719                        ''.join(i.split()[1:17]) for i in ddcutil_output[line_index + 2: line_index + 10]
+720                    )
+721                except Exception:
+722                    pass
+723
+724        if tmp_display:
+725            yield tmp_display
+726
+727    @classmethod
+728    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+729        valid_displays = __cache__.get('ddcutil_monitors_info')
+730        if valid_displays is None:
+731            valid_displays = []
+732            for item in cls._gdi():
+733                if item['unsupported']:
+734                    continue
+735                del item['unsupported']
+736                valid_displays.append(item)
+737
+738            if valid_displays:
+739                __cache__.store('ddcutil_monitors_info', valid_displays)
+740
+741        if display is not None:
+742            valid_displays = filter_monitors(
+743                display=display, haystack=valid_displays, include=['i2c_bus'])
+744        return valid_displays
+745
+746    @classmethod
+747    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+748        monitors = cls.get_display_info()
+749        if display is not None:
+750            monitors = [monitors[display]]
+751
+752        res = []
+753        for monitor in monitors:
+754            value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+755            if value is None:
+756                cmd_out = check_output(
+757                    [
+758                        cls.executable,
+759                        'getvcp', '10', '-t',
+760                        '-b', str(monitor['bus_number']),
+761                        f'--sleep-multiplier={cls.sleep_multiplier}'
+762                    ], max_tries=cls.cmd_max_tries
+763                ).decode().split(' ')
+764
+765                value = int(cmd_out[-2])
+766                max_value = int(cmd_out[-1])
+767                if max_value != 100:
+768                    # if the max brightness is not 100 then the number is not a percentage
+769                    # and will need to be scaled
+770                    value = int((value / max_value) * 100)
+771
+772                # now make sure max brightness is recorded so set_brightness can use it
+773                cache_ident = '%s-%s-%s' % (monitor['name'],
+774                                            monitor['serial'], monitor['bin_serial'])
+775                if cache_ident not in cls._max_brightness_cache:
+776                    cls._max_brightness_cache[cache_ident] = max_value
+777                    cls._logger.debug(
+778                        f'{cache_ident} max brightness:{max_value} (current: {value})')
+779
+780                __cache__.store(
+781                    f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+782            res.append(value)
+783        return res
+784
+785    @classmethod
+786    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+787        monitors = cls.get_display_info()
+788        if display is not None:
+789            monitors = [monitors[display]]
+790
+791        __cache__.expire(startswith='ddcutil_brightness_')
+792        for monitor in monitors:
+793            # check if monitor has a max brightness that requires us to scale this value
+794            cache_ident = '%s-%s-%s' % (monitor['name'],
+795                                        monitor['serial'], monitor['bin_serial'])
+796            if cache_ident not in cls._max_brightness_cache:
+797                cls.get_brightness(display=monitor['index'])
+798
+799            if cls._max_brightness_cache[cache_ident] != 100:
+800                value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+801
+802            check_output(
+803                [
+804                    cls.executable, 'setvcp', '10', str(value),
+805                    '-b', str(monitor['bus_number']),
+806                    f'--sleep-multiplier={cls.sleep_multiplier}'
+807                ], max_tries=cls.cmd_max_tries
+808            )
+
+ + +

collection of screen brightness related methods using the ddcutil executable

+
+ + +
+
+ executable: str = +'ddcutil' + + +
+ + +

The ddcutil executable to be called

+
+ + +
+
+
+ sleep_multiplier: float = +0.5 + + +
+ + +

How long ddcutil should sleep between each DDC request (lower is shorter). +See the ddcutil docs.

+
+ + +
+
+
+ cmd_max_tries: int = +10 + + +
+ + +

Max number of retries when calling the ddcutil

+
+ + +
+
+
+ enable_async = +True + + +
+ + +

Use the --async flag when calling ddcutil. +See ddcutil docs

+
+ + +
+
+ +
+
@classmethod
+ + def + get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]: + + + +
+ + 
727    @classmethod
+728    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+729        valid_displays = __cache__.get('ddcutil_monitors_info')
+730        if valid_displays is None:
+731            valid_displays = []
+732            for item in cls._gdi():
+733                if item['unsupported']:
+734                    continue
+735                del item['unsupported']
+736                valid_displays.append(item)
+737
+738            if valid_displays:
+739                __cache__.store('ddcutil_monitors_info', valid_displays)
+740
+741        if display is not None:
+742            valid_displays = filter_monitors(
+743                display=display, haystack=valid_displays, include=['i2c_bus'])
+744        return valid_displays
+
+ + +

Return information about detected displays.

+ +
Arguments:
+ + + +
Returns:
+ +
+

A list of dictionaries, each representing a detected display. + Each returned dictionary will have the following keys:

+ +
    +
  • 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)
    • +
  • 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
    • +
  • index (int): the index of the display, relative to the brightness method
    • +
+
+
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
746    @classmethod
+747    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+748        monitors = cls.get_display_info()
+749        if display is not None:
+750            monitors = [monitors[display]]
+751
+752        res = []
+753        for monitor in monitors:
+754            value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+755            if value is None:
+756                cmd_out = check_output(
+757                    [
+758                        cls.executable,
+759                        'getvcp', '10', '-t',
+760                        '-b', str(monitor['bus_number']),
+761                        f'--sleep-multiplier={cls.sleep_multiplier}'
+762                    ], max_tries=cls.cmd_max_tries
+763                ).decode().split(' ')
+764
+765                value = int(cmd_out[-2])
+766                max_value = int(cmd_out[-1])
+767                if max_value != 100:
+768                    # if the max brightness is not 100 then the number is not a percentage
+769                    # and will need to be scaled
+770                    value = int((value / max_value) * 100)
+771
+772                # now make sure max brightness is recorded so set_brightness can use it
+773                cache_ident = '%s-%s-%s' % (monitor['name'],
+774                                            monitor['serial'], monitor['bin_serial'])
+775                if cache_ident not in cls._max_brightness_cache:
+776                    cls._max_brightness_cache[cache_ident] = max_value
+777                    cls._logger.debug(
+778                        f'{cache_ident} max brightness:{max_value} (current: {value})')
+779
+780                __cache__.store(
+781                    f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+782            res.append(value)
+783        return res
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
+ +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, one for each + queried display

+
+
+ + +
+
+ +
+
@classmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None): + + + +
+ + 
785    @classmethod
+786    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+787        monitors = cls.get_display_info()
+788        if display is not None:
+789            monitors = [monitors[display]]
+790
+791        __cache__.expire(startswith='ddcutil_brightness_')
+792        for monitor in monitors:
+793            # check if monitor has a max brightness that requires us to scale this value
+794            cache_ident = '%s-%s-%s' % (monitor['name'],
+795                                        monitor['serial'], monitor['bin_serial'])
+796            if cache_ident not in cls._max_brightness_cache:
+797                cls.get_brightness(display=monitor['index'])
+798
+799            if cls._max_brightness_cache[cache_ident] != 100:
+800                value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+801
+802            check_output(
+803                [
+804                    cls.executable, 'setvcp', '10', str(value),
+805                    '-b', str(monitor['bus_number']),
+806                    f'--sleep-multiplier={cls.sleep_multiplier}'
+807                ], max_tries=cls.cmd_max_tries
+808            )
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + def + list_monitors_info( method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False) -> List[dict]: + + + +
+ + 
811def list_monitors_info(
+812    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+813) -> List[dict]:
+814    '''
+815    Lists detailed information about all detected displays
+816
+817    Args:
+818        method: the method the display can be addressed by. See `.get_methods`
+819            for more info on available methods
+820        allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+821        unsupported: include detected displays that are invalid or unsupported
+822    '''
+823    all_methods = get_methods(method).values()
+824    haystack = []
+825    for method_class in all_methods:
+826        try:
+827            if unsupported and issubclass(method_class, BrightnessMethodAdv):
+828                haystack += method_class._gdi()
+829            else:
+830                haystack += method_class.get_display_info()
+831        except Exception as e:
+832            _logger.warning(
+833                f'error grabbing display info from {method_class} - {format_exc(e)}')
+834            pass
+835
+836    if allow_duplicates:
+837        return haystack
+838
+839    try:
+840        # use filter_monitors to remove duplicates
+841        return filter_monitors(haystack=haystack)
+842    except NoValidDisplayError:
+843        return []
+
+ + +

Lists detailed information about all detected displays

+ +
Arguments:
+ +
    +
  • method: the method the display can be addressed by. See screen_brightness_control.get_methods +for more info on available methods
    • +
  • allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
    • +
  • unsupported: include detected displays that are invalid or unsupported
    • +
+
+ + +
+
+
+ METHODS = + + (<class 'SysFiles'>, <class 'I2C'>, <class 'XRandr'>, <class 'DDCUtil'>, <class 'Light'>) + + +
+ + + + +
+
+ + \ No newline at end of file diff --git a/docs/0.22.2/screen_brightness_control/types.html b/docs/0.22.2/screen_brightness_control/types.html new file mode 100644 index 0000000..36cf449 --- /dev/null +++ b/docs/0.22.2/screen_brightness_control/types.html @@ -0,0 +1,415 @@ + + + + + + + screen_brightness_control.types API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control.types

+ +

Submodule containing types and type aliases used throughout the library.

+ +

Splitting these definitions into a seperate submodule allows for detailed +explanations and verbose type definitions, without cluttering up the rest +of the library.

+ +

This file is also useful for wrangling types based on the current Python +version.

+
+ + + + + + 
 1'''
+ 2Submodule containing types and type aliases used throughout the library.
+ 3
+ 4Splitting these definitions into a seperate submodule allows for detailed
+ 5explanations and verbose type definitions, without cluttering up the rest
+ 6of the library.
+ 7
+ 8This file is also useful for wrangling types based on the current Python
+ 9version.
+10'''
+11from typing import Union
+12import sys
+13
+14# a bunch of typing classes were deprecated in Python 3.9
+15# in favour of collections.abc (https://www.python.org/dev/peps/pep-0585/)
+16if sys.version_info[1] >= 9:
+17    from collections.abc import Generator
+18else:
+19    from typing import Generator  # noqa: F401
+20
+21IntPercentage = int
+22'''
+23An integer between 0 and 100 (inclusive) that represents a brightness level.
+24Other than the implied bounds, this is just a normal integer.
+25'''
+26Percentage = Union[IntPercentage, str]
+27'''
+28An `IntPercentage` or a string representing an `IntPercentage`.
+29
+30String values may come in two forms:
+31- Absolute values: for example `'40'` converts directly to `int('40')`
+32- Relative values: strings prefixed with `+`/`-` will be interpreted relative to the
+33    current brightness level. In this case, the integer value of your string will be added to the
+34    current brightness level.
+35    For example, if the current brightness is 50%, a value of `'+40'` would imply 90% brightness
+36    and a value of `'-40'` would imply 10% brightness.
+37
+38Relative brightness values will usually be resolved by the `.helpers.percentage` function.
+39'''
+40
+41
+42DisplayIdentifier = Union[int, str]
+43'''
+44Something that can be used to identify a particular display.
+45Can be any one of the following properties of a display:
+46- edid (str)
+47- serial (str)
+48- name (str)
+49- index (int)
+50
+51See `Display` for descriptions of each property and its type
+52'''
+
+ + +
+ +
+
+
+ IntPercentage = +<class 'int'> + + +
+ + +

An integer between 0 and 100 (inclusive) that represents a brightness level. +Other than the implied bounds, this is just a normal integer.

+
+ + +
+
+
+ Percentage = +typing.Union[int, str] + + +
+ + +

An IntPercentage or a string representing an IntPercentage.

+ +

String values may come in two forms:

+ +
    +
  • Absolute values: for example '40' converts directly to int('40')
    • +
  • Relative values: strings prefixed with +/- will be interpreted relative to the +current brightness level. In this case, the integer value of your string will be added to the +current brightness level. +For example, if the current brightness is 50%, a value of '+40' would imply 90% brightness +and a value of '-40' would imply 10% brightness.
    • +
+ +

Relative brightness values will usually be resolved by the screen_brightness_control.helpers.percentage function.

+
+ + +
+
+
+ DisplayIdentifier = +typing.Union[int, str] + + +
+ + +

Something that can be used to identify a particular display. +Can be any one of the following properties of a display:

+ +
    +
  • edid (str)
    • +
  • serial (str)
    • +
  • name (str)
    • +
  • index (int)
    • +
+ +

See Display for descriptions of each property and its type

+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/0.22.2/screen_brightness_control/windows.html b/docs/0.22.2/screen_brightness_control/windows.html new file mode 100644 index 0000000..8fc2c35 --- /dev/null +++ b/docs/0.22.2/screen_brightness_control/windows.html @@ -0,0 +1,1601 @@ + + + + + + + screen_brightness_control.windows API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control.windows

+ + + + + + + 
  1import logging
+  2import threading
+  3import time
+  4from ctypes import POINTER, WINFUNCTYPE, Structure, WinError, byref, windll
+  5from ctypes.wintypes import (BOOL, BYTE, DWORD, HANDLE, HDC, HMONITOR, LPARAM,
+  6                             RECT, WCHAR)
+  7from typing import List, Optional
+  8
+  9import pythoncom
+ 10import pywintypes
+ 11import win32api
+ 12import win32con
+ 13import wmi
+ 14
+ 15from . import filter_monitors, get_methods
+ 16from .exceptions import EDIDParseError, NoValidDisplayError, format_exc
+ 17from .helpers import EDID, BrightnessMethod, __Cache, _monitor_brand_lookup
+ 18from .types import DisplayIdentifier, Generator, IntPercentage
+ 19
+ 20__cache__ = __Cache()
+ 21_logger = logging.getLogger(__name__)
+ 22
+ 23
+ 24def _wmi_init():
+ 25    '''internal function to create and return a wmi instance'''
+ 26    # WMI calls don't work in new threads so we have to run this check
+ 27    if threading.current_thread() != threading.main_thread():
+ 28        pythoncom.CoInitialize()
+ 29    return wmi.WMI(namespace='wmi')
+ 30
+ 31
+ 32def enum_display_devices() -> Generator[win32api.PyDISPLAY_DEVICEType, None, None]:
+ 33    '''
+ 34    Yields all display devices connected to the computer
+ 35    '''
+ 36    for monitor_enum in win32api.EnumDisplayMonitors():
+ 37        pyhandle = monitor_enum[0]
+ 38        monitor_info = win32api.GetMonitorInfo(pyhandle)
+ 39        for adaptor_index in range(5):
+ 40            try:
+ 41                # EDD_GET_DEVICE_INTERFACE_NAME flag to populate DeviceID field
+ 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
+ 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            try:
+ 93                pydevice = monitor_uids[instance_name]
+ 94            except KeyError:
+ 95                # if laptop display WAS connected but was later put to sleep (#33)
+ 96                if instance_name in laptop_displays:
+ 97                    laptop += 1
+ 98                else:
+ 99                    desktop += 1
+100                _logger.warning(
+101                    f'display {instance_name!r} is detected but not present in monitor_uids.'
+102                    ' Maybe it is asleep?'
+103                )
+104                continue
+105
+106            # get the EDID
+107            try:
+108                edid = ''.join(
+109                    f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
+110                # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
+111                # takes too long
+112                parsed = EDID.parse(edid)
+113                man_id, manufacturer, model, name, serial = parsed
+114                if name is None:
+115                    raise EDIDParseError(
+116                        'parsed EDID returned invalid display name')
+117            except EDIDParseError as e:
+118                edid = None
+119                _logger.warning(
+120                    f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
+121            except Exception as e:
+122                edid = None
+123                _logger.error(
+124                    f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
+125            finally:
+126                if edid is None:
+127                    devid = pydevice.DeviceID.split('#')
+128                    serial = devid[2]
+129                    man_id = devid[1][:3]
+130                    model = devid[1][3:] or 'Generic Monitor'
+131                    del devid
+132                    if (brand := _monitor_brand_lookup(man_id)):
+133                        man_id, manufacturer = brand
+134
+135            if (serial, model) != (None, None):
+136                data: dict = {
+137                    'name': f'{manufacturer} {model}',
+138                    'model': model,
+139                    'serial': serial,
+140                    'manufacturer': manufacturer,
+141                    'manufacturer_id': man_id,
+142                    'edid': edid
+143                }
+144                if monitor.InstanceName in laptop_displays:
+145                    data['index'] = laptop
+146                    data['method'] = WMI
+147                    laptop += 1
+148                else:
+149                    data['method'] = VCP
+150                    desktop += 1
+151
+152                if instance_name in uid_keys:
+153                    # insert the data into the uid_keys list because
+154                    # uid_keys has the monitors sorted correctly. This
+155                    # means we don't have to re-sort the list later
+156                    uid_keys[uid_keys.index(instance_name)] = data
+157                else:
+158                    extras.append(data)
+159
+160        info = uid_keys + extras
+161        if desktop:
+162            # now make sure desktop monitors have the correct index
+163            count = 0
+164            for item in info:
+165                if item['method'] == VCP:
+166                    item['index'] = count
+167                    count += 1
+168
+169        # return info only which has correct data
+170        info = [i for i in info if isinstance(i, dict)]
+171
+172        __cache__.store('windows_monitors_info_raw', info)
+173
+174    return info
+175
+176
+177class WMI(BrightnessMethod):
+178    '''
+179    A collection of screen brightness related methods using the WMI API.
+180    This class primarily works with laptop displays.
+181    '''
+182    @classmethod
+183    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+184        info = [i for i in get_display_info() if i['method'] == cls]
+185        if display is not None:
+186            info = filter_monitors(display=display, haystack=info)
+187        return info
+188
+189    @classmethod
+190    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+191        brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
+192        if display is not None:
+193            brightness_method = [brightness_method[display]]
+194
+195        for method in brightness_method:
+196            method.WmiSetBrightness(value, 0)
+197
+198    @classmethod
+199    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+200        brightness_method = _wmi_init().WmiMonitorBrightness()
+201        if display is not None:
+202            brightness_method = [brightness_method[display]]
+203
+204        values = [i.CurrentBrightness for i in brightness_method]
+205        return values
+206
+207
+208class VCP(BrightnessMethod):
+209    '''Collection of screen brightness related methods using the DDC/CI commands'''
+210    _MONITORENUMPROC = WINFUNCTYPE(BOOL, HMONITOR, HDC, POINTER(RECT), LPARAM)
+211
+212    _logger = _logger.getChild('VCP')
+213
+214    class _PHYSICAL_MONITOR(Structure):
+215        '''internal class, do not call'''
+216        _fields_ = [('handle', HANDLE),
+217                    ('description', WCHAR * 128)]
+218
+219    @classmethod
+220    def iter_physical_monitors(cls, start: int = 0) -> Generator[HANDLE, None, None]:
+221        '''
+222        A generator to iterate through all physical monitors
+223        and then close them again afterwards, yielding their handles.
+224        It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+225
+226        Args:
+227            start: skip the first X handles
+228
+229        Raises:
+230            ctypes.WinError: upon failure to enumerate through the monitors
+231        '''
+232        def callback(hmonitor, *_):
+233            monitors.append(HMONITOR(hmonitor))
+234            return True
+235
+236        monitors: List[HMONITOR] = []
+237        if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
+238            cls._logger.error('EnumDisplayMonitors failed')
+239            raise WinError(None, 'EnumDisplayMonitors failed')
+240
+241        # user index keeps track of valid monitors
+242        user_index = 0
+243        # monitor index keeps track of valid and pseudo monitors
+244        monitor_index = 0
+245        display_devices = list(enum_display_devices())
+246
+247        wmi = _wmi_init()
+248        try:
+249            laptop_displays = [
+250                i.InstanceName.replace('_0', '').split('\\')[2]
+251                for i in wmi.WmiMonitorBrightness()
+252            ]
+253        except Exception as e:
+254            cls._logger.warning(
+255                f'failed to gather list of laptop displays - {format_exc(e)}')
+256            laptop_displays = []
+257
+258        for monitor in monitors:
+259            # Get physical monitor count
+260            count = DWORD()
+261            if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+262                raise WinError(None, 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+263            if count.value > 0:
+264                # Get physical monitor handles
+265                physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+266                if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+267                    raise WinError(None, 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+268                for item in physical_array:
+269                    # check that the monitor is not a pseudo monitor by
+270                    # checking its StateFlags for the
+271                    # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+272                    if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+273                        # check if monitor is actually a laptop display
+274                        if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+275                            if start is None or user_index >= start:
+276                                yield item.handle
+277                            # increment user index as a valid monitor was found
+278                            user_index += 1
+279                    # increment monitor index
+280                    monitor_index += 1
+281                    windll.dxva2.DestroyPhysicalMonitor(item.handle)
+282
+283    @classmethod
+284    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+285        info = [i for i in get_display_info() if i['method'] == cls]
+286        if display is not None:
+287            info = filter_monitors(display=display, haystack=info)
+288        return info
+289
+290    @classmethod
+291    def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+292        '''
+293        Args:
+294            display: the index of the specific display to query.
+295                If unspecified, all detected displays are queried
+296            max_tries: the maximum allowed number of attempts to
+297                read the VCP output from the display
+298
+299        Returns:
+300            See `BrightnessMethod.get_brightness`
+301        '''
+302        code = BYTE(0x10)
+303        values = []
+304        start = display if display is not None else 0
+305        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+306            current = __cache__.get(f'vcp_brightness_{index}')
+307            if current is None:
+308                cur_out = DWORD()
+309                attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+310                for attempt in range(max_tries):
+311                    if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+312                        current = cur_out.value
+313                        break
+314                    current = None
+315                    time.sleep(0.02 if attempt < 20 else 0.1)
+316                else:
+317                    cls._logger.error(
+318                        f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+319
+320            if current is not None:
+321                __cache__.store(
+322                    f'vcp_brightness_{index}', current, expires=0.1)
+323                values.append(current)
+324
+325            if display == index:
+326                # if we've got the display we wanted then exit here, no point iterating through all the others.
+327                # Cleanup function usually called in iter_physical_monitors won't get called if we break, so call now
+328                windll.dxva2.DestroyPhysicalMonitor(handle)
+329                break
+330
+331        return values
+332
+333    @classmethod
+334    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+335        '''
+336        Args:
+337            value: percentage brightness to set the display to
+338            display: The specific display you wish to query.
+339            max_tries: the maximum allowed number of attempts to
+340                send the VCP input to the display
+341        '''
+342        __cache__.expire(startswith='vcp_brightness_')
+343        code = BYTE(0x10)
+344        value_dword = DWORD(value)
+345        start = display if display is not None else 0
+346        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+347            attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+348            for attempt in range(max_tries):
+349                if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+350                    break
+351                time.sleep(0.02 if attempt < 20 else 0.1)
+352            else:
+353                cls._logger.error(
+354                    f'failed to set display:{index}->{value} after {attempt} tries')
+355
+356            if display == index:
+357                # we have the display we wanted, exit and cleanup
+358                windll.dxva2.DestroyPhysicalMonitor(handle)
+359                break
+360
+361
+362def list_monitors_info(
+363    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+364) -> List[dict]:
+365    '''
+366    Lists detailed information about all detected displays
+367
+368    Args:
+369        method: the method the display can be addressed by. See `.get_methods`
+370            for more info on available methods
+371        allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+372        unsupported: include detected displays that are invalid or unsupported.
+373            This argument does nothing on Windows
+374    '''
+375    # no caching here because get_display_info caches its results
+376    info = get_display_info()
+377
+378    all_methods = get_methods(method).values()
+379
+380    if method is not None:
+381        info = [i for i in info if i['method'] in all_methods]
+382
+383    if allow_duplicates:
+384        return info
+385
+386    try:
+387        # use filter_monitors to remove duplicates
+388        return filter_monitors(haystack=info)
+389    except NoValidDisplayError:
+390        return []
+391
+392
+393METHODS = (WMI, VCP)
+
+ + +
+ +
+
+ +
+ + def + enum_display_devices() -> collections.abc.Generator[win32api.PyDISPLAY_DEVICEType, None, None]: + + + +
+ + 
33def enum_display_devices() -> Generator[win32api.PyDISPLAY_DEVICEType, None, None]:
+34    '''
+35    Yields all display devices connected to the computer
+36    '''
+37    for monitor_enum in win32api.EnumDisplayMonitors():
+38        pyhandle = monitor_enum[0]
+39        monitor_info = win32api.GetMonitorInfo(pyhandle)
+40        for adaptor_index in range(5):
+41            try:
+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
+
+ + +

Yields all display devices connected to the computer

+
+ + +
+
+ +
+ + def + get_display_info() -> List[dict]: + + + +
+ + 
 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            try:
+ 94                pydevice = monitor_uids[instance_name]
+ 95            except KeyError:
+ 96                # if laptop display WAS connected but was later put to sleep (#33)
+ 97                if instance_name in laptop_displays:
+ 98                    laptop += 1
+ 99                else:
+100                    desktop += 1
+101                _logger.warning(
+102                    f'display {instance_name!r} is detected but not present in monitor_uids.'
+103                    ' Maybe it is asleep?'
+104                )
+105                continue
+106
+107            # get the EDID
+108            try:
+109                edid = ''.join(
+110                    f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
+111                # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
+112                # takes too long
+113                parsed = EDID.parse(edid)
+114                man_id, manufacturer, model, name, serial = parsed
+115                if name is None:
+116                    raise EDIDParseError(
+117                        'parsed EDID returned invalid display name')
+118            except EDIDParseError as e:
+119                edid = None
+120                _logger.warning(
+121                    f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
+122            except Exception as e:
+123                edid = None
+124                _logger.error(
+125                    f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
+126            finally:
+127                if edid is None:
+128                    devid = pydevice.DeviceID.split('#')
+129                    serial = devid[2]
+130                    man_id = devid[1][:3]
+131                    model = devid[1][3:] or 'Generic Monitor'
+132                    del devid
+133                    if (brand := _monitor_brand_lookup(man_id)):
+134                        man_id, manufacturer = brand
+135
+136            if (serial, model) != (None, None):
+137                data: dict = {
+138                    'name': f'{manufacturer} {model}',
+139                    'model': model,
+140                    'serial': serial,
+141                    'manufacturer': manufacturer,
+142                    'manufacturer_id': man_id,
+143                    'edid': edid
+144                }
+145                if monitor.InstanceName in laptop_displays:
+146                    data['index'] = laptop
+147                    data['method'] = WMI
+148                    laptop += 1
+149                else:
+150                    data['method'] = VCP
+151                    desktop += 1
+152
+153                if instance_name in uid_keys:
+154                    # insert the data into the uid_keys list because
+155                    # uid_keys has the monitors sorted correctly. This
+156                    # means we don't have to re-sort the list later
+157                    uid_keys[uid_keys.index(instance_name)] = data
+158                else:
+159                    extras.append(data)
+160
+161        info = uid_keys + extras
+162        if desktop:
+163            # now make sure desktop monitors have the correct index
+164            count = 0
+165            for item in info:
+166                if item['method'] == VCP:
+167                    item['index'] = count
+168                    count += 1
+169
+170        # return info only which has correct data
+171        info = [i for i in info if isinstance(i, dict)]
+172
+173        __cache__.store('windows_monitors_info_raw', info)
+174
+175    return info
+
+ + +

Gets information about all connected displays using WMI and win32api

+ +
Example:
+ +
+
+
import screen_brightness_control as s
+
+info = s.windows.get_display_info()
+for display in info:
+    print(display['name'])
+
+
+
+
+ + +
+
+ +
+ + class + WMI(screen_brightness_control.helpers.BrightnessMethod): + + + +
+ + 
178class WMI(BrightnessMethod):
+179    '''
+180    A collection of screen brightness related methods using the WMI API.
+181    This class primarily works with laptop displays.
+182    '''
+183    @classmethod
+184    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+185        info = [i for i in get_display_info() if i['method'] == cls]
+186        if display is not None:
+187            info = filter_monitors(display=display, haystack=info)
+188        return info
+189
+190    @classmethod
+191    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+192        brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
+193        if display is not None:
+194            brightness_method = [brightness_method[display]]
+195
+196        for method in brightness_method:
+197            method.WmiSetBrightness(value, 0)
+198
+199    @classmethod
+200    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+201        brightness_method = _wmi_init().WmiMonitorBrightness()
+202        if display is not None:
+203            brightness_method = [brightness_method[display]]
+204
+205        values = [i.CurrentBrightness for i in brightness_method]
+206        return values
+
+ + +

A collection of screen brightness related methods using the WMI API. +This class primarily works with laptop displays.

+
+ + +
+ +
+
@classmethod
+ + def + get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]: + + + +
+ + 
183    @classmethod
+184    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+185        info = [i for i in get_display_info() if i['method'] == cls]
+186        if display is not None:
+187            info = filter_monitors(display=display, haystack=info)
+188        return info
+
+ + +

Return information about detected displays.

+ +
Arguments:
+ + + +
Returns:
+ +
+

A list of dictionaries, each representing a detected display. + Each returned dictionary will have the following keys:

+ +
    +
  • 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)
    • +
  • 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
    • +
  • index (int): the index of the display, relative to the brightness method
    • +
+
+
+ + +
+
+ +
+
@classmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None): + + + +
+ + 
190    @classmethod
+191    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+192        brightness_method = _wmi_init().WmiMonitorBrightnessMethods()
+193        if display is not None:
+194            brightness_method = [brightness_method[display]]
+195
+196        for method in brightness_method:
+197            method.WmiSetBrightness(value, 0)
+
+ + +
Arguments:
+ + +
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
199    @classmethod
+200    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+201        brightness_method = _wmi_init().WmiMonitorBrightness()
+202        if display is not None:
+203            brightness_method = [brightness_method[display]]
+204
+205        values = [i.CurrentBrightness for i in brightness_method]
+206        return values
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
+ +
Returns:
+ +
+

A list of screen_brightness_control.types.IntPercentage values, one for each + queried display

+
+
+ + +
+
+
+ +
+ + class + VCP(screen_brightness_control.helpers.BrightnessMethod): + + + +
+ + 
209class VCP(BrightnessMethod):
+210    '''Collection of screen brightness related methods using the DDC/CI commands'''
+211    _MONITORENUMPROC = WINFUNCTYPE(BOOL, HMONITOR, HDC, POINTER(RECT), LPARAM)
+212
+213    _logger = _logger.getChild('VCP')
+214
+215    class _PHYSICAL_MONITOR(Structure):
+216        '''internal class, do not call'''
+217        _fields_ = [('handle', HANDLE),
+218                    ('description', WCHAR * 128)]
+219
+220    @classmethod
+221    def iter_physical_monitors(cls, start: int = 0) -> Generator[HANDLE, None, None]:
+222        '''
+223        A generator to iterate through all physical monitors
+224        and then close them again afterwards, yielding their handles.
+225        It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+226
+227        Args:
+228            start: skip the first X handles
+229
+230        Raises:
+231            ctypes.WinError: upon failure to enumerate through the monitors
+232        '''
+233        def callback(hmonitor, *_):
+234            monitors.append(HMONITOR(hmonitor))
+235            return True
+236
+237        monitors: List[HMONITOR] = []
+238        if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
+239            cls._logger.error('EnumDisplayMonitors failed')
+240            raise WinError(None, 'EnumDisplayMonitors failed')
+241
+242        # user index keeps track of valid monitors
+243        user_index = 0
+244        # monitor index keeps track of valid and pseudo monitors
+245        monitor_index = 0
+246        display_devices = list(enum_display_devices())
+247
+248        wmi = _wmi_init()
+249        try:
+250            laptop_displays = [
+251                i.InstanceName.replace('_0', '').split('\\')[2]
+252                for i in wmi.WmiMonitorBrightness()
+253            ]
+254        except Exception as e:
+255            cls._logger.warning(
+256                f'failed to gather list of laptop displays - {format_exc(e)}')
+257            laptop_displays = []
+258
+259        for monitor in monitors:
+260            # Get physical monitor count
+261            count = DWORD()
+262            if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+263                raise WinError(None, 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+264            if count.value > 0:
+265                # Get physical monitor handles
+266                physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+267                if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+268                    raise WinError(None, 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+269                for item in physical_array:
+270                    # check that the monitor is not a pseudo monitor by
+271                    # checking its StateFlags for the
+272                    # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+273                    if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+274                        # check if monitor is actually a laptop display
+275                        if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+276                            if start is None or user_index >= start:
+277                                yield item.handle
+278                            # increment user index as a valid monitor was found
+279                            user_index += 1
+280                    # increment monitor index
+281                    monitor_index += 1
+282                    windll.dxva2.DestroyPhysicalMonitor(item.handle)
+283
+284    @classmethod
+285    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+286        info = [i for i in get_display_info() if i['method'] == cls]
+287        if display is not None:
+288            info = filter_monitors(display=display, haystack=info)
+289        return info
+290
+291    @classmethod
+292    def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+293        '''
+294        Args:
+295            display: the index of the specific display to query.
+296                If unspecified, all detected displays are queried
+297            max_tries: the maximum allowed number of attempts to
+298                read the VCP output from the display
+299
+300        Returns:
+301            See `BrightnessMethod.get_brightness`
+302        '''
+303        code = BYTE(0x10)
+304        values = []
+305        start = display if display is not None else 0
+306        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+307            current = __cache__.get(f'vcp_brightness_{index}')
+308            if current is None:
+309                cur_out = DWORD()
+310                attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+311                for attempt in range(max_tries):
+312                    if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+313                        current = cur_out.value
+314                        break
+315                    current = None
+316                    time.sleep(0.02 if attempt < 20 else 0.1)
+317                else:
+318                    cls._logger.error(
+319                        f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+320
+321            if current is not None:
+322                __cache__.store(
+323                    f'vcp_brightness_{index}', current, expires=0.1)
+324                values.append(current)
+325
+326            if display == index:
+327                # if we've got the display we wanted then exit here, no point iterating through all the others.
+328                # Cleanup function usually called in iter_physical_monitors won't get called if we break, so call now
+329                windll.dxva2.DestroyPhysicalMonitor(handle)
+330                break
+331
+332        return values
+333
+334    @classmethod
+335    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+336        '''
+337        Args:
+338            value: percentage brightness to set the display to
+339            display: The specific display you wish to query.
+340            max_tries: the maximum allowed number of attempts to
+341                send the VCP input to the display
+342        '''
+343        __cache__.expire(startswith='vcp_brightness_')
+344        code = BYTE(0x10)
+345        value_dword = DWORD(value)
+346        start = display if display is not None else 0
+347        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+348            attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+349            for attempt in range(max_tries):
+350                if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+351                    break
+352                time.sleep(0.02 if attempt < 20 else 0.1)
+353            else:
+354                cls._logger.error(
+355                    f'failed to set display:{index}->{value} after {attempt} tries')
+356
+357            if display == index:
+358                # we have the display we wanted, exit and cleanup
+359                windll.dxva2.DestroyPhysicalMonitor(handle)
+360                break
+
+ + +

Collection of screen brightness related methods using the DDC/CI commands

+
+ + +
+ +
+
@classmethod
+ + def + iter_physical_monitors( cls, start: int = 0) -> collections.abc.Generator[ctypes.wintypes.HANDLE, None, None]: + + + +
+ + 
220    @classmethod
+221    def iter_physical_monitors(cls, start: int = 0) -> Generator[HANDLE, None, None]:
+222        '''
+223        A generator to iterate through all physical monitors
+224        and then close them again afterwards, yielding their handles.
+225        It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+226
+227        Args:
+228            start: skip the first X handles
+229
+230        Raises:
+231            ctypes.WinError: upon failure to enumerate through the monitors
+232        '''
+233        def callback(hmonitor, *_):
+234            monitors.append(HMONITOR(hmonitor))
+235            return True
+236
+237        monitors: List[HMONITOR] = []
+238        if not windll.user32.EnumDisplayMonitors(None, None, cls._MONITORENUMPROC(callback), None):
+239            cls._logger.error('EnumDisplayMonitors failed')
+240            raise WinError(None, 'EnumDisplayMonitors failed')
+241
+242        # user index keeps track of valid monitors
+243        user_index = 0
+244        # monitor index keeps track of valid and pseudo monitors
+245        monitor_index = 0
+246        display_devices = list(enum_display_devices())
+247
+248        wmi = _wmi_init()
+249        try:
+250            laptop_displays = [
+251                i.InstanceName.replace('_0', '').split('\\')[2]
+252                for i in wmi.WmiMonitorBrightness()
+253            ]
+254        except Exception as e:
+255            cls._logger.warning(
+256                f'failed to gather list of laptop displays - {format_exc(e)}')
+257            laptop_displays = []
+258
+259        for monitor in monitors:
+260            # Get physical monitor count
+261            count = DWORD()
+262            if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+263                raise WinError(None, 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+264            if count.value > 0:
+265                # Get physical monitor handles
+266                physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+267                if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+268                    raise WinError(None, 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+269                for item in physical_array:
+270                    # check that the monitor is not a pseudo monitor by
+271                    # checking its StateFlags for the
+272                    # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+273                    if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+274                        # check if monitor is actually a laptop display
+275                        if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+276                            if start is None or user_index >= start:
+277                                yield item.handle
+278                            # increment user index as a valid monitor was found
+279                            user_index += 1
+280                    # increment monitor index
+281                    monitor_index += 1
+282                    windll.dxva2.DestroyPhysicalMonitor(item.handle)
+
+ + +

A generator to iterate through all physical monitors +and then close them again afterwards, yielding their handles. +It is not recommended to use this function unless you are familiar with ctypes and windll

+ +
Arguments:
+ +
    +
  • start: skip the first X handles
    • +
+ +
Raises:
+ +
    +
  • ctypes.WinError: upon failure to enumerate through the monitors
    • +
+
+ + +
+
+ +
+
@classmethod
+ + def + get_display_info(cls, display: Union[str, int, NoneType] = None) -> List[dict]: + + + +
+ + 
284    @classmethod
+285    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+286        info = [i for i in get_display_info() if i['method'] == cls]
+287        if display is not None:
+288            info = filter_monitors(display=display, haystack=info)
+289        return info
+
+ + +

Return information about detected displays.

+ +
Arguments:
+ + + +
Returns:
+ +
+

A list of dictionaries, each representing a detected display. + Each returned dictionary will have the following keys:

+ +
    +
  • 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)
    • +
  • 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
    • +
  • index (int): the index of the display, relative to the brightness method
    • +
+
+
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[int]: + + + +
+ + 
291    @classmethod
+292    def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+293        '''
+294        Args:
+295            display: the index of the specific display to query.
+296                If unspecified, all detected displays are queried
+297            max_tries: the maximum allowed number of attempts to
+298                read the VCP output from the display
+299
+300        Returns:
+301            See `BrightnessMethod.get_brightness`
+302        '''
+303        code = BYTE(0x10)
+304        values = []
+305        start = display if display is not None else 0
+306        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+307            current = __cache__.get(f'vcp_brightness_{index}')
+308            if current is None:
+309                cur_out = DWORD()
+310                attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+311                for attempt in range(max_tries):
+312                    if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+313                        current = cur_out.value
+314                        break
+315                    current = None
+316                    time.sleep(0.02 if attempt < 20 else 0.1)
+317                else:
+318                    cls._logger.error(
+319                        f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+320
+321            if current is not None:
+322                __cache__.store(
+323                    f'vcp_brightness_{index}', current, expires=0.1)
+324                values.append(current)
+325
+326            if display == index:
+327                # if we've got the display we wanted then exit here, no point iterating through all the others.
+328                # Cleanup function usually called in iter_physical_monitors won't get called if we break, so call now
+329                windll.dxva2.DestroyPhysicalMonitor(handle)
+330                break
+331
+332        return values
+
+ + +
Arguments:
+ +
    +
  • display: the index of the specific display to query. +If unspecified, all detected displays are queried
    • +
  • max_tries: the maximum allowed number of attempts to +read the VCP output from the display
    • +
+ +
Returns:
+ +
+

See BrightnessMethod.get_brightness

+
+
+ + +
+
+ +
+
@classmethod
+ + def + set_brightness(cls, value: int, display: Optional[int] = None, max_tries: int = 50): + + + +
+ + 
334    @classmethod
+335    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+336        '''
+337        Args:
+338            value: percentage brightness to set the display to
+339            display: The specific display you wish to query.
+340            max_tries: the maximum allowed number of attempts to
+341                send the VCP input to the display
+342        '''
+343        __cache__.expire(startswith='vcp_brightness_')
+344        code = BYTE(0x10)
+345        value_dword = DWORD(value)
+346        start = display if display is not None else 0
+347        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+348            attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+349            for attempt in range(max_tries):
+350                if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+351                    break
+352                time.sleep(0.02 if attempt < 20 else 0.1)
+353            else:
+354                cls._logger.error(
+355                    f'failed to set display:{index}->{value} after {attempt} tries')
+356
+357            if display == index:
+358                # we have the display we wanted, exit and cleanup
+359                windll.dxva2.DestroyPhysicalMonitor(handle)
+360                break
+
+ + +
Arguments:
+ +
    +
  • value: percentage brightness to set the display to
    • +
  • display: The specific display you wish to query.
    • +
  • max_tries: the maximum allowed number of attempts to +send the VCP input to the display
    • +
+
+ + +
+
+
+ +
+ + def + list_monitors_info( method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False) -> List[dict]: + + + +
+ + 
363def list_monitors_info(
+364    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+365) -> List[dict]:
+366    '''
+367    Lists detailed information about all detected displays
+368
+369    Args:
+370        method: the method the display can be addressed by. See `.get_methods`
+371            for more info on available methods
+372        allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+373        unsupported: include detected displays that are invalid or unsupported.
+374            This argument does nothing on Windows
+375    '''
+376    # no caching here because get_display_info caches its results
+377    info = get_display_info()
+378
+379    all_methods = get_methods(method).values()
+380
+381    if method is not None:
+382        info = [i for i in info if i['method'] in all_methods]
+383
+384    if allow_duplicates:
+385        return info
+386
+387    try:
+388        # use filter_monitors to remove duplicates
+389        return filter_monitors(haystack=info)
+390    except NoValidDisplayError:
+391        return []
+
+ + +

Lists detailed information about all detected displays

+ +
Arguments:
+ +
    +
  • method: the method the display can be addressed by. See screen_brightness_control.get_methods +for more info on available methods
    • +
  • allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
    • +
  • unsupported: include detected displays that are invalid or unsupported. +This argument does nothing on Windows
    • +
+
+ + +
+
+
+ METHODS = +(<class 'WMI'>, <class 'VCP'>) + + +
+ + + + +
+
+ + \ No newline at end of file diff --git a/docs/0.22.2/search.js b/docs/0.22.2/search.js new file mode 100644 index 0000000..920a232 --- /dev/null +++ b/docs/0.22.2/search.js @@ -0,0 +1,46 @@ +window.pdocSearch = (function(){ +/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();o

\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\n
Arguments:
\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\n
Returns:
\n\n
\n

A list of .types.IntPercentage values, each being the brightness of an\n individual display. Invalid displays may return None.

\n
\n\n
Example:
\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
\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\n
Arguments:
\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\n
Returns:
\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\n
Example:
\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
\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\n
Arguments:
\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\n
Returns:
\n\n
\n

By default, this function calls get_brightness() to return the new\n brightness of any adjusted displays.

\n \n

If blocking is set to False, then a list of threads are\n returned, one for each display being faded.

\n
\n\n
Example:
\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
\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\n
Arguments:
\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\n
Returns:
\n\n
\n

list: list of dictionaries containing information about the detected displays

\n
\n\n
Example:
\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
\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\n
Arguments:
\n\n
    \n
  • method: the method to use to list the available displays. See get_methods for\nmore info on available methods
    • \n
\n\n
Example:
\n\n
\n
\n
import screen_brightness_control as sbc\ndisplay_names = sbc.list_monitors()\n# eg: ['BenQ GL2450H', 'Dell U2211H']\n
\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\n
Arguments:
\n\n
    \n
  • name: if specified, return the method corresponding to this name
    • \n
\n\n
Raises:
\n\n
    \n
  • ValueError: if the given name is incorrect
    • \n
\n\n
Example:
\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
\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\n
Arguments:
\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\n
Returns:
\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
\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\n
Returns:
\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\n
Returns:
\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\n
Arguments:
\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
\n", "bases": "Display"}, "screen_brightness_control.Monitor.__init__": {"fullname": "screen_brightness_control.Monitor.__init__", "modulename": "screen_brightness_control", "qualname": "Monitor.__init__", "kind": "function", "doc": "
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\n
Example:
\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
\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\n
Arguments:
\n\n
    \n
  • monitor: extract an identifier from this dict instead of the monitor class
    • \n
\n\n
Returns:
\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\n
Example:
\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
\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\n
Arguments:
\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\n
Returns:
\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\n
Arguments:
\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\n
Arguments:
\n\n
    \n
  • refresh: whether to refresh the information\nor to return the cached version
    • \n
\n\n
Example:
\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
\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\n
Arguments:
\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\n
Raises:
\n\n
    \n
  • NoValidDisplayError: if the display does not have a match
    • \n
  • TypeError: if the display kwarg is not int or str
    • \n
\n\n
Example:
\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
\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\n
Example:
\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
\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 Picture 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\n
Arguments:
\n\n
    \n
  • display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to filter_monitors
    • \n
\n\n
Returns:
\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\n
Returns:
\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\n
Arguments:
\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\n
Returns:
\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\n
Raises:
\n\n
    \n
  • EDIDParseError: if the EDID info cannot be unpacked
    • \n
  • TypeError: if edid is not str or bytes
    • \n
\n\n
Example:
\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
\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\n
Arguments:
\n\n
    \n
  • file (str): the file to read
    • \n
\n\n
Returns:
\n\n
\n

str: one long hex string

\n
\n\n
Example:
\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
\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\n
Arguments:
\n\n
    \n
  • command: the command to run
    • \n
  • max_tries: the maximum number of retries to allow before raising an error
    • \n
\n\n
Returns:
\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\n

This is useful because it skips many of the higher percentages in the\nsequence where single percent brightness changes are hard to notice.

\n\n

This function is designed to deal with brightness percentages, and so\nwill never return a value less than 0 or greater than 100.

\n\n
Arguments:
\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\n
Yields:
\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\n
Arguments:
\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\n
Returns:
\n\n
\n

.types.IntPercentage: 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\n

This class works with displays that show up in the /sys/class/backlight\ndirectory (so usually laptop displays).

\n\n

To 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\n
Arguments:
\n\n
    \n
  • display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to filter_monitors
    • \n
\n\n
Returns:
\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\n
Returns:
\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\n

Usage of this class requires read and write permission for /dev/i2c-*.

\n\n

This class works over the I2C bus, primarily with desktop monitors as I\nhaven't tested any e-DP displays yet.

\n\n

Massive thanks to siemer for\nhis work on the ddcci.py project,\nwhich served as a my main reference for this.

\n\n
References:
\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\n
Arguments:
\n\n
    \n
  • length: the number of bytes to read
    • \n
\n\n
Returns:
\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\n
Arguments:
\n\n
    \n
  • data: the data to write
    • \n
\n\n
Returns:
\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\n

It is recommended to use setvcp to set VCP values on the DDC device\ninstead of using this function directly.

\n\n
Arguments:
\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\n
Returns:
\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\n
Arguments:
\n\n
    \n
  • vcp_code: the VCP command to send, eg: 0x10 is brightness
    • \n
  • value: what to set the value to
    • \n
\n\n
Returns:
\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\n

It is recommended to use getvcp to retrieve VCP values from the\nDDC device instead of using this function directly.

\n\n
Arguments:
\n\n
    \n
  • amount: the number of bytes to read
    • \n
\n\n
Raises:
\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\n
Arguments:
\n\n
    \n
  • vcp_code: the VCP value to read, eg: 0x10 is brightness
    • \n
\n\n
Returns:
\n\n
\n

The current and maximum value respectively

\n
\n\n
Raises:
\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\n
Arguments:
\n\n
    \n
  • display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to filter_monitors
    • \n
\n\n
Returns:
\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\n
Returns:
\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
\n", "bases": "screen_brightness_control.helpers.BrightnessMethod"}, "screen_brightness_control.linux.Light.executable": {"fullname": "screen_brightness_control.linux.Light.executable", "modulename": "screen_brightness_control.linux", "qualname": "Light.executable", "kind": "variable", "doc": "

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\n

Works 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\n
Returns:
\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\n
Arguments:
\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\n
Returns:
\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\n
Arguments:
\n\n
    \n
  • display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to filter_monitors
    • \n
\n\n
Returns:
\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\n
Returns:
\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\n
Arguments:
\n\n
    \n
  • method: the method the display can be addressed by. See .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.linux.METHODS": {"fullname": "screen_brightness_control.linux.METHODS", "modulename": "screen_brightness_control.linux", "qualname": "METHODS", "kind": "variable", "doc": "

\n", "default_value": "(<class 'screen_brightness_control.linux.SysFiles'>, <class 'screen_brightness_control.linux.I2C'>, <class 'screen_brightness_control.linux.XRandr'>, <class 'screen_brightness_control.linux.DDCUtil'>, <class 'screen_brightness_control.linux.Light'>)"}, "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\n

Splitting these definitions into a seperate submodule allows for detailed\nexplanations and verbose type definitions, without cluttering up the rest\nof the library.

\n\n

This 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\n

String 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\n

Relative 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\n

See 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\n
Example:
\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
\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\n
Arguments:
\n\n
    \n
  • display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to filter_monitors
    • \n
\n\n
Returns:
\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\n
Returns:
\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\n
Arguments:
\n\n
    \n
  • start: skip the first X handles
    • \n
\n\n
Raises:
\n\n
    \n
  • ctypes.WinError: upon failure to enumerate through the monitors
    • \n
\n", "signature": "(\tcls,\tstart: int = 0) -> collections.abc.Generator[ctypes.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\n
Arguments:
\n\n
    \n
  • display (.types.DisplayIdentifier): the specific display to return\ninformation about. This parameter is passed to filter_monitors
    • \n
\n\n
Returns:
\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\n
Returns:
\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
  • value: percentage brightness to set the display to
    • \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\n
Arguments:
\n\n
    \n
  • method: the method the display can be addressed by. See .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"}, "screen_brightness_control.windows.METHODS": {"fullname": "screen_brightness_control.windows.METHODS", "modulename": "screen_brightness_control.windows", "qualname": "METHODS", "kind": "variable", "doc": "

\n", "default_value": "(<class 'screen_brightness_control.windows.WMI'>, <class 'screen_brightness_control.windows.VCP'>)"}}, "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": 250}, "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": 492}, "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": 254}, "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": 355}, "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": 118}, "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": 73}, "screen_brightness_control.linux.METHODS": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 52, "signature": 0, "bases": 0, "doc": 3}, "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": 138}, "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": 71, "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": 52}, "screen_brightness_control.windows.list_monitors_info": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 79}, "screen_brightness_control.windows.METHODS": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 22, "signature": 0, "bases": 0, "doc": 3}}, "length": 125, "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}, "screen_brightness_control.linux.METHODS": {"tf": 1}, "screen_brightness_control.windows.METHODS": {"tf": 1}}, "df": 3}}}}}, "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.linux.METHODS": {"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}, "screen_brightness_control.windows.METHODS": {"tf": 1}}, "df": 125, "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.linux.METHODS": {"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}, "screen_brightness_control.windows.METHODS": {"tf": 1}}, "df": 125, "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.linux.METHODS": {"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}, "screen_brightness_control.windows.METHODS": {"tf": 1}}, "df": 125}}}}}, "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}, "screen_brightness_control.linux.METHODS": {"tf": 1}}, "df": 51}}}, "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}, "screen_brightness_control.linux.METHODS": {"tf": 1}, "screen_brightness_control.windows.METHODS": {"tf": 1}}, "df": 3}}}}}, "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}, "screen_brightness_control.windows.METHODS": {"tf": 1}}, "df": 14}}}}}}, "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.linux.METHODS": {"tf": 1.4142135623730951}, "screen_brightness_control.types.IntPercentage": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.METHODS": {"tf": 1.4142135623730951}}, "df": 10, "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.linux.METHODS": {"tf": 3.1622776601683795}, "screen_brightness_control.types.IntPercentage": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.METHODS": {"tf": 2}}, "df": 10}, "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}, "screen_brightness_control.linux.METHODS": {"tf": 1}}, "df": 2}}}}}}, "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}}}}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.linux.METHODS": {"tf": 2.23606797749979}, "screen_brightness_control.windows.METHODS": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "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.linux.METHODS": {"tf": 2.23606797749979}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.windows.METHODS": {"tf": 1.4142135623730951}}, "df": 3}}}}}, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.METHODS": {"tf": 1}}, "df": 1}}, "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}}, "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.METHODS": {"tf": 2.23606797749979}, "screen_brightness_control.windows.METHODS": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "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}, "screen_brightness_control.linux.METHODS": {"tf": 1}}, "df": 2}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"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.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}}, "c": {"docs": {}, "df": 0, "k": {"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.linux.METHODS": {"tf": 2.23606797749979}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.windows.METHODS": {"tf": 1.4142135623730951}}, "df": 3, "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}, "u": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.linux.METHODS": {"tf": 2.23606797749979}}, "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}, "screen_brightness_control.linux.METHODS": {"tf": 1}}, "df": 2}}}}, "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}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.METHODS": {"tf": 1}}, "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, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.METHODS": {"tf": 2.23606797749979}, "screen_brightness_control.windows.METHODS": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "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.linux.METHODS": {"tf": 2.23606797749979}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.windows.METHODS": {"tf": 1.4142135623730951}}, "df": 4}}, "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}}}}}}}}, "c": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.windows.METHODS": {"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}}, "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.METHODS": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.METHODS": {"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.681145747868608}, "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}}}}}}, "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}}}}}}, "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.489125293076057}, "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.908712114635714}, "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": 14.247806848775006}, "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.48074069840786}, "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.795831523312719}, "screen_brightness_control.linux.METHODS": {"tf": 1.7320508075688772}, "screen_brightness_control.types": {"tf": 3}, "screen_brightness_control.types.IntPercentage": {"tf": 1.7320508075688772}, "screen_brightness_control.types.Percentage": {"tf": 6.708203932499369}, "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": 4.358898943540674}, "screen_brightness_control.windows.list_monitors_info": {"tf": 4.795831523312719}, "screen_brightness_control.windows.METHODS": {"tf": 1.7320508075688772}}, "df": 125, "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.242640687119285}, "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.1622776601683795}, "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": 2}, "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.23606797749979}, "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.4142135623730951}, "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.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.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": 33}, "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}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 2}}}}}}}}, "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": 2.23606797749979}, "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.windows.get_display_info": {"tf": 1}}, "df": 14, "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, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}, "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.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.VCP.set_brightness": {"tf": 1}}, "df": 51, "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": 2}, "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.7320508075688772}, "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.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 2.449489742783178}, "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": 24, "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": 2}, "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": 2}, "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}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 12, "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.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 17}}}}}, "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.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethod.get_display_info": {"tf": 2.449489742783178}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.4142135623730951}, "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": 10, "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}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"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.4142135623730951}, "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.filter_monitors": {"tf": 1}, "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": 10, "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.helpers.percentage": {"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": 21}}}}}}}}}}, "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.7320508075688772}, "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.7320508075688772}, "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.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.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": 30, "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}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 25, "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": 3.1622776601683795}, "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.4142135623730951}, "screen_brightness_control.exceptions.NoValidDisplayError": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"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": 15, "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}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 10, "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": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1, "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. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of file diff --git a/extras/Examples.html b/extras/Examples.html index 5cd14db..900181a 100644 --- a/extras/Examples.html +++ b/extras/Examples.html @@ -58,7 +58,7 @@

License

-
screen_brightness_control v0.22.1
+
screen_brightness_control v0.22.2
diff --git a/extras/FAQ.html b/extras/FAQ.html index 1845067..1b300fc 100644 --- a/extras/FAQ.html +++ b/extras/FAQ.html @@ -60,7 +60,7 @@

License

-
screen_brightness_control v0.22.1
+
screen_brightness_control v0.22.2
diff --git a/extras/Installing On Linux.html b/extras/Installing On Linux.html index b1adfb5..76312be 100644 --- a/extras/Installing On Linux.html +++ b/extras/Installing On Linux.html @@ -66,7 +66,7 @@

License

-
screen_brightness_control v0.22.1
+
screen_brightness_control v0.22.2
diff --git a/extras/Quick Start Guide.html b/extras/Quick Start Guide.html index 7a2fe21..b5d2a25 100644 --- a/extras/Quick Start Guide.html +++ b/extras/Quick Start Guide.html @@ -61,7 +61,7 @@

License

-
screen_brightness_control v0.22.1
+
screen_brightness_control v0.22.2
diff --git a/source.html b/source.html index c043a3e..de247be 100644 --- a/source.html +++ b/source.html @@ -54,7 +54,7 @@

License

-
screen_brightness_control v0.22.1
+
screen_brightness_control v0.22.2
diff --git a/version_navigator.js b/version_navigator.js index 0f72102..e7aa8f9 100644 --- a/version_navigator.js +++ b/version_navigator.js @@ -1,4 +1,4 @@ -var all_nav_links={"API Version":{"docs/0.22.1":["docs/0.22.0"],"docs/0.21.0":[],"docs/0.20.0":[],"docs/0.19.0":[],"docs/0.18.0":[],"docs/0.17.0":[],"docs/0.16.2":["docs/0.16.1","docs/0.16.0"],"docs/0.15.5":["docs/0.15.4","docs/0.15.3","docs/0.15.2","docs/0.15.1","docs/0.15.0"],"docs/0.14.2":["docs/0.14.1","docs/0.14.0"],"docs/0.13.2":["docs/0.13.1","docs/0.13.0"],"docs/0.12.0":[],"docs/0.11.5":["docs/0.11.4","docs/0.11.3","docs/0.11.2","docs/0.11.1","docs/0.11.0"],"docs/0.10.1":["docs/0.10.0"],"docs/0.9.0":[],"docs/0.8.6":["docs/0.8.5","docs/0.8.4","docs/0.8.3","docs/0.8.2","docs/0.8.1","docs/0.8.0"],"docs/0.7.2":["docs/0.7.1","docs/0.7.0"],"docs/0.6.1":["docs/0.6.0"],"docs/0.5.1":[]},"Extras":["extras/Examples.html","extras/FAQ.html","extras/Installing On Linux.html","extras/Quick Start Guide.html"]};var mark_latest={"API Version":"docs/0.22.1"};function newElement(parent,elem){var element=document.createElement(elem);parent.appendChild(element);return element;} +var all_nav_links={"API Version":{"docs/0.22.2":["docs/0.22.1","docs/0.22.0"],"docs/0.21.0":[],"docs/0.20.0":[],"docs/0.19.0":[],"docs/0.18.0":[],"docs/0.17.0":[],"docs/0.16.2":["docs/0.16.1","docs/0.16.0"],"docs/0.15.5":["docs/0.15.4","docs/0.15.3","docs/0.15.2","docs/0.15.1","docs/0.15.0"],"docs/0.14.2":["docs/0.14.1","docs/0.14.0"],"docs/0.13.2":["docs/0.13.1","docs/0.13.0"],"docs/0.12.0":[],"docs/0.11.5":["docs/0.11.4","docs/0.11.3","docs/0.11.2","docs/0.11.1","docs/0.11.0"],"docs/0.10.1":["docs/0.10.0"],"docs/0.9.0":[],"docs/0.8.6":["docs/0.8.5","docs/0.8.4","docs/0.8.3","docs/0.8.2","docs/0.8.1","docs/0.8.0"],"docs/0.7.2":["docs/0.7.1","docs/0.7.0"],"docs/0.6.1":["docs/0.6.0"],"docs/0.5.1":[]},"Extras":["extras/Examples.html","extras/FAQ.html","extras/Installing On Linux.html","extras/Quick Start Guide.html"]};var mark_latest={"API Version":"docs/0.22.2"};function newElement(parent,elem){var element=document.createElement(elem);parent.appendChild(element);return element;} function navLink(link){var name=link.split("/").slice(-1).pop().replace('.html','');var url=new URL(link,get_version_navigation_base_url()).href;return[name,url];} class Menu{constructor(parent){this.container=newElement(parent,"ul");this.frame=this.container;this._numItems=0;} addItem(item){this._incrementItemCount();var[name,href]=navLink(item);var listItem=newElement(this.frame,"li");listItem.className="navigation";var item=newElement(listItem,"a");item.className="navigation";item.href=href;item.innerHTML=name;}