From f1e97b2961d001476258b436f91e46b1c3c8c695 Mon Sep 17 00:00:00 2001 From: "Github Actions [Bot]" Date: Sun, 17 Nov 2024 21:20:22 +0000 Subject: [PATCH] Bump --- docs/0.24.1/index.html | 7 + docs/0.24.1/screen_brightness_control.html | 2641 ++++++++++++ .../screen_brightness_control/config.html | 379 ++ .../screen_brightness_control/exceptions.html | 618 +++ .../screen_brightness_control/helpers.html | 1770 ++++++++ .../screen_brightness_control/linux.html | 3825 +++++++++++++++++ .../screen_brightness_control/types.html | 417 ++ .../screen_brightness_control/windows.html | 1635 +++++++ docs/0.24.1/search.js | 46 + extras/Examples.html | 2 +- extras/FAQ.html | 2 +- extras/Installing On Linux.html | 2 +- extras/Quick Start Guide.html | 2 +- source.html | 2 +- version_navigator.js | 2 +- 15 files changed, 11344 insertions(+), 6 deletions(-) create mode 100644 docs/0.24.1/index.html create mode 100644 docs/0.24.1/screen_brightness_control.html create mode 100644 docs/0.24.1/screen_brightness_control/config.html create mode 100644 docs/0.24.1/screen_brightness_control/exceptions.html create mode 100644 docs/0.24.1/screen_brightness_control/helpers.html create mode 100644 docs/0.24.1/screen_brightness_control/linux.html create mode 100644 docs/0.24.1/screen_brightness_control/types.html create mode 100644 docs/0.24.1/screen_brightness_control/windows.html create mode 100644 docs/0.24.1/search.js diff --git a/docs/0.24.1/index.html b/docs/0.24.1/index.html new file mode 100644 index 0000000..28d5bbd --- /dev/null +++ b/docs/0.24.1/index.html @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/0.24.1/screen_brightness_control.html b/docs/0.24.1/screen_brightness_control.html new file mode 100644 index 0000000..37ff15a --- /dev/null +++ b/docs/0.24.1/screen_brightness_control.html @@ -0,0 +1,2641 @@ + + + + + + + screen_brightness_control API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control

+ + + + + + + 
  1import logging
+  2import platform
+  3import threading
+  4import time
+  5import traceback
+  6from dataclasses import dataclass, field
+  7from typing import Callable, Any, Dict, List, Optional, Tuple, Type, Union, FrozenSet, ClassVar
+  8from ._version import __author__, __version__  # noqa: F401
+  9from .exceptions import NoValidDisplayError, format_exc
+ 10from .helpers import (BrightnessMethod, ScreenBrightnessError,
+ 11                      logarithmic_range, percentage)
+ 12from .types import DisplayIdentifier, IntPercentage, Percentage
+ 13from . import config
+ 14
+ 15
+ 16_logger = logging.getLogger(__name__)
+ 17_logger.addHandler(logging.NullHandler())
+ 18
+ 19
+ 20@config.default_params
+ 21def get_brightness(
+ 22    display: Optional[DisplayIdentifier] = None,
+ 23    method: Optional[str] = None,
+ 24    allow_duplicates: Optional[bool] = 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        allow_duplicates: controls whether to filter out duplicate displays or not.
+ 35        verbose_error: controls the level of detail in the error messages
+ 36
+ 37    Returns:
+ 38        A list of `.types.IntPercentage` values, each being the brightness of an
+ 39        individual display. Invalid displays may return None.
+ 40
+ 41    Example:
+ 42        ```python
+ 43        import screen_brightness_control as sbc
+ 44
+ 45        # get the current screen brightness (for all detected displays)
+ 46        current_brightness = sbc.get_brightness()
+ 47
+ 48        # get the brightness of the primary display
+ 49        primary_brightness = sbc.get_brightness(display=0)
+ 50
+ 51        # get the brightness of the secondary display (if connected)
+ 52        secondary_brightness = sbc.get_brightness(display=1)
+ 53        ```
+ 54    '''
+ 55    result = __brightness(
+ 56        display=display,
+ 57        method=method,
+ 58        meta_method='get',
+ 59        allow_duplicates=allow_duplicates,
+ 60        verbose_error=verbose_error
+ 61    )
+ 62    # __brightness can return None depending on the `no_return` kwarg. That obviously would never happen here
+ 63    # but the type checker doesn't see it that way.
+ 64    return [] if result is None else result
+ 65
+ 66
+ 67@config.default_params
+ 68def set_brightness(
+ 69    value: Percentage,
+ 70    display: Optional[DisplayIdentifier] = None,
+ 71    method: Optional[str] = None,
+ 72    force: bool = False,
+ 73    allow_duplicates: Optional[bool] = None,
+ 74    verbose_error: bool = False,
+ 75    no_return: bool = True
+ 76) -> Optional[List[Union[IntPercentage, None]]]:
+ 77    '''
+ 78    Sets the brightness level of one or more displays to a given value.
+ 79
+ 80    Args:
+ 81        value (.types.Percentage): the new brightness level
+ 82        display (.types.DisplayIdentifier): the specific display to adjust
+ 83        method: the method to use to set the brightness. See `get_methods` for
+ 84            more info on available methods
+ 85        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+ 86            This is because on most displays a brightness of 0 will turn off the backlight.
+ 87            If True, this check is bypassed
+ 88        allow_duplicates: controls whether to filter out duplicate displays or not.
+ 89        verbose_error: boolean value controls the amount of detail error messages will contain
+ 90        no_return: don't return the new brightness level(s)
+ 91
+ 92    Returns:
+ 93        If `no_return` is set to `True` (the default) then this function returns nothing.
+ 94        Otherwise, a list of `.types.IntPercentage` is returned, each item being the new
+ 95        brightness of each adjusted display (invalid displays may return None)
+ 96
+ 97    Example:
+ 98        ```python
+ 99        import screen_brightness_control as sbc
+100
+101        # set brightness to 50%
+102        sbc.set_brightness(50)
+103
+104        # set brightness to 0%
+105        sbc.set_brightness(0, force=True)
+106
+107        # increase brightness by 25%
+108        sbc.set_brightness('+25')
+109
+110        # decrease brightness by 30%
+111        sbc.set_brightness('-30')
+112
+113        # set the brightness of display 0 to 50%
+114        sbc.set_brightness(50, display=0)
+115        ```
+116    '''
+117    if isinstance(value, str) and ('+' in value or '-' in value):
+118        output: List[Union[IntPercentage, None]] = []
+119        for monitor in filter_monitors(display=display, method=method, allow_duplicates=allow_duplicates):
+120            # `filter_monitors()` will raise an error if no valid displays are found
+121            display_instance = Display.from_dict(monitor)
+122            display_instance.set_brightness(value=value, force=force)
+123            output.append(None if no_return else display_instance.get_brightness())
+124
+125        return None if no_return else output
+126
+127    if platform.system() == 'Linux' and not force:
+128        lower_bound = 1
+129    else:
+130        lower_bound = 0
+131
+132    value = percentage(value, lower_bound=lower_bound)
+133
+134    return __brightness(
+135        value, display=display, method=method,
+136        meta_method='set', no_return=no_return,
+137        allow_duplicates=allow_duplicates,
+138        verbose_error=verbose_error
+139    )
+140
+141
+142@config.default_params
+143def fade_brightness(
+144    finish: Percentage,
+145    start: Optional[Percentage] = None,
+146    interval: float = 0.01,
+147    increment: int = 1,
+148    blocking: bool = True,
+149    force: bool = False,
+150    logarithmic: bool = True,
+151    stoppable: bool = True,
+152    **kwargs
+153) -> Union[List[threading.Thread], List[Union[IntPercentage, None]]]:
+154    '''
+155    Gradually change the brightness of one or more displays
+156
+157    Args:
+158        finish (.types.Percentage): fade to this brightness level
+159        start (.types.Percentage): where the brightness should fade from.
+160            If this arg is not specified, the fade will be started from the
+161            current brightness.
+162        interval: the time delay between each step in brightness
+163        increment: the amount to change the brightness by per step
+164        blocking: whether this should occur in the main thread (`True`) or a new daemonic thread (`False`)
+165        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+166            This is because on most displays a brightness of 0 will turn off the backlight.
+167            If True, this check is bypassed
+168        logarithmic: follow a logarithmic brightness curve when adjusting the brightness
+169        stoppable: whether the fade can be stopped by starting a new fade on the same display
+170        **kwargs: passed through to `filter_monitors` for display selection.
+171            Will also be passed to `get_brightness` if `blocking is True`
+172
+173    Returns:
+174        By default, this function calls `get_brightness()` to return the new
+175        brightness of any adjusted displays.
+176
+177        If `blocking` is set to `False`, then a list of threads are
+178        returned, one for each display being faded.
+179
+180    Example:
+181        ```python
+182        import screen_brightness_control as sbc
+183
+184        # fade brightness from the current brightness to 50%
+185        sbc.fade_brightness(50)
+186
+187        # fade the brightness from 25% to 75%
+188        sbc.fade_brightness(75, start=25)
+189
+190        # fade the brightness from the current value to 100% in steps of 10%
+191        sbc.fade_brightness(100, increment=10)
+192
+193        # fade the brightness from 100% to 90% with time intervals of 0.1 seconds
+194        sbc.fade_brightness(90, start=100, interval=0.1)
+195
+196        # fade the brightness to 100% in a new thread
+197        sbc.fade_brightness(100, blocking=False)
+198        ```
+199    '''
+200    # make sure only compatible kwargs are passed to filter_monitors
+201    available_monitors = filter_monitors(
+202        **{k: v for k, v in kwargs.items() if k in (
+203            'display', 'haystack', 'method', 'include', 'allow_duplicates'
+204        )}
+205    )
+206
+207    threads = []
+208    for i in available_monitors:
+209        display = Display.from_dict(i)
+210
+211        thread = threading.Thread(target=display._fade_brightness, args=(finish,), kwargs={
+212            'start': start,
+213            'interval': interval,
+214            'increment': increment,
+215            'force': force,
+216            'logarithmic': logarithmic,
+217            'stoppable': stoppable
+218        })
+219        thread.start()
+220        threads.append(thread)
+221
+222    if not blocking:
+223        return threads
+224
+225    for t in threads:
+226        t.join()
+227    return get_brightness(**kwargs)
+228
+229
+230@config.default_params
+231def list_monitors_info(
+232    method: Optional[str] = None, allow_duplicates: Optional[bool] = None, unsupported: bool = False
+233) -> List[dict]:
+234    '''
+235    List detailed information about all displays that are controllable by this library
+236
+237    Args:
+238        method: the method to use to list the available displays. See `get_methods` for
+239            more info on available methods
+240        allow_duplicates: controls whether to filter out duplicate displays or not.
+241        unsupported: include detected displays that are invalid or unsupported
+242
+243    Returns:
+244        list: list of dictionaries containing information about the detected displays
+245
+246    Example:
+247        ```python
+248        import screen_brightness_control as sbc
+249        displays = sbc.list_monitors_info()
+250        for display in displays:
+251            print('=======================')
+252            # the manufacturer name plus the model
+253            print('Name:', display['name'])
+254            # the general model of the display
+255            print('Model:', display['model'])
+256            # the serial of the display
+257            print('Serial:', display['serial'])
+258            # the name of the brand of the display
+259            print('Manufacturer:', display['manufacturer'])
+260            # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ
+261            print('Manufacturer ID:', display['manufacturer_id'])
+262            # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES
+263            print('Index:', display['index'])
+264            # the method this display can be addressed by
+265            print('Method:', display['method'])
+266            # the EDID string associated with that display
+267            print('EDID:', display['edid'])
+268            # The UID of the display
+269            print('UID:', display['uid'])
+270        ```
+271    '''
+272    return _OS_MODULE.list_monitors_info(
+273        method=method, allow_duplicates=allow_duplicates, unsupported=unsupported
+274    )
+275
+276
+277@config.default_params
+278def list_monitors(method: Optional[str] = None, allow_duplicates: Optional[bool] = None) -> List[str]:
+279    '''
+280    List the names of all detected displays
+281
+282    Args:
+283        method: the method to use to list the available displays. See `get_methods` for
+284            more info on available methods
+285        allow_duplicates: controls whether to filter out duplicate displays or not.
+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, allow_duplicates=allow_duplicates)]
+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: Dict[str, type[BrightnessMethod]] = {i.__name__.lower(): i for i in _OS_MODULE.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    uid: Optional[str] = None
+350    '''A unique identifier for the display. This is usually inferred from the display's connection to the machine.'''
+351    edid: Optional[str] = None
+352    '''A 256 character hex string containing information about a display and its capabilities'''
+353    manufacturer: Optional[str] = None
+354    '''Name of the display's manufacturer'''
+355    manufacturer_id: Optional[str] = None
+356    '''3 letter code corresponding to the manufacturer name'''
+357    model: Optional[str] = None
+358    '''Model name of the display'''
+359    name: Optional[str] = None
+360    '''The name of the display, often the manufacturer name plus the model name'''
+361    serial: Optional[str] = None
+362    '''The serial number of the display or (if serial is not available) an ID assigned by the OS'''
+363
+364    _logger: logging.Logger = field(init=False, repr=False)
+365    _fade_thread_dict: ClassVar[Dict[FrozenSet[Any], threading.Thread]] = {}
+366    '''A dictionary mapping display identifiers to latest fade threads for stopping fades.'''
+367
+368    def __post_init__(self):
+369        self._logger = _logger.getChild(self.__class__.__name__).getChild(
+370            str(self.get_identifier()[1])[:20])
+371
+372    def fade_brightness(
+373        self,
+374        finish: Percentage,
+375        start: Optional[Percentage] = None,
+376        interval: float = 0.01,
+377        increment: int = 1,
+378        force: bool = False,
+379        logarithmic: bool = True,
+380        blocking: bool = True,
+381        stoppable: bool = True
+382    ) -> Optional[threading.Thread]:
+383        '''
+384        Gradually change the brightness of this display to a set value.
+385        Can execute in the current thread, blocking until completion,
+386        or in a separate thread, allowing concurrent operations.
+387        When set as non-blocking and stoppable, a new fade can halt the this operation.
+388
+389        Args:
+390            finish (.types.Percentage): the brightness level to end up on
+391            start (.types.Percentage): where the fade should start from. Defaults
+392                to whatever the current brightness level for the display is
+393            interval: time delay between each change in brightness
+394            increment: amount to change the brightness by each time (as a percentage)
+395            force: [*Linux only*] allow the brightness to be set to 0. By default,
+396                brightness values will never be set lower than 1, since setting them to 0
+397                often turns off the backlight
+398            logarithmic: follow a logarithmic curve when setting brightness values.
+399                See `logarithmic_range` for rationale
+400            blocking: run this function in the current thread and block until it completes
+401            stoppable: whether this fade will be stopped by starting a new fade on the same display
+402
+403        Returns:
+404            If `blocking` is `False`, returns a `threading.Thread` object representing the
+405            thread in which the fade operation is running.
+406            Otherwise, it returns None.
+407        '''
+408        thread = threading.Thread(target=self._fade_brightness, args=(finish,), kwargs={
+409            'start': start,
+410            'interval': interval,
+411            'increment': increment,
+412            'force': force,
+413            'logarithmic': logarithmic,
+414            'stoppable': stoppable
+415        })
+416        thread.start()
+417
+418        if not blocking:
+419            return thread
+420        else:
+421            thread.join()
+422            return None
+423
+424    def _fade_brightness(
+425        self,
+426        finish: Percentage,
+427        start: Optional[Percentage] = None,
+428        interval: float = 0.01,
+429        increment: int = 1,
+430        force: bool = False,
+431        logarithmic: bool = True,
+432        stoppable: bool = True
+433    ) -> None:
+434        # Record the latest thread for this display so that other stoppable threads can be stopped
+435        display_key = frozenset((self.method, self.index))
+436        self._fade_thread_dict[display_key] = threading.current_thread()
+437        # minimum brightness value
+438        if platform.system() == 'Linux' and not force:
+439            lower_bound = 1
+440        else:
+441            lower_bound = 0
+442
+443        current = self.get_brightness()
+444
+445        finish = percentage(finish, current, lower_bound)
+446        start = percentage(
+447            current if start is None else start, current, lower_bound)
+448
+449        # mypy says "object is not callable" but range is. Ignore this
+450        range_func: Callable = logarithmic_range if logarithmic else range  # type: ignore[assignment]
+451        increment = abs(increment)
+452        if start > finish:
+453            increment = -increment
+454
+455        self._logger.debug(
+456            f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+457
+458        # Record the time when the next brightness change should start
+459        next_change_start_time = time.time()
+460        for value in range_func(start, finish, increment):
+461            if stoppable and threading.current_thread() != self._fade_thread_dict[display_key]:
+462                # If the current thread is stoppable and it's not the latest thread, stop fading
+463                break
+464            # `value` is ensured not to hit `finish` in loop, this will be handled in the final step.
+465            self.set_brightness(value, force=force)
+466
+467            # `interval` is the intended time between the start of each brightness change.
+468            next_change_start_time += interval
+469            sleep_time = next_change_start_time - time.time()
+470            # Skip sleep if the scheduled time has already passed
+471            if sleep_time > 0:
+472                time.sleep(sleep_time)
+473        else:
+474            # As `value` doesn't hit `finish` in loop, we explicitly set brightness to `finish`.
+475            # This also avoids an unnecessary sleep in the last iteration.
+476            if not stoppable or threading.current_thread() == self._fade_thread_dict[display_key]:
+477                self.set_brightness(finish, force=force)
+478
+479    @classmethod
+480    def from_dict(cls, display: dict) -> 'Display':
+481        '''
+482        Initialise an instance of the class from a dictionary, ignoring
+483        any unwanted keys
+484        '''
+485        return cls(
+486            index=display['index'],
+487            method=display['method'],
+488            edid=display['edid'],
+489            manufacturer=display['manufacturer'],
+490            manufacturer_id=display['manufacturer_id'],
+491            model=display['model'],
+492            name=display['name'],
+493            serial=display['serial'],
+494            uid=display.get('uid')
+495        )
+496
+497    def get_brightness(self) -> IntPercentage:
+498        '''
+499        Returns the brightness of this display.
+500
+501        Returns:
+502            The brightness value of the display, as a percentage.
+503            See `.types.IntPercentage`
+504        '''
+505        return self.method.get_brightness(display=self.index)[0]
+506
+507    def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+508        '''
+509        Returns the `.types.DisplayIdentifier` for this display.
+510        Will iterate through the UID, EDID, serial, name and index and return the first
+511        value that is not equal to None
+512
+513        Returns:
+514            The name of the property returned and the value of said property.
+515            EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+516        '''
+517        for key in ('uid', 'edid', 'serial', 'name'):
+518            value = getattr(self, key, None)
+519            if value is not None:
+520                return key, value
+521        # the index should surely never be `None`
+522        return 'index', self.index
+523
+524    def is_active(self) -> bool:
+525        '''
+526        Attempts to retrieve the brightness for this display. If it works the display is deemed active
+527        '''
+528        try:
+529            self.get_brightness()
+530            return True
+531        except Exception as e:
+532            self._logger.error(
+533                f'Display.is_active: {self.get_identifier()} failed get_brightness call'
+534                f' - {format_exc(e)}'
+535            )
+536            return False
+537
+538    def set_brightness(self, value: Percentage, force: bool = False):
+539        '''
+540        Sets the brightness for this display. See `set_brightness` for the full docs
+541
+542        Args:
+543            value (.types.Percentage): the brightness percentage to set the display to
+544            force: allow the brightness to be set to 0 on Linux. This is disabled by default
+545                because setting the brightness of 0 will often turn off the backlight
+546        '''
+547        # convert brightness value to percentage
+548        if platform.system() == 'Linux' and not force:
+549            lower_bound = 1
+550        else:
+551            lower_bound = 0
+552
+553        value = percentage(
+554            value,
+555            current=self.get_brightness,
+556            lower_bound=lower_bound
+557        )
+558
+559        self.method.set_brightness(value, display=self.index)
+560
+561
+562@config.default_params
+563def filter_monitors(
+564    display: Optional[DisplayIdentifier] = None,
+565    haystack: Optional[List[dict]] = None,
+566    method: Optional[str] = None,
+567    include: List[str] = [],
+568    allow_duplicates: Optional[bool] = None
+569) -> List[dict]:
+570    '''
+571    Searches through the information for all detected displays
+572    and attempts to return the info matching the value given.
+573    Will attempt to match against index, name, edid, method and serial
+574
+575    Args:
+576        display (.types.DisplayIdentifier): the display you are searching for
+577        haystack: the information to filter from.
+578            If this isn't set it defaults to the return of `list_monitors_info`
+579        method: the method the monitors use. See `get_methods` for
+580            more info on available methods
+581        include: extra fields of information to sort by
+582        allow_duplicates: controls whether to filter out duplicate displays or not
+583
+584    Raises:
+585        NoValidDisplayError: if the display does not have a match
+586        TypeError: if the `display` kwarg is not `int` or `str`
+587
+588    Example:
+589        ```python
+590        import screen_brightness_control as sbc
+591
+592        search = 'GL2450H'
+593        match = sbc.filter_displays(search)
+594        print(match)
+595        # EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]
+596        ```
+597    '''
+598    if display is not None and type(display) not in (str, int):
+599        raise TypeError(
+600            f'display kwarg must be int or str, not "{type(display).__name__}"')
+601
+602    def get_monitor_list():
+603        # if we have been provided with a list of monitors to sift through then use that
+604        # otherwise, get the info ourselves
+605        if haystack is not None:
+606            monitors_with_duplicates = haystack
+607            if method is not None:
+608                method_class = next(iter(get_methods(method).values()))
+609                monitors_with_duplicates = [
+610                    i for i in haystack if i['method'] == method_class]
+611        else:
+612            monitors_with_duplicates = list_monitors_info(
+613                method=method, allow_duplicates=True)
+614
+615        return monitors_with_duplicates
+616
+617    def filter_monitor_list(to_filter):
+618        # This loop does two things:
+619        # 1. Filters out duplicate monitors
+620        # 2. Matches the display kwarg (if applicable)
+621
+622        # When duplicates are allowed, the logic is straightforward:
+623        if allow_duplicates:
+624            if display is None:
+625                # no monitor should be filtered out
+626                return to_filter
+627            elif isinstance(display, int):
+628                # 'display' variable should be the index of the monitor
+629                # return a list with the monitor at the index or an empty list if the index is out of range
+630                return to_filter[display:display + 1]
+631            elif isinstance(display, str):
+632                # 'display' variable should be an identifier of the monitor
+633                # multiple monitors with the same identifier are allowed here, so return all of them
+634                monitors = []
+635                for monitor in to_filter:
+636                    for identifier in ['uid', 'edid', 'serial', 'name'] + include:
+637                        if display == monitor.get(identifier, None):
+638                            monitors.append(monitor)
+639                            break
+640                return monitors
+641
+642        filtered_displays = {}
+643        for monitor in to_filter:
+644            # find a valid identifier for a monitor, excluding any which are equal to None
+645            added = False
+646            for identifier in ['uid', 'edid', 'serial', 'name'] + include:
+647                if monitor.get(identifier, None) is None:
+648                    continue
+649
+650                m_id = monitor[identifier]
+651                if m_id in filtered_displays:
+652                    break
+653
+654                if isinstance(display, str) and m_id != display:
+655                    continue
+656
+657                # check we haven't already added the monitor
+658                if not added:
+659                    filtered_displays[m_id] = monitor
+660                    added = True
+661
+662                # if the display kwarg is an integer and we are currently at that index
+663                if isinstance(display, int) and len(filtered_displays) - 1 == display:
+664                    return [monitor]
+665
+666                if added:
+667                    break
+668        return list(filtered_displays.values())
+669
+670    duplicates = []
+671    for _ in range(3):
+672        duplicates = get_monitor_list()
+673        if duplicates:
+674            break
+675        time.sleep(0.4)
+676    else:
+677        msg = 'no displays detected'
+678        if method is not None:
+679            msg += f' with method: {method!r}'
+680        raise NoValidDisplayError(msg)
+681
+682    monitors = filter_monitor_list(duplicates)
+683    if not monitors:
+684        # if no displays matched the query
+685        msg = 'no displays found'
+686        if display is not None:
+687            msg += f' with name/serial/edid/index of {display!r}'
+688        if method is not None:
+689            msg += f' with method of {method!r}'
+690        raise NoValidDisplayError(msg)
+691
+692    return monitors
+693
+694
+695def __brightness(
+696    *args: Any,
+697    display: Optional[DisplayIdentifier] = None,
+698    method: Optional[str] = None,
+699    meta_method: str = 'get',
+700    no_return: bool = False,
+701    allow_duplicates: bool = False,
+702    verbose_error: bool = False,
+703    **kwargs: Any
+704) -> Optional[List[Union[IntPercentage, None]]]:
+705    '''Internal function used to get/set brightness'''
+706    _logger.debug(
+707        f"brightness {meta_method} request display {display} with method {method}")
+708
+709    output: List[Union[int, None]] = []
+710    errors = []
+711
+712    for monitor in filter_monitors(display=display, method=method, allow_duplicates=allow_duplicates):
+713        try:
+714            if meta_method == 'set':
+715                monitor['method'].set_brightness(
+716                    *args, display=monitor['index'], **kwargs)
+717                if no_return:
+718                    output.append(None)
+719                    continue
+720
+721            output += monitor['method'].get_brightness(
+722                display=monitor['index'], **kwargs)
+723        except Exception as e:
+724            output.append(None)
+725            errors.append((
+726                monitor, e.__class__.__name__,
+727                traceback.format_exc() if verbose_error else e
+728            ))
+729
+730    if output:
+731        output_is_none = set(output) == {None}
+732        if (
+733            # can't have None output if we are trying to get the brightness
+734            (meta_method == 'get' and not output_is_none)
+735            or (
+736                # if we are setting the brightness then we CAN have a None output
+737                # but only if no_return is True.
+738                meta_method == 'set'
+739                and ((no_return and output_is_none) or not output_is_none)
+740            )
+741        ):
+742            return None if no_return else output
+743
+744    # if the function hasn't returned then it has failed
+745    msg = '\n'
+746    if errors:
+747        for monitor, exc_name, exc in errors:
+748            if isinstance(monitor, str):
+749                msg += f'\t{monitor}'
+750            else:
+751                msg += f'\t{monitor["name"]} ({monitor["serial"]})'
+752            msg += f' -> {exc_name}: '
+753            msg += str(exc).replace('\n', '\n\t\t') + '\n'
+754    else:
+755        msg += '\tno valid output was received from brightness methods'
+756
+757    raise ScreenBrightnessError(msg)
+758
+759
+760if platform.system() == 'Windows':
+761    from . import windows
+762    _OS_MODULE = windows
+763elif platform.system() == 'Linux':
+764    from . import linux
+765    _OS_MODULE = linux
+766else:
+767    _logger.warning(
+768        f'package imported on unsupported platform ({platform.system()})')
+
+ + +
+ +
+
+ +
+
@config.default_params
+ + def + get_brightness( display: Union[str, int, NoneType] = None, method: Optional[str] = None, allow_duplicates: Optional[bool] = None, verbose_error: bool = False) -> List[Optional[int]]: + + + +
+ + 
21@config.default_params
+22def get_brightness(
+23    display: Optional[DisplayIdentifier] = None,
+24    method: Optional[str] = None,
+25    allow_duplicates: Optional[bool] = None,
+26    verbose_error: bool = False
+27) -> List[Union[IntPercentage, None]]:
+28    '''
+29    Returns the current brightness of one or more displays
+30
+31    Args:
+32        display (.types.DisplayIdentifier): the specific display to query
+33        method: the method to use to get the brightness. See `get_methods` for
+34            more info on available methods
+35        allow_duplicates: controls whether to filter out duplicate displays or not.
+36        verbose_error: controls the level of detail in the error messages
+37
+38    Returns:
+39        A list of `.types.IntPercentage` values, each being the brightness of an
+40        individual display. Invalid displays may return None.
+41
+42    Example:
+43        ```python
+44        import screen_brightness_control as sbc
+45
+46        # get the current screen brightness (for all detected displays)
+47        current_brightness = sbc.get_brightness()
+48
+49        # get the brightness of the primary display
+50        primary_brightness = sbc.get_brightness(display=0)
+51
+52        # get the brightness of the secondary display (if connected)
+53        secondary_brightness = sbc.get_brightness(display=1)
+54        ```
+55    '''
+56    result = __brightness(
+57        display=display,
+58        method=method,
+59        meta_method='get',
+60        allow_duplicates=allow_duplicates,
+61        verbose_error=verbose_error
+62    )
+63    # __brightness can return None depending on the `no_return` kwarg. That obviously would never happen here
+64    # but the type checker doesn't see it that way.
+65    return [] if result is None else result
+
+ + +

Returns the current brightness of one or more displays

+ +
Arguments:
+ +
    +
  • display (screen_brightness_control.types.DisplayIdentifier): the specific display to query
    • +
  • method: the method to use to get the brightness. See get_methods for +more info on available methods
    • +
  • allow_duplicates: controls whether to filter out duplicate displays or not.
    • +
  • verbose_error: controls the level of detail in the error messages
    • +
+ +
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)
+
+
+
+
+ + +
+
+ +
+
@config.default_params
+ + def + set_brightness( value: Union[int, str], display: Union[str, int, NoneType] = None, method: Optional[str] = None, force: bool = False, allow_duplicates: Optional[bool] = None, verbose_error: bool = False, no_return: bool = True) -> Optional[List[Optional[int]]]: + + + +
+ + 
 68@config.default_params
+ 69def set_brightness(
+ 70    value: Percentage,
+ 71    display: Optional[DisplayIdentifier] = None,
+ 72    method: Optional[str] = None,
+ 73    force: bool = False,
+ 74    allow_duplicates: Optional[bool] = None,
+ 75    verbose_error: bool = False,
+ 76    no_return: bool = True
+ 77) -> Optional[List[Union[IntPercentage, None]]]:
+ 78    '''
+ 79    Sets the brightness level of one or more displays to a given value.
+ 80
+ 81    Args:
+ 82        value (.types.Percentage): the new brightness level
+ 83        display (.types.DisplayIdentifier): the specific display to adjust
+ 84        method: the method to use to set the brightness. See `get_methods` for
+ 85            more info on available methods
+ 86        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+ 87            This is because on most displays a brightness of 0 will turn off the backlight.
+ 88            If True, this check is bypassed
+ 89        allow_duplicates: controls whether to filter out duplicate displays or not.
+ 90        verbose_error: boolean value controls the amount of detail error messages will contain
+ 91        no_return: don't return the new brightness level(s)
+ 92
+ 93    Returns:
+ 94        If `no_return` is set to `True` (the default) then this function returns nothing.
+ 95        Otherwise, a list of `.types.IntPercentage` is returned, each item being the new
+ 96        brightness of each adjusted display (invalid displays may return None)
+ 97
+ 98    Example:
+ 99        ```python
+100        import screen_brightness_control as sbc
+101
+102        # set brightness to 50%
+103        sbc.set_brightness(50)
+104
+105        # set brightness to 0%
+106        sbc.set_brightness(0, force=True)
+107
+108        # increase brightness by 25%
+109        sbc.set_brightness('+25')
+110
+111        # decrease brightness by 30%
+112        sbc.set_brightness('-30')
+113
+114        # set the brightness of display 0 to 50%
+115        sbc.set_brightness(50, display=0)
+116        ```
+117    '''
+118    if isinstance(value, str) and ('+' in value or '-' in value):
+119        output: List[Union[IntPercentage, None]] = []
+120        for monitor in filter_monitors(display=display, method=method, allow_duplicates=allow_duplicates):
+121            # `filter_monitors()` will raise an error if no valid displays are found
+122            display_instance = Display.from_dict(monitor)
+123            display_instance.set_brightness(value=value, force=force)
+124            output.append(None if no_return else display_instance.get_brightness())
+125
+126        return None if no_return else output
+127
+128    if platform.system() == 'Linux' and not force:
+129        lower_bound = 1
+130    else:
+131        lower_bound = 0
+132
+133    value = percentage(value, lower_bound=lower_bound)
+134
+135    return __brightness(
+136        value, display=display, method=method,
+137        meta_method='set', no_return=no_return,
+138        allow_duplicates=allow_duplicates,
+139        verbose_error=verbose_error
+140    )
+
+ + +

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
    • +
  • allow_duplicates: controls whether to filter out duplicate displays or not.
    • +
  • 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)
+
+
+
+
+ + +
+
+ +
+
@config.default_params
+ + 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, stoppable: bool = True, **kwargs) -> Union[List[threading.Thread], List[Optional[int]]]: + + + +
+ + 
143@config.default_params
+144def fade_brightness(
+145    finish: Percentage,
+146    start: Optional[Percentage] = None,
+147    interval: float = 0.01,
+148    increment: int = 1,
+149    blocking: bool = True,
+150    force: bool = False,
+151    logarithmic: bool = True,
+152    stoppable: bool = True,
+153    **kwargs
+154) -> Union[List[threading.Thread], List[Union[IntPercentage, None]]]:
+155    '''
+156    Gradually change the brightness of one or more displays
+157
+158    Args:
+159        finish (.types.Percentage): fade to this brightness level
+160        start (.types.Percentage): where the brightness should fade from.
+161            If this arg is not specified, the fade will be started from the
+162            current brightness.
+163        interval: the time delay between each step in brightness
+164        increment: the amount to change the brightness by per step
+165        blocking: whether this should occur in the main thread (`True`) or a new daemonic thread (`False`)
+166        force: [*Linux Only*] if False the brightness will never be set lower than 1.
+167            This is because on most displays a brightness of 0 will turn off the backlight.
+168            If True, this check is bypassed
+169        logarithmic: follow a logarithmic brightness curve when adjusting the brightness
+170        stoppable: whether the fade can be stopped by starting a new fade on the same display
+171        **kwargs: passed through to `filter_monitors` for display selection.
+172            Will also be passed to `get_brightness` if `blocking is True`
+173
+174    Returns:
+175        By default, this function calls `get_brightness()` to return the new
+176        brightness of any adjusted displays.
+177
+178        If `blocking` is set to `False`, then a list of threads are
+179        returned, one for each display being faded.
+180
+181    Example:
+182        ```python
+183        import screen_brightness_control as sbc
+184
+185        # fade brightness from the current brightness to 50%
+186        sbc.fade_brightness(50)
+187
+188        # fade the brightness from 25% to 75%
+189        sbc.fade_brightness(75, start=25)
+190
+191        # fade the brightness from the current value to 100% in steps of 10%
+192        sbc.fade_brightness(100, increment=10)
+193
+194        # fade the brightness from 100% to 90% with time intervals of 0.1 seconds
+195        sbc.fade_brightness(90, start=100, interval=0.1)
+196
+197        # fade the brightness to 100% in a new thread
+198        sbc.fade_brightness(100, blocking=False)
+199        ```
+200    '''
+201    # make sure only compatible kwargs are passed to filter_monitors
+202    available_monitors = filter_monitors(
+203        **{k: v for k, v in kwargs.items() if k in (
+204            'display', 'haystack', 'method', 'include', 'allow_duplicates'
+205        )}
+206    )
+207
+208    threads = []
+209    for i in available_monitors:
+210        display = Display.from_dict(i)
+211
+212        thread = threading.Thread(target=display._fade_brightness, args=(finish,), kwargs={
+213            'start': start,
+214            'interval': interval,
+215            'increment': increment,
+216            'force': force,
+217            'logarithmic': logarithmic,
+218            'stoppable': stoppable
+219        })
+220        thread.start()
+221        threads.append(thread)
+222
+223    if not blocking:
+224        return threads
+225
+226    for t in threads:
+227        t.join()
+228    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
    • +
  • stoppable: whether the fade can be stopped by starting a new fade on the same display
    • +
  • **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)
+
+
+
+
+ + +
+
+ +
+
@config.default_params
+ + def + list_monitors_info( method: Optional[str] = None, allow_duplicates: Optional[bool] = None, unsupported: bool = False) -> List[dict]: + + + +
+ + 
231@config.default_params
+232def list_monitors_info(
+233    method: Optional[str] = None, allow_duplicates: Optional[bool] = None, unsupported: bool = False
+234) -> List[dict]:
+235    '''
+236    List detailed information about all displays that are controllable by this library
+237
+238    Args:
+239        method: the method to use to list the available displays. See `get_methods` for
+240            more info on available methods
+241        allow_duplicates: controls whether to filter out duplicate displays or not.
+242        unsupported: include detected displays that are invalid or unsupported
+243
+244    Returns:
+245        list: list of dictionaries containing information about the detected displays
+246
+247    Example:
+248        ```python
+249        import screen_brightness_control as sbc
+250        displays = sbc.list_monitors_info()
+251        for display in displays:
+252            print('=======================')
+253            # the manufacturer name plus the model
+254            print('Name:', display['name'])
+255            # the general model of the display
+256            print('Model:', display['model'])
+257            # the serial of the display
+258            print('Serial:', display['serial'])
+259            # the name of the brand of the display
+260            print('Manufacturer:', display['manufacturer'])
+261            # the 3 letter code corresponding to the brand name, EG: BNQ -> BenQ
+262            print('Manufacturer ID:', display['manufacturer_id'])
+263            # the index of that display FOR THE SPECIFIC METHOD THE DISPLAY USES
+264            print('Index:', display['index'])
+265            # the method this display can be addressed by
+266            print('Method:', display['method'])
+267            # the EDID string associated with that display
+268            print('EDID:', display['edid'])
+269            # The UID of the display
+270            print('UID:', display['uid'])
+271        ```
+272    '''
+273    return _OS_MODULE.list_monitors_info(
+274        method=method, allow_duplicates=allow_duplicates, unsupported=unsupported
+275    )
+
+ + +

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: controls 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'])
+    # The UID of the display
+    print('UID:', display['uid'])
+
+
+
+
+ + +
+
+ +
+
@config.default_params
+ + def + list_monitors( method: Optional[str] = None, allow_duplicates: Optional[bool] = None) -> List[str]: + + + +
+ + 
278@config.default_params
+279def list_monitors(method: Optional[str] = None, allow_duplicates: Optional[bool] = 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        allow_duplicates: controls whether to filter out duplicate displays or not.
+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, allow_duplicates=allow_duplicates)]
+
+ + +

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
    • +
  • allow_duplicates: controls whether to filter out duplicate displays or not.
    • +
+ +
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: Dict[str, type[BrightnessMethod]] = {i.__name__.lower(): i for i in _OS_MODULE.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    uid: Optional[str] = None
+351    '''A unique identifier for the display. This is usually inferred from the display's connection to the machine.'''
+352    edid: Optional[str] = None
+353    '''A 256 character hex string containing information about a display and its capabilities'''
+354    manufacturer: Optional[str] = None
+355    '''Name of the display's manufacturer'''
+356    manufacturer_id: Optional[str] = None
+357    '''3 letter code corresponding to the manufacturer name'''
+358    model: Optional[str] = None
+359    '''Model name of the display'''
+360    name: Optional[str] = None
+361    '''The name of the display, often the manufacturer name plus the model name'''
+362    serial: Optional[str] = None
+363    '''The serial number of the display or (if serial is not available) an ID assigned by the OS'''
+364
+365    _logger: logging.Logger = field(init=False, repr=False)
+366    _fade_thread_dict: ClassVar[Dict[FrozenSet[Any], threading.Thread]] = {}
+367    '''A dictionary mapping display identifiers to latest fade threads for stopping fades.'''
+368
+369    def __post_init__(self):
+370        self._logger = _logger.getChild(self.__class__.__name__).getChild(
+371            str(self.get_identifier()[1])[:20])
+372
+373    def fade_brightness(
+374        self,
+375        finish: Percentage,
+376        start: Optional[Percentage] = None,
+377        interval: float = 0.01,
+378        increment: int = 1,
+379        force: bool = False,
+380        logarithmic: bool = True,
+381        blocking: bool = True,
+382        stoppable: bool = True
+383    ) -> Optional[threading.Thread]:
+384        '''
+385        Gradually change the brightness of this display to a set value.
+386        Can execute in the current thread, blocking until completion,
+387        or in a separate thread, allowing concurrent operations.
+388        When set as non-blocking and stoppable, a new fade can halt the this operation.
+389
+390        Args:
+391            finish (.types.Percentage): the brightness level to end up on
+392            start (.types.Percentage): where the fade should start from. Defaults
+393                to whatever the current brightness level for the display is
+394            interval: time delay between each change in brightness
+395            increment: amount to change the brightness by each time (as a percentage)
+396            force: [*Linux only*] allow the brightness to be set to 0. By default,
+397                brightness values will never be set lower than 1, since setting them to 0
+398                often turns off the backlight
+399            logarithmic: follow a logarithmic curve when setting brightness values.
+400                See `logarithmic_range` for rationale
+401            blocking: run this function in the current thread and block until it completes
+402            stoppable: whether this fade will be stopped by starting a new fade on the same display
+403
+404        Returns:
+405            If `blocking` is `False`, returns a `threading.Thread` object representing the
+406            thread in which the fade operation is running.
+407            Otherwise, it returns None.
+408        '''
+409        thread = threading.Thread(target=self._fade_brightness, args=(finish,), kwargs={
+410            'start': start,
+411            'interval': interval,
+412            'increment': increment,
+413            'force': force,
+414            'logarithmic': logarithmic,
+415            'stoppable': stoppable
+416        })
+417        thread.start()
+418
+419        if not blocking:
+420            return thread
+421        else:
+422            thread.join()
+423            return None
+424
+425    def _fade_brightness(
+426        self,
+427        finish: Percentage,
+428        start: Optional[Percentage] = None,
+429        interval: float = 0.01,
+430        increment: int = 1,
+431        force: bool = False,
+432        logarithmic: bool = True,
+433        stoppable: bool = True
+434    ) -> None:
+435        # Record the latest thread for this display so that other stoppable threads can be stopped
+436        display_key = frozenset((self.method, self.index))
+437        self._fade_thread_dict[display_key] = threading.current_thread()
+438        # minimum brightness value
+439        if platform.system() == 'Linux' and not force:
+440            lower_bound = 1
+441        else:
+442            lower_bound = 0
+443
+444        current = self.get_brightness()
+445
+446        finish = percentage(finish, current, lower_bound)
+447        start = percentage(
+448            current if start is None else start, current, lower_bound)
+449
+450        # mypy says "object is not callable" but range is. Ignore this
+451        range_func: Callable = logarithmic_range if logarithmic else range  # type: ignore[assignment]
+452        increment = abs(increment)
+453        if start > finish:
+454            increment = -increment
+455
+456        self._logger.debug(
+457            f'fade {start}->{finish}:{increment}:logarithmic={logarithmic}')
+458
+459        # Record the time when the next brightness change should start
+460        next_change_start_time = time.time()
+461        for value in range_func(start, finish, increment):
+462            if stoppable and threading.current_thread() != self._fade_thread_dict[display_key]:
+463                # If the current thread is stoppable and it's not the latest thread, stop fading
+464                break
+465            # `value` is ensured not to hit `finish` in loop, this will be handled in the final step.
+466            self.set_brightness(value, force=force)
+467
+468            # `interval` is the intended time between the start of each brightness change.
+469            next_change_start_time += interval
+470            sleep_time = next_change_start_time - time.time()
+471            # Skip sleep if the scheduled time has already passed
+472            if sleep_time > 0:
+473                time.sleep(sleep_time)
+474        else:
+475            # As `value` doesn't hit `finish` in loop, we explicitly set brightness to `finish`.
+476            # This also avoids an unnecessary sleep in the last iteration.
+477            if not stoppable or threading.current_thread() == self._fade_thread_dict[display_key]:
+478                self.set_brightness(finish, force=force)
+479
+480    @classmethod
+481    def from_dict(cls, display: dict) -> 'Display':
+482        '''
+483        Initialise an instance of the class from a dictionary, ignoring
+484        any unwanted keys
+485        '''
+486        return cls(
+487            index=display['index'],
+488            method=display['method'],
+489            edid=display['edid'],
+490            manufacturer=display['manufacturer'],
+491            manufacturer_id=display['manufacturer_id'],
+492            model=display['model'],
+493            name=display['name'],
+494            serial=display['serial'],
+495            uid=display.get('uid')
+496        )
+497
+498    def get_brightness(self) -> IntPercentage:
+499        '''
+500        Returns the brightness of this display.
+501
+502        Returns:
+503            The brightness value of the display, as a percentage.
+504            See `.types.IntPercentage`
+505        '''
+506        return self.method.get_brightness(display=self.index)[0]
+507
+508    def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+509        '''
+510        Returns the `.types.DisplayIdentifier` for this display.
+511        Will iterate through the UID, EDID, serial, name and index and return the first
+512        value that is not equal to None
+513
+514        Returns:
+515            The name of the property returned and the value of said property.
+516            EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+517        '''
+518        for key in ('uid', 'edid', 'serial', 'name'):
+519            value = getattr(self, key, None)
+520            if value is not None:
+521                return key, value
+522        # the index should surely never be `None`
+523        return 'index', self.index
+524
+525    def is_active(self) -> bool:
+526        '''
+527        Attempts to retrieve the brightness for this display. If it works the display is deemed active
+528        '''
+529        try:
+530            self.get_brightness()
+531            return True
+532        except Exception as e:
+533            self._logger.error(
+534                f'Display.is_active: {self.get_identifier()} failed get_brightness call'
+535                f' - {format_exc(e)}'
+536            )
+537            return False
+538
+539    def set_brightness(self, value: Percentage, force: bool = False):
+540        '''
+541        Sets the brightness for this display. See `set_brightness` for the full docs
+542
+543        Args:
+544            value (.types.Percentage): the brightness percentage to set the display to
+545            force: allow the brightness to be set to 0 on Linux. This is disabled by default
+546                because setting the brightness of 0 will often turn off the backlight
+547        '''
+548        # convert brightness value to percentage
+549        if platform.system() == 'Linux' and not force:
+550            lower_bound = 1
+551        else:
+552            lower_bound = 0
+553
+554        value = percentage(
+555            value,
+556            current=self.get_brightness,
+557            lower_bound=lower_bound
+558        )
+559
+560        self.method.set_brightness(value, display=self.index)
+
+ + +

Represents a single connected display.

+
+ + +
+
+ + Display( index: int, method: Type[screen_brightness_control.helpers.BrightnessMethod], uid: Optional[str] = None, 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

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

A unique identifier for the display. This is usually inferred from the display's connection to the machine.

+
+ + +
+
+
+ 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, blocking: bool = True, stoppable: bool = True) -> Optional[threading.Thread]: + + + +
+ + 
373    def fade_brightness(
+374        self,
+375        finish: Percentage,
+376        start: Optional[Percentage] = None,
+377        interval: float = 0.01,
+378        increment: int = 1,
+379        force: bool = False,
+380        logarithmic: bool = True,
+381        blocking: bool = True,
+382        stoppable: bool = True
+383    ) -> Optional[threading.Thread]:
+384        '''
+385        Gradually change the brightness of this display to a set value.
+386        Can execute in the current thread, blocking until completion,
+387        or in a separate thread, allowing concurrent operations.
+388        When set as non-blocking and stoppable, a new fade can halt the this operation.
+389
+390        Args:
+391            finish (.types.Percentage): the brightness level to end up on
+392            start (.types.Percentage): where the fade should start from. Defaults
+393                to whatever the current brightness level for the display is
+394            interval: time delay between each change in brightness
+395            increment: amount to change the brightness by each time (as a percentage)
+396            force: [*Linux only*] allow the brightness to be set to 0. By default,
+397                brightness values will never be set lower than 1, since setting them to 0
+398                often turns off the backlight
+399            logarithmic: follow a logarithmic curve when setting brightness values.
+400                See `logarithmic_range` for rationale
+401            blocking: run this function in the current thread and block until it completes
+402            stoppable: whether this fade will be stopped by starting a new fade on the same display
+403
+404        Returns:
+405            If `blocking` is `False`, returns a `threading.Thread` object representing the
+406            thread in which the fade operation is running.
+407            Otherwise, it returns None.
+408        '''
+409        thread = threading.Thread(target=self._fade_brightness, args=(finish,), kwargs={
+410            'start': start,
+411            'interval': interval,
+412            'increment': increment,
+413            'force': force,
+414            'logarithmic': logarithmic,
+415            'stoppable': stoppable
+416        })
+417        thread.start()
+418
+419        if not blocking:
+420            return thread
+421        else:
+422            thread.join()
+423            return None
+
+ + +

Gradually change the brightness of this display to a set value. +Can execute in the current thread, blocking until completion, +or in a separate thread, allowing concurrent operations. +When set as non-blocking and stoppable, a new fade can halt the this operation.

+ +
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
    • +
  • blocking: run this function in the current thread and block until it completes
    • +
  • stoppable: whether this fade will be stopped by starting a new fade on the same display
    • +
+ +
Returns:
+ +
+

If blocking is False, returns a threading.Thread object representing the + thread in which the fade operation is running. + Otherwise, it returns None.

+
+
+ + +
+
+ +
+
@classmethod
+ + def + from_dict(cls, display: dict) -> Display: + + + +
+ + 
480    @classmethod
+481    def from_dict(cls, display: dict) -> 'Display':
+482        '''
+483        Initialise an instance of the class from a dictionary, ignoring
+484        any unwanted keys
+485        '''
+486        return cls(
+487            index=display['index'],
+488            method=display['method'],
+489            edid=display['edid'],
+490            manufacturer=display['manufacturer'],
+491            manufacturer_id=display['manufacturer_id'],
+492            model=display['model'],
+493            name=display['name'],
+494            serial=display['serial'],
+495            uid=display.get('uid')
+496        )
+
+ + +

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

+
+ + +
+
+ +
+ + def + get_brightness(self) -> int: + + + +
+ + 
498    def get_brightness(self) -> IntPercentage:
+499        '''
+500        Returns the brightness of this display.
+501
+502        Returns:
+503            The brightness value of the display, as a percentage.
+504            See `.types.IntPercentage`
+505        '''
+506        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]]: + + + +
+ + 
508    def get_identifier(self) -> Tuple[str, DisplayIdentifier]:
+509        '''
+510        Returns the `.types.DisplayIdentifier` for this display.
+511        Will iterate through the UID, EDID, serial, name and index and return the first
+512        value that is not equal to None
+513
+514        Returns:
+515            The name of the property returned and the value of said property.
+516            EG: `('serial', '123abc...')` or `('name', 'BenQ GL2450H')`
+517        '''
+518        for key in ('uid', 'edid', 'serial', 'name'):
+519            value = getattr(self, key, None)
+520            if value is not None:
+521                return key, value
+522        # the index should surely never be `None`
+523        return 'index', self.index
+
+ + +

Returns the screen_brightness_control.types.DisplayIdentifier for this display. +Will iterate through the UID, 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: + + + +
+ + 
525    def is_active(self) -> bool:
+526        '''
+527        Attempts to retrieve the brightness for this display. If it works the display is deemed active
+528        '''
+529        try:
+530            self.get_brightness()
+531            return True
+532        except Exception as e:
+533            self._logger.error(
+534                f'Display.is_active: {self.get_identifier()} failed get_brightness call'
+535                f' - {format_exc(e)}'
+536            )
+537            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): + + + +
+ + 
539    def set_brightness(self, value: Percentage, force: bool = False):
+540        '''
+541        Sets the brightness for this display. See `set_brightness` for the full docs
+542
+543        Args:
+544            value (.types.Percentage): the brightness percentage to set the display to
+545            force: allow the brightness to be set to 0 on Linux. This is disabled by default
+546                because setting the brightness of 0 will often turn off the backlight
+547        '''
+548        # convert brightness value to percentage
+549        if platform.system() == 'Linux' and not force:
+550            lower_bound = 1
+551        else:
+552            lower_bound = 0
+553
+554        value = percentage(
+555            value,
+556            current=self.get_brightness,
+557            lower_bound=lower_bound
+558        )
+559
+560        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
    • +
+
+ + +
+
+
+ +
+
@config.default_params
+ + def + filter_monitors( display: Union[str, int, NoneType] = None, haystack: Optional[List[dict]] = None, method: Optional[str] = None, include: List[str] = [], allow_duplicates: Optional[bool] = None) -> List[dict]: + + + +
+ + 
563@config.default_params
+564def filter_monitors(
+565    display: Optional[DisplayIdentifier] = None,
+566    haystack: Optional[List[dict]] = None,
+567    method: Optional[str] = None,
+568    include: List[str] = [],
+569    allow_duplicates: Optional[bool] = None
+570) -> List[dict]:
+571    '''
+572    Searches through the information for all detected displays
+573    and attempts to return the info matching the value given.
+574    Will attempt to match against index, name, edid, method and serial
+575
+576    Args:
+577        display (.types.DisplayIdentifier): the display you are searching for
+578        haystack: the information to filter from.
+579            If this isn't set it defaults to the return of `list_monitors_info`
+580        method: the method the monitors use. See `get_methods` for
+581            more info on available methods
+582        include: extra fields of information to sort by
+583        allow_duplicates: controls whether to filter out duplicate displays or not
+584
+585    Raises:
+586        NoValidDisplayError: if the display does not have a match
+587        TypeError: if the `display` kwarg is not `int` or `str`
+588
+589    Example:
+590        ```python
+591        import screen_brightness_control as sbc
+592
+593        search = 'GL2450H'
+594        match = sbc.filter_displays(search)
+595        print(match)
+596        # EG output: [{'name': 'BenQ GL2450H', 'model': 'GL2450H', ... }]
+597        ```
+598    '''
+599    if display is not None and type(display) not in (str, int):
+600        raise TypeError(
+601            f'display kwarg must be int or str, not "{type(display).__name__}"')
+602
+603    def get_monitor_list():
+604        # if we have been provided with a list of monitors to sift through then use that
+605        # otherwise, get the info ourselves
+606        if haystack is not None:
+607            monitors_with_duplicates = haystack
+608            if method is not None:
+609                method_class = next(iter(get_methods(method).values()))
+610                monitors_with_duplicates = [
+611                    i for i in haystack if i['method'] == method_class]
+612        else:
+613            monitors_with_duplicates = list_monitors_info(
+614                method=method, allow_duplicates=True)
+615
+616        return monitors_with_duplicates
+617
+618    def filter_monitor_list(to_filter):
+619        # This loop does two things:
+620        # 1. Filters out duplicate monitors
+621        # 2. Matches the display kwarg (if applicable)
+622
+623        # When duplicates are allowed, the logic is straightforward:
+624        if allow_duplicates:
+625            if display is None:
+626                # no monitor should be filtered out
+627                return to_filter
+628            elif isinstance(display, int):
+629                # 'display' variable should be the index of the monitor
+630                # return a list with the monitor at the index or an empty list if the index is out of range
+631                return to_filter[display:display + 1]
+632            elif isinstance(display, str):
+633                # 'display' variable should be an identifier of the monitor
+634                # multiple monitors with the same identifier are allowed here, so return all of them
+635                monitors = []
+636                for monitor in to_filter:
+637                    for identifier in ['uid', 'edid', 'serial', 'name'] + include:
+638                        if display == monitor.get(identifier, None):
+639                            monitors.append(monitor)
+640                            break
+641                return monitors
+642
+643        filtered_displays = {}
+644        for monitor in to_filter:
+645            # find a valid identifier for a monitor, excluding any which are equal to None
+646            added = False
+647            for identifier in ['uid', 'edid', 'serial', 'name'] + include:
+648                if monitor.get(identifier, None) is None:
+649                    continue
+650
+651                m_id = monitor[identifier]
+652                if m_id in filtered_displays:
+653                    break
+654
+655                if isinstance(display, str) and m_id != display:
+656                    continue
+657
+658                # check we haven't already added the monitor
+659                if not added:
+660                    filtered_displays[m_id] = monitor
+661                    added = True
+662
+663                # if the display kwarg is an integer and we are currently at that index
+664                if isinstance(display, int) and len(filtered_displays) - 1 == display:
+665                    return [monitor]
+666
+667                if added:
+668                    break
+669        return list(filtered_displays.values())
+670
+671    duplicates = []
+672    for _ in range(3):
+673        duplicates = get_monitor_list()
+674        if duplicates:
+675            break
+676        time.sleep(0.4)
+677    else:
+678        msg = 'no displays detected'
+679        if method is not None:
+680            msg += f' with method: {method!r}'
+681        raise NoValidDisplayError(msg)
+682
+683    monitors = filter_monitor_list(duplicates)
+684    if not monitors:
+685        # if no displays matched the query
+686        msg = 'no displays found'
+687        if display is not None:
+688            msg += f' with name/serial/edid/index of {display!r}'
+689        if method is not None:
+690            msg += f' with method of {method!r}'
+691        raise NoValidDisplayError(msg)
+692
+693    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:
+ +
    +
  • display (screen_brightness_control.types.DisplayIdentifier): the display you are searching for
    • +
  • haystack: the information to filter from. +If this isn't set it defaults to the return of list_monitors_info
    • +
  • method: the method the monitors use. See get_methods for +more info on available methods
    • +
  • include: extra fields of information to sort by
    • +
  • allow_duplicates: controls whether to filter out duplicate displays or not
    • +
+ +
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.24.1/screen_brightness_control/config.html b/docs/0.24.1/screen_brightness_control/config.html new file mode 100644 index 0000000..7ac6873 --- /dev/null +++ b/docs/0.24.1/screen_brightness_control/config.html @@ -0,0 +1,379 @@ + + + + + + + screen_brightness_control.config API documentation + + + + + + + + + + + + +
+
+ + +

+screen_brightness_control.config

+ +

Contains globally applicable configuration variables.

+
+ + + + + + 
 1'''
+ 2Contains globally applicable configuration variables.
+ 3'''
+ 4from functools import wraps
+ 5from typing import Callable, Optional
+ 6
+ 7
+ 8def default_params(func: Callable):
+ 9    '''
+10    This decorator sets default kwarg values using global configuration variables.
+11    '''
+12    @wraps(func)
+13    def wrapper(*args, **kwargs):
+14        kwargs.setdefault('allow_duplicates', ALLOW_DUPLICATES)
+15        kwargs.setdefault('method', METHOD)
+16        return func(*args, **kwargs)
+17    return wrapper
+18
+19
+20ALLOW_DUPLICATES: bool = False
+21'''
+22Default value for the `allow_duplicates` parameter in top-level functions.
+23'''
+24
+25METHOD: Optional[str] = None
+26'''
+27Default value for the `method` parameter in top-level functions.
+28
+29For available values, see `.get_methods`
+30'''
+
+ + +
+ +
+
+ +
+ + def + default_params(func: Callable): + + + +
+ + 
 9def default_params(func: Callable):
+10    '''
+11    This decorator sets default kwarg values using global configuration variables.
+12    '''
+13    @wraps(func)
+14    def wrapper(*args, **kwargs):
+15        kwargs.setdefault('allow_duplicates', ALLOW_DUPLICATES)
+16        kwargs.setdefault('method', METHOD)
+17        return func(*args, **kwargs)
+18    return wrapper
+
+ + +

This decorator sets default kwarg values using global configuration variables.

+
+ + +
+
+
+ ALLOW_DUPLICATES: bool = +False + + +
+ + +

Default value for the allow_duplicates parameter in top-level functions.

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

Default value for the method parameter in top-level functions.

+ +

For available values, see screen_brightness_control.get_methods

+
+ + +
+
+ + \ No newline at end of file diff --git a/docs/0.24.1/screen_brightness_control/exceptions.html b/docs/0.24.1/screen_brightness_control/exceptions.html new file mode 100644 index 0000000..2edefa0 --- /dev/null +++ b/docs/0.24.1/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.24.1/screen_brightness_control/helpers.html b/docs/0.24.1/screen_brightness_control/helpers.html new file mode 100644 index 0000000..93b17cb --- /dev/null +++ b/docs/0.24.1/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
+
+ +
+
+
+
+ +
+ + 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.24.1/screen_brightness_control/linux.html b/docs/0.24.1/screen_brightness_control/linux.html new file mode 100644 index 0000000..43cf3c1 --- /dev/null +++ b/docs/0.24.1/screen_brightness_control/linux.html @@ -0,0 +1,3825 @@ + + + + + + + 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        # map drm devices to their pci device paths
+ 46        drm_paths = {}
+ 47        for folder in glob.glob('/sys/class/drm/card*-*'):
+ 48            drm_paths[os.path.realpath(folder)] = folder
+ 49
+ 50        for subsystem in subsystems:
+ 51
+ 52            device: dict = {
+ 53                'name': subsystem[0],
+ 54                'path': f'/sys/class/backlight/{subsystem[0]}',
+ 55                'method': cls,
+ 56                'index': index,
+ 57                'model': None,
+ 58                'serial': None,
+ 59                'manufacturer': None,
+ 60                'manufacturer_id': None,
+ 61                'edid': None,
+ 62                'scale': None,
+ 63                'uid': None
+ 64            }
+ 65
+ 66            for folder in subsystem:
+ 67                # subsystems like intel_backlight usually have an acpi_video0
+ 68                # counterpart, which we don't want so lets find the 'best' candidate
+ 69                try:
+ 70                    with open(f'/sys/class/backlight/{folder}/max_brightness') as f:
+ 71                        # scale for SysFiles is just a multiplier for the set/get brightness values
+ 72                        scale = int(f.read().rstrip(' \n')) / 100
+ 73
+ 74                    # use the display with the highest resolution scale
+ 75                    if device['scale'] is None or scale > device['scale']:
+ 76                        device['name'] = folder
+ 77                        device['path'] = f'/sys/class/backlight/{folder}'
+ 78                        device['scale'] = scale
+ 79                except (FileNotFoundError, TypeError) as e:
+ 80                    cls._logger.error(
+ 81                        f'error getting highest resolution scale for {folder}'
+ 82                        f' - {format_exc(e)}'
+ 83                    )
+ 84                    continue
+ 85
+ 86                # check if backlight subsystem device matches any of the PCI devices discovered earlier
+ 87                # if so, extract the i2c bus from the drm device folder
+ 88                pci_path = os.path.realpath(f'/sys/class/backlight/{folder}/device')
+ 89                if pci_path in drm_paths:
+ 90                    device['uid'] = device['uid'] or i2c_bus_from_drm_device(drm_paths[pci_path])
+ 91
+ 92            if os.path.isfile('%s/device/edid' % device['path']):
+ 93                device['edid'] = EDID.hexdump('%s/device/edid' % device['path'])
+ 94
+ 95                for key, value in zip(
+ 96                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+ 97                    EDID.parse(device['edid'])
+ 98                ):
+ 99                    if value is None:
+100                        continue
+101                    device[key] = value
+102
+103            displays_by_edid[device['edid']] = device
+104            index += 1
+105
+106        all_displays = list(displays_by_edid.values())
+107        if display is not None:
+108            all_displays = filter_monitors(
+109                display=display, haystack=all_displays, include=['path'])
+110        return all_displays
+111
+112    @classmethod
+113    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+114        info = cls.get_display_info()
+115        if display is not None:
+116            info = [info[display]]
+117
+118        results = []
+119        for device in info:
+120            with open(os.path.join(device['path'], 'brightness'), 'r') as f:
+121                brightness = int(f.read().rstrip('\n'))
+122            results.append(int(brightness / device['scale']))
+123
+124        return results
+125
+126    @classmethod
+127    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+128        info = cls.get_display_info()
+129        if display is not None:
+130            info = [info[display]]
+131
+132        for device in info:
+133            with open(os.path.join(device['path'], 'brightness'), 'w') as f:
+134                f.write(str(int(value * device['scale'])))
+135
+136
+137class I2C(BrightnessMethod):
+138    '''
+139    In the same spirit as `SysFiles`, this class serves as a way of getting
+140    display information and adjusting the brightness without relying on any
+141    3rd party software.
+142
+143    Usage of this class requires read and write permission for `/dev/i2c-*`.
+144
+145    This class works over the I2C bus, primarily with desktop monitors as I
+146    haven't tested any e-DP displays yet.
+147
+148    Massive thanks to [siemer](https://github.com/siemer) for
+149    his work on the [ddcci.py](https://github.com/siemer/ddcci) project,
+150    which served as a my main reference for this.
+151
+152    References:
+153        * [ddcci.py](https://github.com/siemer/ddcci)
+154        * [DDCCI Spec](https://milek7.pl/ddcbacklight/ddcci.pdf)
+155    '''
+156    _logger = _logger.getChild('I2C')
+157
+158    # vcp commands
+159    GET_VCP_CMD = 0x01
+160    '''VCP command to get the value of a feature (eg: brightness)'''
+161    GET_VCP_REPLY = 0x02
+162    '''VCP feature reply op code'''
+163    SET_VCP_CMD = 0x03
+164    '''VCP command to set the value of a feature (eg: brightness)'''
+165
+166    # addresses
+167    DDCCI_ADDR = 0x37
+168    '''DDC packets are transmittred using this I2C address'''
+169    HOST_ADDR_R = 0x50
+170    '''Packet source address (the computer) when reading data'''
+171    HOST_ADDR_W = 0x51
+172    '''Packet source address (the computer) when writing data'''
+173    DESTINATION_ADDR_W = 0x6e
+174    '''Packet destination address (the monitor) when writing data'''
+175    I2C_SLAVE = 0x0703
+176    '''The I2C slave address'''
+177
+178    # timings
+179    WAIT_TIME = 0.05
+180    '''How long to wait between I2C commands'''
+181
+182    _max_brightness_cache: dict = {}
+183
+184    class I2CDevice():
+185        '''
+186        Class to read and write data to an I2C bus,
+187        based on the `I2CDev` class from [ddcci.py](https://github.com/siemer/ddcci)
+188        '''
+189
+190        def __init__(self, fname: str, slave_addr: int):
+191            '''
+192            Args:
+193                fname: the I2C path, eg: `/dev/i2c-2`
+194                slave_addr: not entirely sure what this is meant to be
+195            '''
+196            self.device = os.open(fname, os.O_RDWR)
+197            # I2C_SLAVE address setup
+198            fcntl.ioctl(self.device, I2C.I2C_SLAVE, slave_addr)
+199
+200        def read(self, length: int) -> bytes:
+201            '''
+202            Read a certain number of bytes from the I2C bus
+203
+204            Args:
+205                length: the number of bytes to read
+206
+207            Returns:
+208                bytes
+209            '''
+210            return os.read(self.device, length)
+211
+212        def write(self, data: bytes) -> int:
+213            '''
+214            Writes data to the I2C bus
+215
+216            Args:
+217                data: the data to write
+218
+219            Returns:
+220                The number of bytes written
+221            '''
+222            return os.write(self.device, data)
+223
+224    class DDCInterface(I2CDevice):
+225        '''
+226        Class to send DDC (Display Data Channel) commands to an I2C device,
+227        based on the `Ddcci` and `Mccs` classes from [ddcci.py](https://github.com/siemer/ddcci)
+228        '''
+229
+230        PROTOCOL_FLAG = 0x80
+231
+232        def __init__(self, i2c_path: str):
+233            '''
+234            Args:
+235                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+236            '''
+237            self.logger = _logger.getChild(
+238                self.__class__.__name__).getChild(i2c_path)
+239            super().__init__(i2c_path, I2C.DDCCI_ADDR)
+240
+241        def write(self, *args) -> int:
+242            '''
+243            Write some data to the I2C device.
+244
+245            It is recommended to use `setvcp` to set VCP values on the DDC device
+246            instead of using this function directly.
+247
+248            Args:
+249                *args: variable length list of arguments. This will be put
+250                    into a `bytearray` and wrapped up in various flags and
+251                    checksums before being written to the I2C device
+252
+253            Returns:
+254                The number of bytes that were written
+255            '''
+256            time.sleep(I2C.WAIT_TIME)
+257
+258            ba = bytearray(args)
+259            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+260            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+261            ba.append(functools.reduce(operator.xor, ba,
+262                      I2C.DESTINATION_ADDR_W))  # checksum
+263
+264            return super().write(ba)
+265
+266        def setvcp(self, vcp_code: int, value: int) -> int:
+267            '''
+268            Set a VCP value on the device
+269
+270            Args:
+271                vcp_code: the VCP command to send, eg: `0x10` is brightness
+272                value: what to set the value to
+273
+274            Returns:
+275                The number of bytes written to the device
+276            '''
+277            return self.write(I2C.SET_VCP_CMD, vcp_code, *value.to_bytes(2, 'big'))
+278
+279        def read(self, amount: int) -> bytes:
+280            '''
+281            Reads data from the DDC device.
+282
+283            It is recommended to use `getvcp` to retrieve VCP values from the
+284            DDC device instead of using this function directly.
+285
+286            Args:
+287                amount: the number of bytes to read
+288
+289            Raises:
+290                ValueError: if the read data is deemed invalid
+291            '''
+292            time.sleep(I2C.WAIT_TIME)
+293
+294            ba = super().read(amount + 3)
+295
+296            # check the bytes read
+297            checks = {
+298                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+299                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+300                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+301            }
+302            if False in checks.values():
+303                self.logger.error('i2c read check failed: ' + repr(checks))
+304                raise I2CValidationError(
+305                    'i2c read check failed: ' + repr(checks))
+306
+307            return ba[2:-1]
+308
+309        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+310            '''
+311            Retrieves a VCP value from the DDC device.
+312
+313            Args:
+314                vcp_code: the VCP value to read, eg: `0x10` is brightness
+315
+316            Returns:
+317                The current and maximum value respectively
+318
+319            Raises:
+320                ValueError: if the read data is deemed invalid
+321            '''
+322            self.write(I2C.GET_VCP_CMD, vcp_code)
+323            ba = self.read(8)
+324
+325            checks = {
+326                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+327                'supported VCP opcode': ba[1] == 0,
+328                'answer matches request': ba[2] == vcp_code
+329            }
+330            if False in checks.values():
+331                self.logger.error('i2c read check failed: ' + repr(checks))
+332                raise I2CValidationError(
+333                    'i2c read check failed: ' + repr(checks))
+334
+335            # current and max values
+336            return int.from_bytes(ba[6:8], 'big'), int.from_bytes(ba[4:6], 'big')
+337
+338    @classmethod
+339    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+340        all_displays = __cache__.get('i2c_display_info')
+341        if all_displays is None:
+342            all_displays = []
+343            index = 0
+344
+345            for i2c_path in glob.glob('/dev/i2c-*'):
+346                if not os.path.exists(i2c_path):
+347                    continue
+348
+349                try:
+350                    # open the I2C device using the host read address
+351                    device = cls.I2CDevice(i2c_path, cls.HOST_ADDR_R)
+352                    # read some 512 bytes from the device
+353                    data = device.read(512)
+354                except IOError as e:
+355                    cls._logger.error(
+356                        f'IOError reading from device {i2c_path}: {e}')
+357                    continue
+358
+359                # search for the EDID header within our 512 read bytes
+360                start = data.find(bytes.fromhex('00 FF FF FF FF FF FF 00'))
+361                if start < 0:
+362                    continue
+363
+364                # grab 128 bytes of the edid
+365                edid = data[start: start + 128]
+366                # parse the EDID
+367                (
+368                    manufacturer_id,
+369                    manufacturer,
+370                    model,
+371                    name,
+372                    serial
+373                ) = EDID.parse(edid)
+374
+375                all_displays.append(
+376                    {
+377                        'name': name,
+378                        'model': model,
+379                        'manufacturer': manufacturer,
+380                        'manufacturer_id': manufacturer_id,
+381                        'serial': serial,
+382                        'method': cls,
+383                        'index': index,
+384                        # convert edid to hex string
+385                        'edid': ''.join(f'{i:02x}' for i in edid),
+386                        'i2c_bus': i2c_path,
+387                        'uid': i2c_path.split('-')[-1]
+388                    }
+389                )
+390                index += 1
+391
+392            if all_displays:
+393                __cache__.store('i2c_display_info', all_displays, expires=2)
+394
+395        if display is not None:
+396            return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+397        return all_displays
+398
+399    @classmethod
+400    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+401        all_displays = cls.get_display_info()
+402        if display is not None:
+403            all_displays = [all_displays[display]]
+404
+405        results = []
+406        for device in all_displays:
+407            interface = cls.DDCInterface(device['i2c_bus'])
+408            value, max_value = interface.getvcp(0x10)
+409
+410            # make sure display's max brighness is cached
+411            cache_ident = '%s-%s-%s' % (device['name'],
+412                                        device['model'], device['serial'])
+413            if cache_ident not in cls._max_brightness_cache:
+414                cls._max_brightness_cache[cache_ident] = max_value
+415                cls._logger.info(
+416                    f'{cache_ident} max brightness:{max_value} (current: {value})')
+417
+418            if max_value != 100:
+419                # if max value is not 100 then we have to adjust the scale to be
+420                # a percentage
+421                value = int((value / max_value) * 100)
+422
+423            results.append(value)
+424
+425        return results
+426
+427    @classmethod
+428    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+429        all_displays = cls.get_display_info()
+430        if display is not None:
+431            all_displays = [all_displays[display]]
+432
+433        for device in all_displays:
+434            # make sure display brightness max value is cached
+435            cache_ident = '%s-%s-%s' % (device['name'],
+436                                        device['model'], device['serial'])
+437            if cache_ident not in cls._max_brightness_cache:
+438                cls.get_brightness(display=device['index'])
+439
+440            # scale the brightness value according to the max brightness
+441            max_value = cls._max_brightness_cache[cache_ident]
+442            if max_value != 100:
+443                value = int((value / 100) * max_value)
+444
+445            interface = cls.DDCInterface(device['i2c_bus'])
+446            interface.setvcp(0x10, value)
+447
+448
+449class XRandr(BrightnessMethodAdv):
+450    '''collection of screen brightness related methods using the xrandr executable'''
+451
+452    executable: str = 'xrandr'
+453    '''the xrandr executable to be called'''
+454
+455    @staticmethod
+456    def _get_uid(interface: str) -> Optional[str]:
+457        '''
+458        Attempts to find a UID (I2C bus path) for a given display interface.
+459
+460        This works by parsing the interface name and matching it up to the entries in `/sys/class/drm`.
+461        `i2c_bus_from_drm_device` is then used to extract the bus number
+462
+463        Args:
+464            interface: the interface in question. EG: `eDP-1`, `eDP1`, `HDMI-1`...
+465
+466        Returns:
+467            The bus number as a string if found. Otherwise, none.
+468        '''
+469        if not os.path.isdir('/sys/class/drm'):
+470            return None
+471
+472        # use regex because sometimes it can be `eDP-1` and sometimes it's `eDP1`
+473        if interface_match := re.match(r'([a-z]+)-?(\d+)', interface, re.I):
+474            interface, count = interface_match.groups()
+475        else:
+476            return None
+477
+478        for dir in os.listdir('/sys/class/drm/'):
+479            # use regex here for case insensitivity on the interface
+480            if not re.match(r'card\d+-%s(?:-[A-Z])?-%s' % (interface, count), dir, re.I):
+481                continue
+482            dir = f'/sys/class/drm/{dir}'
+483            if bus := i2c_bus_from_drm_device(dir):
+484                return bus
+485
+486    @classmethod
+487    def _gdi(cls):
+488        '''
+489        .. warning:: Don't use this
+490           This function isn't final and I will probably make breaking changes to it.
+491           You have been warned
+492
+493        Gets all displays reported by XRandr even if they're not supported
+494        '''
+495        xrandr_output = check_output(
+496            [cls.executable, '--verbose']).decode().split('\n')
+497
+498        display_count = 0
+499        tmp_display: dict = {}
+500
+501        for line_index, line in enumerate(xrandr_output):
+502            if line == '':
+503                continue
+504
+505            if not line.startswith((' ', '\t')) and 'connected' in line and 'disconnected' not in line:
+506                if tmp_display:
+507                    yield tmp_display
+508
+509                tmp_display = {
+510                    'name': line.split(' ')[0],
+511                    'interface': line.split(' ')[0],
+512                    'method': cls,
+513                    'index': display_count,
+514                    'model': None,
+515                    'serial': None,
+516                    'manufacturer': None,
+517                    'manufacturer_id': None,
+518                    'edid': None,
+519                    'unsupported': line.startswith('XWAYLAND') or 'WAYLAND_DISPLAY' in os.environ,
+520                    'uid': cls._get_uid(line.split(' ')[0])
+521                }
+522                display_count += 1
+523
+524            elif 'EDID:' in line:
+525                # extract the edid from the chunk of the output that will contain the edid
+526                edid = ''.join(
+527                    i.replace('\t', '').replace(' ', '') for i in xrandr_output[line_index + 1: line_index + 9]
+528                )
+529                tmp_display['edid'] = edid
+530
+531                for key, value in zip(
+532                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+533                    EDID.parse(tmp_display['edid'])
+534                ):
+535                    if value is None:
+536                        continue
+537                    tmp_display[key] = value
+538
+539            elif 'Brightness:' in line:
+540                tmp_display['brightness'] = int(
+541                    float(line.replace('Brightness:', '')) * 100)
+542
+543        if tmp_display:
+544            yield tmp_display
+545
+546    @classmethod
+547    def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+548        '''
+549        Implements `BrightnessMethod.get_display_info`.
+550
+551        Args:
+552            display: the index of the specific display to query.
+553                If unspecified, all detected displays are queried
+554            brightness: whether to include the current brightness
+555                in the returned info
+556        '''
+557        valid_displays = []
+558        for item in cls._gdi():
+559            if item['unsupported']:
+560                continue
+561            if not brightness:
+562                del item['brightness']
+563            del item['unsupported']
+564            valid_displays.append(item)
+565        if display is not None:
+566            valid_displays = filter_monitors(
+567                display=display, haystack=valid_displays, include=['interface'])
+568        return valid_displays
+569
+570    @classmethod
+571    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+572        monitors = cls.get_display_info(brightness=True)
+573        if display is not None:
+574            monitors = [monitors[display]]
+575        brightness = [i['brightness'] for i in monitors]
+576
+577        return brightness
+578
+579    @classmethod
+580    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+581        value_as_str = str(float(value) / 100)
+582        info = cls.get_display_info()
+583        if display is not None:
+584            info = [info[display]]
+585
+586        for i in info:
+587            check_output([cls.executable, '--output',
+588                         i['interface'], '--brightness', value_as_str])
+589
+590
+591class DDCUtil(BrightnessMethodAdv):
+592    '''collection of screen brightness related methods using the ddcutil executable'''
+593    _logger = _logger.getChild('DDCUtil')
+594
+595    executable: str = 'ddcutil'
+596    '''The ddcutil executable to be called'''
+597    sleep_multiplier: float = 0.5
+598    '''
+599    How long ddcutil should sleep between each DDC request (lower is shorter).
+600    See [the ddcutil docs](https://www.ddcutil.com/performance_options/#option-sleep-multiplier).
+601    '''
+602    cmd_max_tries: int = 10
+603    '''Max number of retries when calling the ddcutil'''
+604    enable_async = True
+605    '''
+606    Use the `--async` flag when calling ddcutil.
+607    See [ddcutil docs](https://www.ddcutil.com/performance_options/#option-async)
+608    '''
+609    _max_brightness_cache: dict = {}
+610    '''Cache for displays and their maximum brightness values'''
+611
+612    @classmethod
+613    def _gdi(cls):
+614        '''
+615        .. warning:: Don't use this
+616           This function isn't final and I will probably make breaking changes to it.
+617           You have been warned
+618
+619        Gets all displays reported by DDCUtil even if they're not supported
+620        '''
+621        raw_ddcutil_output = str(
+622            check_output(
+623                [
+624                    cls.executable, 'detect', '-v',
+625                    f'--sleep-multiplier={cls.sleep_multiplier}'
+626                ] + ['--async'] if cls.enable_async else [], max_tries=cls.cmd_max_tries
+627            )
+628        )[2:-1].split('\\n')
+629        # Use -v to get EDID string but this means output cannot be decoded.
+630        # Or maybe it can. I don't know the encoding though, so let's assume it cannot be decoded.
+631        # Use str()[2:-1] workaround
+632
+633        # include "Invalid display" sections because they tell us where one displays metadata ends
+634        # and another begins. We filter out invalid displays later on
+635        ddcutil_output = [i for i in raw_ddcutil_output if i.startswith(
+636            ('Invalid display', 'Display', '\t', ' '))]
+637        tmp_display: dict = {}
+638        display_count = 0
+639
+640        for line_index, line in enumerate(ddcutil_output):
+641            if not line.startswith(('\t', ' ')):
+642                if tmp_display:
+643                    yield tmp_display
+644
+645                tmp_display = {
+646                    'method': cls,
+647                    'index': display_count,
+648                    'model': None,
+649                    'serial': None,
+650                    'bin_serial': None,
+651                    'manufacturer': None,
+652                    'manufacturer_id': None,
+653                    'edid': None,
+654                    'unsupported': 'invalid display' in line.lower(),
+655                    'uid': None
+656                }
+657                display_count += 1
+658
+659            elif 'I2C bus' in line:
+660                tmp_display['i2c_bus'] = line[line.index('/'):]
+661                tmp_display['bus_number'] = int(
+662                    tmp_display['i2c_bus'].replace('/dev/i2c-', ''))
+663                tmp_display['uid'] = tmp_display['i2c_bus'].split('-')[-1]
+664
+665            elif 'Mfg id' in line:
+666                # Recently ddcutil has started reporting manufacturer IDs like
+667                # 'BNQ - UNK' or 'MSI - Microstep' so we have to split the line
+668                # into chunks of alpha chars and check for a valid mfg id
+669                for code in re.split(r'[^A-Za-z]', line.replace('Mfg id:', '').replace(' ', '')):
+670                    if len(code) != 3:
+671                        # all mfg ids are 3 chars long
+672                        continue
+673
+674                    if (brand := _monitor_brand_lookup(code)):
+675                        tmp_display['manufacturer_id'], tmp_display['manufacturer'] = brand
+676                        break
+677
+678            elif 'Model' in line:
+679                # the split() removes extra spaces
+680                name = line.replace('Model:', '').split()
+681                try:
+682                    tmp_display['model'] = name[1]
+683                except IndexError:
+684                    pass
+685                tmp_display['name'] = ' '.join(name)
+686
+687            elif 'Serial number' in line:
+688                tmp_display['serial'] = line.replace(
+689                    'Serial number:', '').replace(' ', '') or None
+690
+691            elif 'Binary serial number:' in line:
+692                tmp_display['bin_serial'] = line.split(' ')[-1][3:-1]
+693
+694            elif 'EDID hex dump:' in line:
+695                try:
+696                    tmp_display['edid'] = ''.join(
+697                        ''.join(i.split()[1:17]) for i in ddcutil_output[line_index + 2: line_index + 10]
+698                    )
+699                except Exception:
+700                    pass
+701
+702        if tmp_display:
+703            yield tmp_display
+704
+705    @classmethod
+706    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+707        valid_displays = __cache__.get('ddcutil_monitors_info')
+708        if valid_displays is None:
+709            valid_displays = []
+710            for item in cls._gdi():
+711                if item['unsupported']:
+712                    continue
+713                del item['unsupported']
+714                valid_displays.append(item)
+715
+716            if valid_displays:
+717                __cache__.store('ddcutil_monitors_info', valid_displays)
+718
+719        if display is not None:
+720            valid_displays = filter_monitors(
+721                display=display, haystack=valid_displays, include=['i2c_bus'])
+722        return valid_displays
+723
+724    @classmethod
+725    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+726        monitors = cls.get_display_info()
+727        if display is not None:
+728            monitors = [monitors[display]]
+729
+730        res = []
+731        for monitor in monitors:
+732            value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+733            if value is None:
+734                cmd_out = check_output(
+735                    [
+736                        cls.executable,
+737                        'getvcp', '10', '-t',
+738                        '-b', str(monitor['bus_number']),
+739                        f'--sleep-multiplier={cls.sleep_multiplier}'
+740                    ], max_tries=cls.cmd_max_tries
+741                ).decode().split(' ')
+742
+743                value = int(cmd_out[-2])
+744                max_value = int(cmd_out[-1])
+745                if max_value != 100:
+746                    # if the max brightness is not 100 then the number is not a percentage
+747                    # and will need to be scaled
+748                    value = int((value / max_value) * 100)
+749
+750                # now make sure max brightness is recorded so set_brightness can use it
+751                cache_ident = '%s-%s-%s' % (monitor['name'],
+752                                            monitor['serial'], monitor['bin_serial'])
+753                if cache_ident not in cls._max_brightness_cache:
+754                    cls._max_brightness_cache[cache_ident] = max_value
+755                    cls._logger.debug(
+756                        f'{cache_ident} max brightness:{max_value} (current: {value})')
+757
+758                __cache__.store(
+759                    f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+760            res.append(value)
+761        return res
+762
+763    @classmethod
+764    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+765        monitors = cls.get_display_info()
+766        if display is not None:
+767            monitors = [monitors[display]]
+768
+769        __cache__.expire(startswith='ddcutil_brightness_')
+770        for monitor in monitors:
+771            # check if monitor has a max brightness that requires us to scale this value
+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.get_brightness(display=monitor['index'])
+776
+777            if cls._max_brightness_cache[cache_ident] != 100:
+778                value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+779
+780            check_output(
+781                [
+782                    cls.executable, 'setvcp', '10', str(value),
+783                    '-b', str(monitor['bus_number']),
+784                    f'--sleep-multiplier={cls.sleep_multiplier}'
+785                ], max_tries=cls.cmd_max_tries
+786            )
+787
+788
+789def i2c_bus_from_drm_device(dir: str) -> Optional[str]:
+790    '''
+791    Extract the relevant I2C bus number from a device in `/sys/class/drm`.
+792
+793    This function works by searching the directory for `i2c-*` and `ddc/i2c-dev/i2c-*` folders.
+794
+795    Args:
+796        dir: the DRM directory, in the format `/sys/class/drm/<device>`
+797
+798    Returns:
+799        Returns the I2C bus number as a string if found. Otherwise, returns None
+800    '''
+801    # check for enabled file and skip device if monitor inactive
+802    if os.path.isfile(f'{dir}/enabled'):
+803        with open(f'{dir}/enabled') as f:
+804            if f.read().strip().lower() != 'enabled':
+805                return
+806
+807    # sometimes the i2c path is in /sys/class/drm/*/i2c-*
+808    # do this first because, in my testing, sometimes a device can have both `.../i2c-X` and `.../ddc/i2c-dev/...`
+809    # and the latter is usually the wrong i2c path
+810    paths = glob.glob(f'{dir}/i2c-*')
+811    if paths:
+812        return paths[0].split('-')[-1]
+813
+814    # sometimes the i2c path is in /sys/class/drm/*/ddc/i2c-dev
+815    if os.path.isdir(f'{dir}/ddc/i2c-dev'):
+816        paths = os.listdir(f'{dir}/ddc/i2c-dev')
+817        if paths:
+818            return paths[0].replace('i2c-', '')
+819
+820
+821def list_monitors_info(
+822    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+823) -> List[dict]:
+824    '''
+825    Lists detailed information about all detected displays
+826
+827    Args:
+828        method: the method the display can be addressed by. See `.get_methods`
+829            for more info on available methods
+830        allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+831        unsupported: include detected displays that are invalid or unsupported
+832    '''
+833    all_methods = get_methods(method).values()
+834    haystack = []
+835    for method_class in all_methods:
+836        try:
+837            if unsupported and issubclass(method_class, BrightnessMethodAdv):
+838                haystack += method_class._gdi()
+839            else:
+840                haystack += method_class.get_display_info()
+841        except Exception as e:
+842            _logger.warning(
+843                f'error grabbing display info from {method_class} - {format_exc(e)}')
+844            pass
+845
+846    if allow_duplicates:
+847        return haystack
+848
+849    try:
+850        # use filter_monitors to remove duplicates
+851        return filter_monitors(haystack=haystack)
+852    except NoValidDisplayError:
+853        return []
+854
+855
+856METHODS = (SysFiles, I2C, XRandr, DDCUtil)
+
+ + +
+ +
+
+ +
+ + 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        # map drm devices to their pci device paths
+ 47        drm_paths = {}
+ 48        for folder in glob.glob('/sys/class/drm/card*-*'):
+ 49            drm_paths[os.path.realpath(folder)] = folder
+ 50
+ 51        for subsystem in subsystems:
+ 52
+ 53            device: dict = {
+ 54                'name': subsystem[0],
+ 55                'path': f'/sys/class/backlight/{subsystem[0]}',
+ 56                'method': cls,
+ 57                'index': index,
+ 58                'model': None,
+ 59                'serial': None,
+ 60                'manufacturer': None,
+ 61                'manufacturer_id': None,
+ 62                'edid': None,
+ 63                'scale': None,
+ 64                'uid': None
+ 65            }
+ 66
+ 67            for folder in subsystem:
+ 68                # subsystems like intel_backlight usually have an acpi_video0
+ 69                # counterpart, which we don't want so lets find the 'best' candidate
+ 70                try:
+ 71                    with open(f'/sys/class/backlight/{folder}/max_brightness') as f:
+ 72                        # scale for SysFiles is just a multiplier for the set/get brightness values
+ 73                        scale = int(f.read().rstrip(' \n')) / 100
+ 74
+ 75                    # use the display with the highest resolution scale
+ 76                    if device['scale'] is None or scale > device['scale']:
+ 77                        device['name'] = folder
+ 78                        device['path'] = f'/sys/class/backlight/{folder}'
+ 79                        device['scale'] = scale
+ 80                except (FileNotFoundError, TypeError) as e:
+ 81                    cls._logger.error(
+ 82                        f'error getting highest resolution scale for {folder}'
+ 83                        f' - {format_exc(e)}'
+ 84                    )
+ 85                    continue
+ 86
+ 87                # check if backlight subsystem device matches any of the PCI devices discovered earlier
+ 88                # if so, extract the i2c bus from the drm device folder
+ 89                pci_path = os.path.realpath(f'/sys/class/backlight/{folder}/device')
+ 90                if pci_path in drm_paths:
+ 91                    device['uid'] = device['uid'] or i2c_bus_from_drm_device(drm_paths[pci_path])
+ 92
+ 93            if os.path.isfile('%s/device/edid' % device['path']):
+ 94                device['edid'] = EDID.hexdump('%s/device/edid' % device['path'])
+ 95
+ 96                for key, value in zip(
+ 97                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+ 98                    EDID.parse(device['edid'])
+ 99                ):
+100                    if value is None:
+101                        continue
+102                    device[key] = value
+103
+104            displays_by_edid[device['edid']] = device
+105            index += 1
+106
+107        all_displays = list(displays_by_edid.values())
+108        if display is not None:
+109            all_displays = filter_monitors(
+110                display=display, haystack=all_displays, include=['path'])
+111        return all_displays
+112
+113    @classmethod
+114    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+115        info = cls.get_display_info()
+116        if display is not None:
+117            info = [info[display]]
+118
+119        results = []
+120        for device in info:
+121            with open(os.path.join(device['path'], 'brightness'), 'r') as f:
+122                brightness = int(f.read().rstrip('\n'))
+123            results.append(int(brightness / device['scale']))
+124
+125        return results
+126
+127    @classmethod
+128    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+129        info = cls.get_display_info()
+130        if display is not None:
+131            info = [info[display]]
+132
+133        for device in info:
+134            with open(os.path.join(device['path'], 'brightness'), 'w') as f:
+135                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        # map drm devices to their pci device paths
+ 47        drm_paths = {}
+ 48        for folder in glob.glob('/sys/class/drm/card*-*'):
+ 49            drm_paths[os.path.realpath(folder)] = folder
+ 50
+ 51        for subsystem in subsystems:
+ 52
+ 53            device: dict = {
+ 54                'name': subsystem[0],
+ 55                'path': f'/sys/class/backlight/{subsystem[0]}',
+ 56                'method': cls,
+ 57                'index': index,
+ 58                'model': None,
+ 59                'serial': None,
+ 60                'manufacturer': None,
+ 61                'manufacturer_id': None,
+ 62                'edid': None,
+ 63                'scale': None,
+ 64                'uid': None
+ 65            }
+ 66
+ 67            for folder in subsystem:
+ 68                # subsystems like intel_backlight usually have an acpi_video0
+ 69                # counterpart, which we don't want so lets find the 'best' candidate
+ 70                try:
+ 71                    with open(f'/sys/class/backlight/{folder}/max_brightness') as f:
+ 72                        # scale for SysFiles is just a multiplier for the set/get brightness values
+ 73                        scale = int(f.read().rstrip(' \n')) / 100
+ 74
+ 75                    # use the display with the highest resolution scale
+ 76                    if device['scale'] is None or scale > device['scale']:
+ 77                        device['name'] = folder
+ 78                        device['path'] = f'/sys/class/backlight/{folder}'
+ 79                        device['scale'] = scale
+ 80                except (FileNotFoundError, TypeError) as e:
+ 81                    cls._logger.error(
+ 82                        f'error getting highest resolution scale for {folder}'
+ 83                        f' - {format_exc(e)}'
+ 84                    )
+ 85                    continue
+ 86
+ 87                # check if backlight subsystem device matches any of the PCI devices discovered earlier
+ 88                # if so, extract the i2c bus from the drm device folder
+ 89                pci_path = os.path.realpath(f'/sys/class/backlight/{folder}/device')
+ 90                if pci_path in drm_paths:
+ 91                    device['uid'] = device['uid'] or i2c_bus_from_drm_device(drm_paths[pci_path])
+ 92
+ 93            if os.path.isfile('%s/device/edid' % device['path']):
+ 94                device['edid'] = EDID.hexdump('%s/device/edid' % device['path'])
+ 95
+ 96                for key, value in zip(
+ 97                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+ 98                    EDID.parse(device['edid'])
+ 99                ):
+100                    if value is None:
+101                        continue
+102                    device[key] = value
+103
+104            displays_by_edid[device['edid']] = device
+105            index += 1
+106
+107        all_displays = list(displays_by_edid.values())
+108        if display is not None:
+109            all_displays = filter_monitors(
+110                display=display, haystack=all_displays, include=['path'])
+111        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]: + + + +
+ + 
113    @classmethod
+114    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+115        info = cls.get_display_info()
+116        if display is not None:
+117            info = [info[display]]
+118
+119        results = []
+120        for device in info:
+121            with open(os.path.join(device['path'], 'brightness'), 'r') as f:
+122                brightness = int(f.read().rstrip('\n'))
+123            results.append(int(brightness / device['scale']))
+124
+125        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): + + + +
+ + 
127    @classmethod
+128    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+129        info = cls.get_display_info()
+130        if display is not None:
+131            info = [info[display]]
+132
+133        for device in info:
+134            with open(os.path.join(device['path'], 'brightness'), 'w') as f:
+135                f.write(str(int(value * device['scale'])))
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + class + I2C(screen_brightness_control.helpers.BrightnessMethod): + + + +
+ + 
138class I2C(BrightnessMethod):
+139    '''
+140    In the same spirit as `SysFiles`, this class serves as a way of getting
+141    display information and adjusting the brightness without relying on any
+142    3rd party software.
+143
+144    Usage of this class requires read and write permission for `/dev/i2c-*`.
+145
+146    This class works over the I2C bus, primarily with desktop monitors as I
+147    haven't tested any e-DP displays yet.
+148
+149    Massive thanks to [siemer](https://github.com/siemer) for
+150    his work on the [ddcci.py](https://github.com/siemer/ddcci) project,
+151    which served as a my main reference for this.
+152
+153    References:
+154        * [ddcci.py](https://github.com/siemer/ddcci)
+155        * [DDCCI Spec](https://milek7.pl/ddcbacklight/ddcci.pdf)
+156    '''
+157    _logger = _logger.getChild('I2C')
+158
+159    # vcp commands
+160    GET_VCP_CMD = 0x01
+161    '''VCP command to get the value of a feature (eg: brightness)'''
+162    GET_VCP_REPLY = 0x02
+163    '''VCP feature reply op code'''
+164    SET_VCP_CMD = 0x03
+165    '''VCP command to set the value of a feature (eg: brightness)'''
+166
+167    # addresses
+168    DDCCI_ADDR = 0x37
+169    '''DDC packets are transmittred using this I2C address'''
+170    HOST_ADDR_R = 0x50
+171    '''Packet source address (the computer) when reading data'''
+172    HOST_ADDR_W = 0x51
+173    '''Packet source address (the computer) when writing data'''
+174    DESTINATION_ADDR_W = 0x6e
+175    '''Packet destination address (the monitor) when writing data'''
+176    I2C_SLAVE = 0x0703
+177    '''The I2C slave address'''
+178
+179    # timings
+180    WAIT_TIME = 0.05
+181    '''How long to wait between I2C commands'''
+182
+183    _max_brightness_cache: dict = {}
+184
+185    class I2CDevice():
+186        '''
+187        Class to read and write data to an I2C bus,
+188        based on the `I2CDev` class from [ddcci.py](https://github.com/siemer/ddcci)
+189        '''
+190
+191        def __init__(self, fname: str, slave_addr: int):
+192            '''
+193            Args:
+194                fname: the I2C path, eg: `/dev/i2c-2`
+195                slave_addr: not entirely sure what this is meant to be
+196            '''
+197            self.device = os.open(fname, os.O_RDWR)
+198            # I2C_SLAVE address setup
+199            fcntl.ioctl(self.device, I2C.I2C_SLAVE, slave_addr)
+200
+201        def read(self, length: int) -> bytes:
+202            '''
+203            Read a certain number of bytes from the I2C bus
+204
+205            Args:
+206                length: the number of bytes to read
+207
+208            Returns:
+209                bytes
+210            '''
+211            return os.read(self.device, length)
+212
+213        def write(self, data: bytes) -> int:
+214            '''
+215            Writes data to the I2C bus
+216
+217            Args:
+218                data: the data to write
+219
+220            Returns:
+221                The number of bytes written
+222            '''
+223            return os.write(self.device, data)
+224
+225    class DDCInterface(I2CDevice):
+226        '''
+227        Class to send DDC (Display Data Channel) commands to an I2C device,
+228        based on the `Ddcci` and `Mccs` classes from [ddcci.py](https://github.com/siemer/ddcci)
+229        '''
+230
+231        PROTOCOL_FLAG = 0x80
+232
+233        def __init__(self, i2c_path: str):
+234            '''
+235            Args:
+236                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+237            '''
+238            self.logger = _logger.getChild(
+239                self.__class__.__name__).getChild(i2c_path)
+240            super().__init__(i2c_path, I2C.DDCCI_ADDR)
+241
+242        def write(self, *args) -> int:
+243            '''
+244            Write some data to the I2C device.
+245
+246            It is recommended to use `setvcp` to set VCP values on the DDC device
+247            instead of using this function directly.
+248
+249            Args:
+250                *args: variable length list of arguments. This will be put
+251                    into a `bytearray` and wrapped up in various flags and
+252                    checksums before being written to the I2C device
+253
+254            Returns:
+255                The number of bytes that were written
+256            '''
+257            time.sleep(I2C.WAIT_TIME)
+258
+259            ba = bytearray(args)
+260            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+261            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+262            ba.append(functools.reduce(operator.xor, ba,
+263                      I2C.DESTINATION_ADDR_W))  # checksum
+264
+265            return super().write(ba)
+266
+267        def setvcp(self, vcp_code: int, value: int) -> int:
+268            '''
+269            Set a VCP value on the device
+270
+271            Args:
+272                vcp_code: the VCP command to send, eg: `0x10` is brightness
+273                value: what to set the value to
+274
+275            Returns:
+276                The number of bytes written to the device
+277            '''
+278            return self.write(I2C.SET_VCP_CMD, vcp_code, *value.to_bytes(2, 'big'))
+279
+280        def read(self, amount: int) -> bytes:
+281            '''
+282            Reads data from the DDC device.
+283
+284            It is recommended to use `getvcp` to retrieve VCP values from the
+285            DDC device instead of using this function directly.
+286
+287            Args:
+288                amount: the number of bytes to read
+289
+290            Raises:
+291                ValueError: if the read data is deemed invalid
+292            '''
+293            time.sleep(I2C.WAIT_TIME)
+294
+295            ba = super().read(amount + 3)
+296
+297            # check the bytes read
+298            checks = {
+299                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+300                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+301                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+302            }
+303            if False in checks.values():
+304                self.logger.error('i2c read check failed: ' + repr(checks))
+305                raise I2CValidationError(
+306                    'i2c read check failed: ' + repr(checks))
+307
+308            return ba[2:-1]
+309
+310        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+311            '''
+312            Retrieves a VCP value from the DDC device.
+313
+314            Args:
+315                vcp_code: the VCP value to read, eg: `0x10` is brightness
+316
+317            Returns:
+318                The current and maximum value respectively
+319
+320            Raises:
+321                ValueError: if the read data is deemed invalid
+322            '''
+323            self.write(I2C.GET_VCP_CMD, vcp_code)
+324            ba = self.read(8)
+325
+326            checks = {
+327                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+328                'supported VCP opcode': ba[1] == 0,
+329                'answer matches request': ba[2] == vcp_code
+330            }
+331            if False in checks.values():
+332                self.logger.error('i2c read check failed: ' + repr(checks))
+333                raise I2CValidationError(
+334                    'i2c read check failed: ' + repr(checks))
+335
+336            # current and max values
+337            return int.from_bytes(ba[6:8], 'big'), int.from_bytes(ba[4:6], 'big')
+338
+339    @classmethod
+340    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+341        all_displays = __cache__.get('i2c_display_info')
+342        if all_displays is None:
+343            all_displays = []
+344            index = 0
+345
+346            for i2c_path in glob.glob('/dev/i2c-*'):
+347                if not os.path.exists(i2c_path):
+348                    continue
+349
+350                try:
+351                    # open the I2C device using the host read address
+352                    device = cls.I2CDevice(i2c_path, cls.HOST_ADDR_R)
+353                    # read some 512 bytes from the device
+354                    data = device.read(512)
+355                except IOError as e:
+356                    cls._logger.error(
+357                        f'IOError reading from device {i2c_path}: {e}')
+358                    continue
+359
+360                # search for the EDID header within our 512 read bytes
+361                start = data.find(bytes.fromhex('00 FF FF FF FF FF FF 00'))
+362                if start < 0:
+363                    continue
+364
+365                # grab 128 bytes of the edid
+366                edid = data[start: start + 128]
+367                # parse the EDID
+368                (
+369                    manufacturer_id,
+370                    manufacturer,
+371                    model,
+372                    name,
+373                    serial
+374                ) = EDID.parse(edid)
+375
+376                all_displays.append(
+377                    {
+378                        'name': name,
+379                        'model': model,
+380                        'manufacturer': manufacturer,
+381                        'manufacturer_id': manufacturer_id,
+382                        'serial': serial,
+383                        'method': cls,
+384                        'index': index,
+385                        # convert edid to hex string
+386                        'edid': ''.join(f'{i:02x}' for i in edid),
+387                        'i2c_bus': i2c_path,
+388                        'uid': i2c_path.split('-')[-1]
+389                    }
+390                )
+391                index += 1
+392
+393            if all_displays:
+394                __cache__.store('i2c_display_info', all_displays, expires=2)
+395
+396        if display is not None:
+397            return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+398        return all_displays
+399
+400    @classmethod
+401    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+402        all_displays = cls.get_display_info()
+403        if display is not None:
+404            all_displays = [all_displays[display]]
+405
+406        results = []
+407        for device in all_displays:
+408            interface = cls.DDCInterface(device['i2c_bus'])
+409            value, max_value = interface.getvcp(0x10)
+410
+411            # make sure display's max brighness is cached
+412            cache_ident = '%s-%s-%s' % (device['name'],
+413                                        device['model'], device['serial'])
+414            if cache_ident not in cls._max_brightness_cache:
+415                cls._max_brightness_cache[cache_ident] = max_value
+416                cls._logger.info(
+417                    f'{cache_ident} max brightness:{max_value} (current: {value})')
+418
+419            if max_value != 100:
+420                # if max value is not 100 then we have to adjust the scale to be
+421                # a percentage
+422                value = int((value / max_value) * 100)
+423
+424            results.append(value)
+425
+426        return results
+427
+428    @classmethod
+429    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+430        all_displays = cls.get_display_info()
+431        if display is not None:
+432            all_displays = [all_displays[display]]
+433
+434        for device in all_displays:
+435            # make sure display brightness max value is cached
+436            cache_ident = '%s-%s-%s' % (device['name'],
+437                                        device['model'], device['serial'])
+438            if cache_ident not in cls._max_brightness_cache:
+439                cls.get_brightness(display=device['index'])
+440
+441            # scale the brightness value according to the max brightness
+442            max_value = cls._max_brightness_cache[cache_ident]
+443            if max_value != 100:
+444                value = int((value / 100) * max_value)
+445
+446            interface = cls.DDCInterface(device['i2c_bus'])
+447            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]: + + + +
+ + 
339    @classmethod
+340    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+341        all_displays = __cache__.get('i2c_display_info')
+342        if all_displays is None:
+343            all_displays = []
+344            index = 0
+345
+346            for i2c_path in glob.glob('/dev/i2c-*'):
+347                if not os.path.exists(i2c_path):
+348                    continue
+349
+350                try:
+351                    # open the I2C device using the host read address
+352                    device = cls.I2CDevice(i2c_path, cls.HOST_ADDR_R)
+353                    # read some 512 bytes from the device
+354                    data = device.read(512)
+355                except IOError as e:
+356                    cls._logger.error(
+357                        f'IOError reading from device {i2c_path}: {e}')
+358                    continue
+359
+360                # search for the EDID header within our 512 read bytes
+361                start = data.find(bytes.fromhex('00 FF FF FF FF FF FF 00'))
+362                if start < 0:
+363                    continue
+364
+365                # grab 128 bytes of the edid
+366                edid = data[start: start + 128]
+367                # parse the EDID
+368                (
+369                    manufacturer_id,
+370                    manufacturer,
+371                    model,
+372                    name,
+373                    serial
+374                ) = EDID.parse(edid)
+375
+376                all_displays.append(
+377                    {
+378                        'name': name,
+379                        'model': model,
+380                        'manufacturer': manufacturer,
+381                        'manufacturer_id': manufacturer_id,
+382                        'serial': serial,
+383                        'method': cls,
+384                        'index': index,
+385                        # convert edid to hex string
+386                        'edid': ''.join(f'{i:02x}' for i in edid),
+387                        'i2c_bus': i2c_path,
+388                        'uid': i2c_path.split('-')[-1]
+389                    }
+390                )
+391                index += 1
+392
+393            if all_displays:
+394                __cache__.store('i2c_display_info', all_displays, expires=2)
+395
+396        if display is not None:
+397            return filter_monitors(display=display, haystack=all_displays, include=['i2c_bus'])
+398        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]: + + + +
+ + 
400    @classmethod
+401    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+402        all_displays = cls.get_display_info()
+403        if display is not None:
+404            all_displays = [all_displays[display]]
+405
+406        results = []
+407        for device in all_displays:
+408            interface = cls.DDCInterface(device['i2c_bus'])
+409            value, max_value = interface.getvcp(0x10)
+410
+411            # make sure display's max brighness is cached
+412            cache_ident = '%s-%s-%s' % (device['name'],
+413                                        device['model'], device['serial'])
+414            if cache_ident not in cls._max_brightness_cache:
+415                cls._max_brightness_cache[cache_ident] = max_value
+416                cls._logger.info(
+417                    f'{cache_ident} max brightness:{max_value} (current: {value})')
+418
+419            if max_value != 100:
+420                # if max value is not 100 then we have to adjust the scale to be
+421                # a percentage
+422                value = int((value / max_value) * 100)
+423
+424            results.append(value)
+425
+426        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): + + + +
+ + 
428    @classmethod
+429    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+430        all_displays = cls.get_display_info()
+431        if display is not None:
+432            all_displays = [all_displays[display]]
+433
+434        for device in all_displays:
+435            # make sure display brightness max value is cached
+436            cache_ident = '%s-%s-%s' % (device['name'],
+437                                        device['model'], device['serial'])
+438            if cache_ident not in cls._max_brightness_cache:
+439                cls.get_brightness(display=device['index'])
+440
+441            # scale the brightness value according to the max brightness
+442            max_value = cls._max_brightness_cache[cache_ident]
+443            if max_value != 100:
+444                value = int((value / 100) * max_value)
+445
+446            interface = cls.DDCInterface(device['i2c_bus'])
+447            interface.setvcp(0x10, value)
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + class + I2C.I2CDevice: + + + +
+ + 
185    class I2CDevice():
+186        '''
+187        Class to read and write data to an I2C bus,
+188        based on the `I2CDev` class from [ddcci.py](https://github.com/siemer/ddcci)
+189        '''
+190
+191        def __init__(self, fname: str, slave_addr: int):
+192            '''
+193            Args:
+194                fname: the I2C path, eg: `/dev/i2c-2`
+195                slave_addr: not entirely sure what this is meant to be
+196            '''
+197            self.device = os.open(fname, os.O_RDWR)
+198            # I2C_SLAVE address setup
+199            fcntl.ioctl(self.device, I2C.I2C_SLAVE, slave_addr)
+200
+201        def read(self, length: int) -> bytes:
+202            '''
+203            Read a certain number of bytes from the I2C bus
+204
+205            Args:
+206                length: the number of bytes to read
+207
+208            Returns:
+209                bytes
+210            '''
+211            return os.read(self.device, length)
+212
+213        def write(self, data: bytes) -> int:
+214            '''
+215            Writes data to the I2C bus
+216
+217            Args:
+218                data: the data to write
+219
+220            Returns:
+221                The number of bytes written
+222            '''
+223            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) + + + +
+ + 
191        def __init__(self, fname: str, slave_addr: int):
+192            '''
+193            Args:
+194                fname: the I2C path, eg: `/dev/i2c-2`
+195                slave_addr: not entirely sure what this is meant to be
+196            '''
+197            self.device = os.open(fname, os.O_RDWR)
+198            # I2C_SLAVE address setup
+199            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: + + + +
+ + 
201        def read(self, length: int) -> bytes:
+202            '''
+203            Read a certain number of bytes from the I2C bus
+204
+205            Args:
+206                length: the number of bytes to read
+207
+208            Returns:
+209                bytes
+210            '''
+211            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: + + + +
+ + 
213        def write(self, data: bytes) -> int:
+214            '''
+215            Writes data to the I2C bus
+216
+217            Args:
+218                data: the data to write
+219
+220            Returns:
+221                The number of bytes written
+222            '''
+223            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): + + + +
+ + 
225    class DDCInterface(I2CDevice):
+226        '''
+227        Class to send DDC (Display Data Channel) commands to an I2C device,
+228        based on the `Ddcci` and `Mccs` classes from [ddcci.py](https://github.com/siemer/ddcci)
+229        '''
+230
+231        PROTOCOL_FLAG = 0x80
+232
+233        def __init__(self, i2c_path: str):
+234            '''
+235            Args:
+236                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+237            '''
+238            self.logger = _logger.getChild(
+239                self.__class__.__name__).getChild(i2c_path)
+240            super().__init__(i2c_path, I2C.DDCCI_ADDR)
+241
+242        def write(self, *args) -> int:
+243            '''
+244            Write some data to the I2C device.
+245
+246            It is recommended to use `setvcp` to set VCP values on the DDC device
+247            instead of using this function directly.
+248
+249            Args:
+250                *args: variable length list of arguments. This will be put
+251                    into a `bytearray` and wrapped up in various flags and
+252                    checksums before being written to the I2C device
+253
+254            Returns:
+255                The number of bytes that were written
+256            '''
+257            time.sleep(I2C.WAIT_TIME)
+258
+259            ba = bytearray(args)
+260            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+261            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+262            ba.append(functools.reduce(operator.xor, ba,
+263                      I2C.DESTINATION_ADDR_W))  # checksum
+264
+265            return super().write(ba)
+266
+267        def setvcp(self, vcp_code: int, value: int) -> int:
+268            '''
+269            Set a VCP value on the device
+270
+271            Args:
+272                vcp_code: the VCP command to send, eg: `0x10` is brightness
+273                value: what to set the value to
+274
+275            Returns:
+276                The number of bytes written to the device
+277            '''
+278            return self.write(I2C.SET_VCP_CMD, vcp_code, *value.to_bytes(2, 'big'))
+279
+280        def read(self, amount: int) -> bytes:
+281            '''
+282            Reads data from the DDC device.
+283
+284            It is recommended to use `getvcp` to retrieve VCP values from the
+285            DDC device instead of using this function directly.
+286
+287            Args:
+288                amount: the number of bytes to read
+289
+290            Raises:
+291                ValueError: if the read data is deemed invalid
+292            '''
+293            time.sleep(I2C.WAIT_TIME)
+294
+295            ba = super().read(amount + 3)
+296
+297            # check the bytes read
+298            checks = {
+299                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+300                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+301                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+302            }
+303            if False in checks.values():
+304                self.logger.error('i2c read check failed: ' + repr(checks))
+305                raise I2CValidationError(
+306                    'i2c read check failed: ' + repr(checks))
+307
+308            return ba[2:-1]
+309
+310        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+311            '''
+312            Retrieves a VCP value from the DDC device.
+313
+314            Args:
+315                vcp_code: the VCP value to read, eg: `0x10` is brightness
+316
+317            Returns:
+318                The current and maximum value respectively
+319
+320            Raises:
+321                ValueError: if the read data is deemed invalid
+322            '''
+323            self.write(I2C.GET_VCP_CMD, vcp_code)
+324            ba = self.read(8)
+325
+326            checks = {
+327                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+328                'supported VCP opcode': ba[1] == 0,
+329                'answer matches request': ba[2] == vcp_code
+330            }
+331            if False in checks.values():
+332                self.logger.error('i2c read check failed: ' + repr(checks))
+333                raise I2CValidationError(
+334                    'i2c read check failed: ' + repr(checks))
+335
+336            # current and max values
+337            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) + + + +
+ + 
233        def __init__(self, i2c_path: str):
+234            '''
+235            Args:
+236                i2c_path: the path to the I2C device, eg: `/dev/i2c-2`
+237            '''
+238            self.logger = _logger.getChild(
+239                self.__class__.__name__).getChild(i2c_path)
+240            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: + + + +
+ + 
242        def write(self, *args) -> int:
+243            '''
+244            Write some data to the I2C device.
+245
+246            It is recommended to use `setvcp` to set VCP values on the DDC device
+247            instead of using this function directly.
+248
+249            Args:
+250                *args: variable length list of arguments. This will be put
+251                    into a `bytearray` and wrapped up in various flags and
+252                    checksums before being written to the I2C device
+253
+254            Returns:
+255                The number of bytes that were written
+256            '''
+257            time.sleep(I2C.WAIT_TIME)
+258
+259            ba = bytearray(args)
+260            ba.insert(0, len(ba) | self.PROTOCOL_FLAG)  # add length info
+261            ba.insert(0, I2C.HOST_ADDR_W)  # insert source address
+262            ba.append(functools.reduce(operator.xor, ba,
+263                      I2C.DESTINATION_ADDR_W))  # checksum
+264
+265            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: + + + +
+ + 
267        def setvcp(self, vcp_code: int, value: int) -> int:
+268            '''
+269            Set a VCP value on the device
+270
+271            Args:
+272                vcp_code: the VCP command to send, eg: `0x10` is brightness
+273                value: what to set the value to
+274
+275            Returns:
+276                The number of bytes written to the device
+277            '''
+278            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: + + + +
+ + 
280        def read(self, amount: int) -> bytes:
+281            '''
+282            Reads data from the DDC device.
+283
+284            It is recommended to use `getvcp` to retrieve VCP values from the
+285            DDC device instead of using this function directly.
+286
+287            Args:
+288                amount: the number of bytes to read
+289
+290            Raises:
+291                ValueError: if the read data is deemed invalid
+292            '''
+293            time.sleep(I2C.WAIT_TIME)
+294
+295            ba = super().read(amount + 3)
+296
+297            # check the bytes read
+298            checks = {
+299                'source address': ba[0] == I2C.DESTINATION_ADDR_W,
+300                'checksum': functools.reduce(operator.xor, ba) == I2C.HOST_ADDR_R,
+301                'length': len(ba) >= (ba[1] & ~self.PROTOCOL_FLAG) + 3
+302            }
+303            if False in checks.values():
+304                self.logger.error('i2c read check failed: ' + repr(checks))
+305                raise I2CValidationError(
+306                    'i2c read check failed: ' + repr(checks))
+307
+308            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]: + + + +
+ + 
310        def getvcp(self, vcp_code: int) -> Tuple[int, int]:
+311            '''
+312            Retrieves a VCP value from the DDC device.
+313
+314            Args:
+315                vcp_code: the VCP value to read, eg: `0x10` is brightness
+316
+317            Returns:
+318                The current and maximum value respectively
+319
+320            Raises:
+321                ValueError: if the read data is deemed invalid
+322            '''
+323            self.write(I2C.GET_VCP_CMD, vcp_code)
+324            ba = self.read(8)
+325
+326            checks = {
+327                'is feature reply': ba[0] == I2C.GET_VCP_REPLY,
+328                'supported VCP opcode': ba[1] == 0,
+329                'answer matches request': ba[2] == vcp_code
+330            }
+331            if False in checks.values():
+332                self.logger.error('i2c read check failed: ' + repr(checks))
+333                raise I2CValidationError(
+334                    'i2c read check failed: ' + repr(checks))
+335
+336            # current and max values
+337            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
+
+ +
+
+
+
+ +
+ + class + XRandr(screen_brightness_control.helpers.BrightnessMethodAdv): + + + +
+ + 
450class XRandr(BrightnessMethodAdv):
+451    '''collection of screen brightness related methods using the xrandr executable'''
+452
+453    executable: str = 'xrandr'
+454    '''the xrandr executable to be called'''
+455
+456    @staticmethod
+457    def _get_uid(interface: str) -> Optional[str]:
+458        '''
+459        Attempts to find a UID (I2C bus path) for a given display interface.
+460
+461        This works by parsing the interface name and matching it up to the entries in `/sys/class/drm`.
+462        `i2c_bus_from_drm_device` is then used to extract the bus number
+463
+464        Args:
+465            interface: the interface in question. EG: `eDP-1`, `eDP1`, `HDMI-1`...
+466
+467        Returns:
+468            The bus number as a string if found. Otherwise, none.
+469        '''
+470        if not os.path.isdir('/sys/class/drm'):
+471            return None
+472
+473        # use regex because sometimes it can be `eDP-1` and sometimes it's `eDP1`
+474        if interface_match := re.match(r'([a-z]+)-?(\d+)', interface, re.I):
+475            interface, count = interface_match.groups()
+476        else:
+477            return None
+478
+479        for dir in os.listdir('/sys/class/drm/'):
+480            # use regex here for case insensitivity on the interface
+481            if not re.match(r'card\d+-%s(?:-[A-Z])?-%s' % (interface, count), dir, re.I):
+482                continue
+483            dir = f'/sys/class/drm/{dir}'
+484            if bus := i2c_bus_from_drm_device(dir):
+485                return bus
+486
+487    @classmethod
+488    def _gdi(cls):
+489        '''
+490        .. warning:: Don't use this
+491           This function isn't final and I will probably make breaking changes to it.
+492           You have been warned
+493
+494        Gets all displays reported by XRandr even if they're not supported
+495        '''
+496        xrandr_output = check_output(
+497            [cls.executable, '--verbose']).decode().split('\n')
+498
+499        display_count = 0
+500        tmp_display: dict = {}
+501
+502        for line_index, line in enumerate(xrandr_output):
+503            if line == '':
+504                continue
+505
+506            if not line.startswith((' ', '\t')) and 'connected' in line and 'disconnected' not in line:
+507                if tmp_display:
+508                    yield tmp_display
+509
+510                tmp_display = {
+511                    'name': line.split(' ')[0],
+512                    'interface': line.split(' ')[0],
+513                    'method': cls,
+514                    'index': display_count,
+515                    'model': None,
+516                    'serial': None,
+517                    'manufacturer': None,
+518                    'manufacturer_id': None,
+519                    'edid': None,
+520                    'unsupported': line.startswith('XWAYLAND') or 'WAYLAND_DISPLAY' in os.environ,
+521                    'uid': cls._get_uid(line.split(' ')[0])
+522                }
+523                display_count += 1
+524
+525            elif 'EDID:' in line:
+526                # extract the edid from the chunk of the output that will contain the edid
+527                edid = ''.join(
+528                    i.replace('\t', '').replace(' ', '') for i in xrandr_output[line_index + 1: line_index + 9]
+529                )
+530                tmp_display['edid'] = edid
+531
+532                for key, value in zip(
+533                    ('manufacturer_id', 'manufacturer', 'model', 'name', 'serial'),
+534                    EDID.parse(tmp_display['edid'])
+535                ):
+536                    if value is None:
+537                        continue
+538                    tmp_display[key] = value
+539
+540            elif 'Brightness:' in line:
+541                tmp_display['brightness'] = int(
+542                    float(line.replace('Brightness:', '')) * 100)
+543
+544        if tmp_display:
+545            yield tmp_display
+546
+547    @classmethod
+548    def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+549        '''
+550        Implements `BrightnessMethod.get_display_info`.
+551
+552        Args:
+553            display: the index of the specific display to query.
+554                If unspecified, all detected displays are queried
+555            brightness: whether to include the current brightness
+556                in the returned info
+557        '''
+558        valid_displays = []
+559        for item in cls._gdi():
+560            if item['unsupported']:
+561                continue
+562            if not brightness:
+563                del item['brightness']
+564            del item['unsupported']
+565            valid_displays.append(item)
+566        if display is not None:
+567            valid_displays = filter_monitors(
+568                display=display, haystack=valid_displays, include=['interface'])
+569        return valid_displays
+570
+571    @classmethod
+572    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+573        monitors = cls.get_display_info(brightness=True)
+574        if display is not None:
+575            monitors = [monitors[display]]
+576        brightness = [i['brightness'] for i in monitors]
+577
+578        return brightness
+579
+580    @classmethod
+581    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+582        value_as_str = str(float(value) / 100)
+583        info = cls.get_display_info()
+584        if display is not None:
+585            info = [info[display]]
+586
+587        for i in info:
+588            check_output([cls.executable, '--output',
+589                         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]: + + + +
+ + 
547    @classmethod
+548    def get_display_info(cls, display: Optional[DisplayIdentifier] = None, brightness: bool = False) -> List[dict]:
+549        '''
+550        Implements `BrightnessMethod.get_display_info`.
+551
+552        Args:
+553            display: the index of the specific display to query.
+554                If unspecified, all detected displays are queried
+555            brightness: whether to include the current brightness
+556                in the returned info
+557        '''
+558        valid_displays = []
+559        for item in cls._gdi():
+560            if item['unsupported']:
+561                continue
+562            if not brightness:
+563                del item['brightness']
+564            del item['unsupported']
+565            valid_displays.append(item)
+566        if display is not None:
+567            valid_displays = filter_monitors(
+568                display=display, haystack=valid_displays, include=['interface'])
+569        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]: + + + +
+ + 
571    @classmethod
+572    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+573        monitors = cls.get_display_info(brightness=True)
+574        if display is not None:
+575            monitors = [monitors[display]]
+576        brightness = [i['brightness'] for i in monitors]
+577
+578        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): + + + +
+ + 
580    @classmethod
+581    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+582        value_as_str = str(float(value) / 100)
+583        info = cls.get_display_info()
+584        if display is not None:
+585            info = [info[display]]
+586
+587        for i in info:
+588            check_output([cls.executable, '--output',
+589                         i['interface'], '--brightness', value_as_str])
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + class + DDCUtil(screen_brightness_control.helpers.BrightnessMethodAdv): + + + +
+ + 
592class DDCUtil(BrightnessMethodAdv):
+593    '''collection of screen brightness related methods using the ddcutil executable'''
+594    _logger = _logger.getChild('DDCUtil')
+595
+596    executable: str = 'ddcutil'
+597    '''The ddcutil executable to be called'''
+598    sleep_multiplier: float = 0.5
+599    '''
+600    How long ddcutil should sleep between each DDC request (lower is shorter).
+601    See [the ddcutil docs](https://www.ddcutil.com/performance_options/#option-sleep-multiplier).
+602    '''
+603    cmd_max_tries: int = 10
+604    '''Max number of retries when calling the ddcutil'''
+605    enable_async = True
+606    '''
+607    Use the `--async` flag when calling ddcutil.
+608    See [ddcutil docs](https://www.ddcutil.com/performance_options/#option-async)
+609    '''
+610    _max_brightness_cache: dict = {}
+611    '''Cache for displays and their maximum brightness values'''
+612
+613    @classmethod
+614    def _gdi(cls):
+615        '''
+616        .. warning:: Don't use this
+617           This function isn't final and I will probably make breaking changes to it.
+618           You have been warned
+619
+620        Gets all displays reported by DDCUtil even if they're not supported
+621        '''
+622        raw_ddcutil_output = str(
+623            check_output(
+624                [
+625                    cls.executable, 'detect', '-v',
+626                    f'--sleep-multiplier={cls.sleep_multiplier}'
+627                ] + ['--async'] if cls.enable_async else [], max_tries=cls.cmd_max_tries
+628            )
+629        )[2:-1].split('\\n')
+630        # Use -v to get EDID string but this means output cannot be decoded.
+631        # Or maybe it can. I don't know the encoding though, so let's assume it cannot be decoded.
+632        # Use str()[2:-1] workaround
+633
+634        # include "Invalid display" sections because they tell us where one displays metadata ends
+635        # and another begins. We filter out invalid displays later on
+636        ddcutil_output = [i for i in raw_ddcutil_output if i.startswith(
+637            ('Invalid display', 'Display', '\t', ' '))]
+638        tmp_display: dict = {}
+639        display_count = 0
+640
+641        for line_index, line in enumerate(ddcutil_output):
+642            if not line.startswith(('\t', ' ')):
+643                if tmp_display:
+644                    yield tmp_display
+645
+646                tmp_display = {
+647                    'method': cls,
+648                    'index': display_count,
+649                    'model': None,
+650                    'serial': None,
+651                    'bin_serial': None,
+652                    'manufacturer': None,
+653                    'manufacturer_id': None,
+654                    'edid': None,
+655                    'unsupported': 'invalid display' in line.lower(),
+656                    'uid': None
+657                }
+658                display_count += 1
+659
+660            elif 'I2C bus' in line:
+661                tmp_display['i2c_bus'] = line[line.index('/'):]
+662                tmp_display['bus_number'] = int(
+663                    tmp_display['i2c_bus'].replace('/dev/i2c-', ''))
+664                tmp_display['uid'] = tmp_display['i2c_bus'].split('-')[-1]
+665
+666            elif 'Mfg id' in line:
+667                # Recently ddcutil has started reporting manufacturer IDs like
+668                # 'BNQ - UNK' or 'MSI - Microstep' so we have to split the line
+669                # into chunks of alpha chars and check for a valid mfg id
+670                for code in re.split(r'[^A-Za-z]', line.replace('Mfg id:', '').replace(' ', '')):
+671                    if len(code) != 3:
+672                        # all mfg ids are 3 chars long
+673                        continue
+674
+675                    if (brand := _monitor_brand_lookup(code)):
+676                        tmp_display['manufacturer_id'], tmp_display['manufacturer'] = brand
+677                        break
+678
+679            elif 'Model' in line:
+680                # the split() removes extra spaces
+681                name = line.replace('Model:', '').split()
+682                try:
+683                    tmp_display['model'] = name[1]
+684                except IndexError:
+685                    pass
+686                tmp_display['name'] = ' '.join(name)
+687
+688            elif 'Serial number' in line:
+689                tmp_display['serial'] = line.replace(
+690                    'Serial number:', '').replace(' ', '') or None
+691
+692            elif 'Binary serial number:' in line:
+693                tmp_display['bin_serial'] = line.split(' ')[-1][3:-1]
+694
+695            elif 'EDID hex dump:' in line:
+696                try:
+697                    tmp_display['edid'] = ''.join(
+698                        ''.join(i.split()[1:17]) for i in ddcutil_output[line_index + 2: line_index + 10]
+699                    )
+700                except Exception:
+701                    pass
+702
+703        if tmp_display:
+704            yield tmp_display
+705
+706    @classmethod
+707    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+708        valid_displays = __cache__.get('ddcutil_monitors_info')
+709        if valid_displays is None:
+710            valid_displays = []
+711            for item in cls._gdi():
+712                if item['unsupported']:
+713                    continue
+714                del item['unsupported']
+715                valid_displays.append(item)
+716
+717            if valid_displays:
+718                __cache__.store('ddcutil_monitors_info', valid_displays)
+719
+720        if display is not None:
+721            valid_displays = filter_monitors(
+722                display=display, haystack=valid_displays, include=['i2c_bus'])
+723        return valid_displays
+724
+725    @classmethod
+726    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+727        monitors = cls.get_display_info()
+728        if display is not None:
+729            monitors = [monitors[display]]
+730
+731        res = []
+732        for monitor in monitors:
+733            value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+734            if value is None:
+735                cmd_out = check_output(
+736                    [
+737                        cls.executable,
+738                        'getvcp', '10', '-t',
+739                        '-b', str(monitor['bus_number']),
+740                        f'--sleep-multiplier={cls.sleep_multiplier}'
+741                    ], max_tries=cls.cmd_max_tries
+742                ).decode().split(' ')
+743
+744                value = int(cmd_out[-2])
+745                max_value = int(cmd_out[-1])
+746                if max_value != 100:
+747                    # if the max brightness is not 100 then the number is not a percentage
+748                    # and will need to be scaled
+749                    value = int((value / max_value) * 100)
+750
+751                # now make sure max brightness is recorded so set_brightness can use it
+752                cache_ident = '%s-%s-%s' % (monitor['name'],
+753                                            monitor['serial'], monitor['bin_serial'])
+754                if cache_ident not in cls._max_brightness_cache:
+755                    cls._max_brightness_cache[cache_ident] = max_value
+756                    cls._logger.debug(
+757                        f'{cache_ident} max brightness:{max_value} (current: {value})')
+758
+759                __cache__.store(
+760                    f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+761            res.append(value)
+762        return res
+763
+764    @classmethod
+765    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+766        monitors = cls.get_display_info()
+767        if display is not None:
+768            monitors = [monitors[display]]
+769
+770        __cache__.expire(startswith='ddcutil_brightness_')
+771        for monitor in monitors:
+772            # check if monitor has a max brightness that requires us to scale this value
+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.get_brightness(display=monitor['index'])
+777
+778            if cls._max_brightness_cache[cache_ident] != 100:
+779                value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+780
+781            check_output(
+782                [
+783                    cls.executable, 'setvcp', '10', str(value),
+784                    '-b', str(monitor['bus_number']),
+785                    f'--sleep-multiplier={cls.sleep_multiplier}'
+786                ], max_tries=cls.cmd_max_tries
+787            )
+
+ + +

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]: + + + +
+ + 
706    @classmethod
+707    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+708        valid_displays = __cache__.get('ddcutil_monitors_info')
+709        if valid_displays is None:
+710            valid_displays = []
+711            for item in cls._gdi():
+712                if item['unsupported']:
+713                    continue
+714                del item['unsupported']
+715                valid_displays.append(item)
+716
+717            if valid_displays:
+718                __cache__.store('ddcutil_monitors_info', valid_displays)
+719
+720        if display is not None:
+721            valid_displays = filter_monitors(
+722                display=display, haystack=valid_displays, include=['i2c_bus'])
+723        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]: + + + +
+ + 
725    @classmethod
+726    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+727        monitors = cls.get_display_info()
+728        if display is not None:
+729            monitors = [monitors[display]]
+730
+731        res = []
+732        for monitor in monitors:
+733            value = __cache__.get(f'ddcutil_brightness_{monitor["index"]}')
+734            if value is None:
+735                cmd_out = check_output(
+736                    [
+737                        cls.executable,
+738                        'getvcp', '10', '-t',
+739                        '-b', str(monitor['bus_number']),
+740                        f'--sleep-multiplier={cls.sleep_multiplier}'
+741                    ], max_tries=cls.cmd_max_tries
+742                ).decode().split(' ')
+743
+744                value = int(cmd_out[-2])
+745                max_value = int(cmd_out[-1])
+746                if max_value != 100:
+747                    # if the max brightness is not 100 then the number is not a percentage
+748                    # and will need to be scaled
+749                    value = int((value / max_value) * 100)
+750
+751                # now make sure max brightness is recorded so set_brightness can use it
+752                cache_ident = '%s-%s-%s' % (monitor['name'],
+753                                            monitor['serial'], monitor['bin_serial'])
+754                if cache_ident not in cls._max_brightness_cache:
+755                    cls._max_brightness_cache[cache_ident] = max_value
+756                    cls._logger.debug(
+757                        f'{cache_ident} max brightness:{max_value} (current: {value})')
+758
+759                __cache__.store(
+760                    f'ddcutil_brightness_{monitor["index"]}', value, expires=0.5)
+761            res.append(value)
+762        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): + + + +
+ + 
764    @classmethod
+765    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+766        monitors = cls.get_display_info()
+767        if display is not None:
+768            monitors = [monitors[display]]
+769
+770        __cache__.expire(startswith='ddcutil_brightness_')
+771        for monitor in monitors:
+772            # check if monitor has a max brightness that requires us to scale this value
+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.get_brightness(display=monitor['index'])
+777
+778            if cls._max_brightness_cache[cache_ident] != 100:
+779                value = int((value / 100) * cls._max_brightness_cache[cache_ident])
+780
+781            check_output(
+782                [
+783                    cls.executable, 'setvcp', '10', str(value),
+784                    '-b', str(monitor['bus_number']),
+785                    f'--sleep-multiplier={cls.sleep_multiplier}'
+786                ], max_tries=cls.cmd_max_tries
+787            )
+
+ + +
Arguments:
+ + +
+ + +
+
+
+ +
+ + def + i2c_bus_from_drm_device(dir: str) -> Optional[str]: + + + +
+ + 
790def i2c_bus_from_drm_device(dir: str) -> Optional[str]:
+791    '''
+792    Extract the relevant I2C bus number from a device in `/sys/class/drm`.
+793
+794    This function works by searching the directory for `i2c-*` and `ddc/i2c-dev/i2c-*` folders.
+795
+796    Args:
+797        dir: the DRM directory, in the format `/sys/class/drm/<device>`
+798
+799    Returns:
+800        Returns the I2C bus number as a string if found. Otherwise, returns None
+801    '''
+802    # check for enabled file and skip device if monitor inactive
+803    if os.path.isfile(f'{dir}/enabled'):
+804        with open(f'{dir}/enabled') as f:
+805            if f.read().strip().lower() != 'enabled':
+806                return
+807
+808    # sometimes the i2c path is in /sys/class/drm/*/i2c-*
+809    # do this first because, in my testing, sometimes a device can have both `.../i2c-X` and `.../ddc/i2c-dev/...`
+810    # and the latter is usually the wrong i2c path
+811    paths = glob.glob(f'{dir}/i2c-*')
+812    if paths:
+813        return paths[0].split('-')[-1]
+814
+815    # sometimes the i2c path is in /sys/class/drm/*/ddc/i2c-dev
+816    if os.path.isdir(f'{dir}/ddc/i2c-dev'):
+817        paths = os.listdir(f'{dir}/ddc/i2c-dev')
+818        if paths:
+819            return paths[0].replace('i2c-', '')
+
+ + +

Extract the relevant I2C bus number from a device in /sys/class/drm.

+ +

This function works by searching the directory for i2c-* and ddc/i2c-dev/i2c-* folders.

+ +
Arguments:
+ +
    +
  • dir: the DRM directory, in the format /sys/class/drm/<device>
    • +
+ +
Returns:
+ +
+

Returns the I2C bus number as a string if found. Otherwise, returns None

+
+
+ + +
+
+ +
+ + def + list_monitors_info( method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False) -> List[dict]: + + + +
+ + 
822def list_monitors_info(
+823    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+824) -> List[dict]:
+825    '''
+826    Lists detailed information about all detected displays
+827
+828    Args:
+829        method: the method the display can be addressed by. See `.get_methods`
+830            for more info on available methods
+831        allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+832        unsupported: include detected displays that are invalid or unsupported
+833    '''
+834    all_methods = get_methods(method).values()
+835    haystack = []
+836    for method_class in all_methods:
+837        try:
+838            if unsupported and issubclass(method_class, BrightnessMethodAdv):
+839                haystack += method_class._gdi()
+840            else:
+841                haystack += method_class.get_display_info()
+842        except Exception as e:
+843            _logger.warning(
+844                f'error grabbing display info from {method_class} - {format_exc(e)}')
+845            pass
+846
+847    if allow_duplicates:
+848        return haystack
+849
+850    try:
+851        # use filter_monitors to remove duplicates
+852        return filter_monitors(haystack=haystack)
+853    except NoValidDisplayError:
+854        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'>) + + +
+ + + + +
+
+ + \ No newline at end of file diff --git a/docs/0.24.1/screen_brightness_control/types.html b/docs/0.24.1/screen_brightness_control/types.html new file mode 100644 index 0000000..1d6a767 --- /dev/null +++ b/docs/0.24.1/screen_brightness_control/types.html @@ -0,0 +1,417 @@ + + + + + + + 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- uid (str)
+47- edid (str)
+48- serial (str)
+49- name (str)
+50- index (int)
+51
+52See `.Display` for descriptions of each property and its type
+53'''
+
+ + +
+ +
+
+
+ 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:

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

See screen_brightness_control.Display for descriptions of each property and its type

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

+screen_brightness_control.windows

+ + + + + + + 
  1import logging
+  2import re
+  3import time
+  4from contextlib import contextmanager
+  5from ctypes import Structure, WinError, byref, windll
+  6from ctypes.wintypes import BYTE, DWORD, HANDLE, 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
+ 23COM_MODEL = None
+ 24'''
+ 25The concurrency model and flags used when calling `pythoncom.CoInitializeEx`.
+ 26If left as `None` the library will call `CoInitialize` instead with whatever defaults it chooses.
+ 27
+ 28Refer to the [MS docs](https://learn.microsoft.com/en-us/windows/win32/api/objbase/ne-objbase-coinit)
+ 29for all the possible flags.
+ 30
+ 31See also:
+ 32- https://timgolden.me.uk/pywin32-docs/pythoncom__CoInitialize_meth.html
+ 33- https://timgolden.me.uk/pywin32-docs/pythoncom__CoInitializeEx_meth.html
+ 34- https://github.com/Crozzers/screen_brightness_control/issues/42
+ 35'''
+ 36
+ 37
+ 38@contextmanager
+ 39def _wmi_init():
+ 40    '''internal function to create and return a wmi instance'''
+ 41    com_init = False
+ 42    try:
+ 43        yield wmi.WMI(namespace='wmi')
+ 44    except Exception as e:
+ 45        # WMI init will fail outside the main thread, or if CoInitialize wasn't called first
+ 46        _logger.debug(f'WMI init failed ({e!r}). Calling CoInitialize and retrying')
+ 47        com_init = True
+ 48        if COM_MODEL is None:
+ 49            pythoncom.CoInitialize()
+ 50        else:
+ 51            pythoncom.CoInitializeEx(COM_MODEL)
+ 52
+ 53        yield wmi.WMI(namespace='wmi')
+ 54
+ 55    # only uninitialise if we initialised. Avoid cleaning up resources being used by another library
+ 56    if com_init:
+ 57        pythoncom.CoUninitialize()
+ 58
+ 59
+ 60def enum_display_devices() -> Generator[win32api.PyDISPLAY_DEVICEType, None, None]:
+ 61    '''
+ 62    Yields all display devices connected to the computer
+ 63    '''
+ 64    for monitor_enum in win32api.EnumDisplayMonitors():
+ 65        pyhandle = monitor_enum[0]
+ 66        monitor_info = win32api.GetMonitorInfo(pyhandle.handle)
+ 67        for adaptor_index in range(5):
+ 68            try:
+ 69                # EDD_GET_DEVICE_INTERFACE_NAME flag to populate DeviceID field
+ 70                device = win32api.EnumDisplayDevices(
+ 71                    monitor_info['Device'], adaptor_index, 1)
+ 72            except pywintypes.error:
+ 73                _logger.debug(
+ 74                    f'failed to get display device {monitor_info["Device"]} on adaptor index {adaptor_index}')
+ 75            else:
+ 76                yield device
+ 77                break
+ 78
+ 79
+ 80def get_display_info() -> List[dict]:
+ 81    '''
+ 82    Gets information about all connected displays using WMI and win32api
+ 83
+ 84    Example:
+ 85        ```python
+ 86        import screen_brightness_control as s
+ 87
+ 88        info = s.windows.get_display_info()
+ 89        for display in info:
+ 90            print(display['name'])
+ 91        ```
+ 92    '''
+ 93    info = __cache__.get('windows_monitors_info_raw')
+ 94    if info is None:
+ 95        info = []
+ 96        # collect all monitor UIDs (derived from DeviceID)
+ 97        monitor_uids = {}
+ 98        for device in enum_display_devices():
+ 99            monitor_uids[device.DeviceID.split('#')[2]] = device
+100
+101        # gather list of laptop displays to check against later
+102        with _wmi_init() as wmi:
+103            try:
+104                laptop_displays = [
+105                    i.InstanceName
+106                    for i in wmi.WmiMonitorBrightness()
+107                ]
+108            except Exception as e:
+109                # don't do specific exception classes here because WMI does not play ball with it
+110                _logger.warning(
+111                    f'get_display_info: failed to gather list of laptop displays - {format_exc(e)}')
+112                laptop_displays = []
+113
+114            extras, desktop, laptop = [], 0, 0
+115            uid_keys = list(monitor_uids.keys())
+116            for monitor in wmi.WmiMonitorDescriptorMethods():
+117                model, serial, manufacturer, man_id, edid = None, None, None, None, None
+118                instance_name = monitor.InstanceName.replace(
+119                    '_0', '', 1).split('\\')[2]
+120                try:
+121                    pydevice = monitor_uids[instance_name]
+122                except KeyError:
+123                    # if laptop display WAS connected but was later put to sleep (#33)
+124                    if instance_name in laptop_displays:
+125                        laptop += 1
+126                    else:
+127                        desktop += 1
+128                    _logger.warning(
+129                        f'display {instance_name!r} is detected but not present in monitor_uids.'
+130                        ' Maybe it is asleep?'
+131                    )
+132                    continue
+133
+134                # get the EDID
+135                try:
+136                    edid = ''.join(
+137                        f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
+138                    # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
+139                    # takes too long
+140                    parsed = EDID.parse(edid)
+141                    man_id, manufacturer, model, name, serial = parsed
+142                    if name is None:
+143                        raise EDIDParseError(
+144                            'parsed EDID returned invalid display name')
+145                except EDIDParseError as e:
+146                    edid = None
+147                    _logger.warning(
+148                        f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
+149                except Exception as e:
+150                    edid = None
+151                    _logger.error(
+152                        f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
+153                finally:
+154                    if edid is None:
+155                        devid = pydevice.DeviceID.split('#')
+156                        serial = devid[2]
+157                        man_id = devid[1][:3]
+158                        model = devid[1][3:] or 'Generic Monitor'
+159                        del devid
+160                        if (brand := _monitor_brand_lookup(man_id)):
+161                            man_id, manufacturer = brand
+162
+163                if (serial, model) != (None, None):
+164                    data: dict = {
+165                        'name': f'{manufacturer} {model}',
+166                        'model': model,
+167                        'serial': serial,
+168                        'manufacturer': manufacturer,
+169                        'manufacturer_id': man_id,
+170                        'edid': edid,
+171                        'uid': uid_match.group(1) if (uid_match := re.search(r"UID(\d+)", instance_name)) else None,
+172                    }
+173                    if monitor.InstanceName in laptop_displays:
+174                        data['index'] = laptop
+175                        data['method'] = WMI
+176                        laptop += 1
+177                    else:
+178                        data['method'] = VCP
+179                        desktop += 1
+180
+181                    if instance_name in uid_keys:
+182                        # insert the data into the uid_keys list because
+183                        # uid_keys has the monitors sorted correctly. This
+184                        # means we don't have to re-sort the list later
+185                        uid_keys[uid_keys.index(instance_name)] = data
+186                    else:
+187                        extras.append(data)
+188
+189        info = uid_keys + extras
+190        if desktop:
+191            # now make sure desktop monitors have the correct index
+192            count = 0
+193            for item in info:
+194                if item['method'] == VCP:
+195                    item['index'] = count
+196                    count += 1
+197
+198        # return info only which has correct data
+199        info = [i for i in info if isinstance(i, dict)]
+200
+201        __cache__.store('windows_monitors_info_raw', info)
+202
+203    return info
+204
+205
+206class WMI(BrightnessMethod):
+207    '''
+208    A collection of screen brightness related methods using the WMI API.
+209    This class primarily works with laptop displays.
+210    '''
+211    @classmethod
+212    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+213        info = [i for i in get_display_info() if i['method'] == cls]
+214        if display is not None:
+215            info = filter_monitors(display=display, haystack=info)
+216        return info
+217
+218    @classmethod
+219    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+220        with _wmi_init() as wmi:
+221            brightness_method = wmi.WmiMonitorBrightnessMethods()
+222            if display is not None:
+223                brightness_method = [brightness_method[display]]
+224
+225            for method in brightness_method:
+226                method.WmiSetBrightness(value, 0)
+227
+228    @classmethod
+229    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+230        with _wmi_init() as wmi:
+231            brightness_method = wmi.WmiMonitorBrightness()
+232            if display is not None:
+233                brightness_method = [brightness_method[display]]
+234
+235            values = [i.CurrentBrightness for i in brightness_method]
+236            return values
+237
+238
+239class VCP(BrightnessMethod):
+240    '''Collection of screen brightness related methods using the DDC/CI commands'''
+241    _logger = _logger.getChild('VCP')
+242
+243    class _PHYSICAL_MONITOR(Structure):
+244        '''internal class, do not call'''
+245        _fields_ = [('handle', HANDLE),
+246                    ('description', WCHAR * 128)]
+247
+248    @classmethod
+249    def iter_physical_monitors(cls, start: int = 0) -> Generator[HANDLE, None, None]:
+250        '''
+251        A generator to iterate through all physical monitors
+252        and then close them again afterwards, yielding their handles.
+253        It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+254
+255        Args:
+256            start: skip the first X handles
+257
+258        Raises:
+259            ctypes.WinError: upon failure to enumerate through the monitors
+260        '''
+261        # user index keeps track of valid monitors
+262        user_index = 0
+263        # monitor index keeps track of valid and pseudo monitors
+264        monitor_index = 0
+265        display_devices = list(enum_display_devices())
+266
+267        with _wmi_init() as wmi:
+268            try:
+269                laptop_displays = [
+270                    i.InstanceName.replace('_0', '').split('\\')[2]
+271                    for i in wmi.WmiMonitorBrightness()
+272                ]
+273            except Exception as e:
+274                cls._logger.warning(
+275                    f'failed to gather list of laptop displays - {format_exc(e)}')
+276                laptop_displays = []
+277
+278        for monitor in map(lambda m: m[0].handle, win32api.EnumDisplayMonitors()):
+279            # Get physical monitor count
+280            count = DWORD()
+281            if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+282                raise WinError(None, 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+283            if count.value > 0:
+284                # Get physical monitor handles
+285                physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+286                if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+287                    raise WinError(None, 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+288                for item in physical_array:
+289                    # check that the monitor is not a pseudo monitor by
+290                    # checking its StateFlags for the
+291                    # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+292                    if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+293                        # check if monitor is actually a laptop display
+294                        if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+295                            if start is None or user_index >= start:
+296                                yield item.handle
+297                            # increment user index as a valid monitor was found
+298                            user_index += 1
+299                    # increment monitor index
+300                    monitor_index += 1
+301                    windll.dxva2.DestroyPhysicalMonitor(item.handle)
+302
+303    @classmethod
+304    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+305        info = [i for i in get_display_info() if i['method'] == cls]
+306        if display is not None:
+307            info = filter_monitors(display=display, haystack=info)
+308        return info
+309
+310    @classmethod
+311    def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+312        '''
+313        Args:
+314            display: the index of the specific display to query.
+315                If unspecified, all detected displays are queried
+316            max_tries: the maximum allowed number of attempts to
+317                read the VCP output from the display
+318
+319        Returns:
+320            See `BrightnessMethod.get_brightness`
+321        '''
+322        code = BYTE(0x10)
+323        values = []
+324        start = display if display is not None else 0
+325        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+326            current = __cache__.get(f'vcp_brightness_{index}')
+327            if current is None:
+328                cur_out = DWORD()
+329                attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+330                for attempt in range(max_tries):
+331                    if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+332                        current = cur_out.value
+333                        break
+334                    current = None
+335                    time.sleep(0.02 if attempt < 20 else 0.1)
+336                else:
+337                    cls._logger.error(
+338                        f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+339
+340            if current is not None:
+341                __cache__.store(
+342                    f'vcp_brightness_{index}', current, expires=0.1)
+343                values.append(current)
+344
+345            if display == index:
+346                # if we've got the display we wanted then exit here, no point iterating through all the others.
+347                # Cleanup function usually called in iter_physical_monitors won't get called if we break, so call now
+348                windll.dxva2.DestroyPhysicalMonitor(handle)
+349                break
+350
+351        return values
+352
+353    @classmethod
+354    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+355        '''
+356        Args:
+357            value: percentage brightness to set the display to
+358            display: The specific display you wish to query.
+359            max_tries: the maximum allowed number of attempts to
+360                send the VCP input to the display
+361        '''
+362        __cache__.expire(startswith='vcp_brightness_')
+363        code = BYTE(0x10)
+364        value_dword = DWORD(value)
+365        start = display if display is not None else 0
+366        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+367            attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+368            for attempt in range(max_tries):
+369                if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+370                    break
+371                time.sleep(0.02 if attempt < 20 else 0.1)
+372            else:
+373                cls._logger.error(
+374                    f'failed to set display:{index}->{value} after {attempt} tries')
+375
+376            if display == index:
+377                # we have the display we wanted, exit and cleanup
+378                windll.dxva2.DestroyPhysicalMonitor(handle)
+379                break
+380
+381
+382def list_monitors_info(
+383    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+384) -> List[dict]:
+385    '''
+386    Lists detailed information about all detected displays
+387
+388    Args:
+389        method: the method the display can be addressed by. See `.get_methods`
+390            for more info on available methods
+391        allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+392        unsupported: include detected displays that are invalid or unsupported.
+393            This argument does nothing on Windows
+394    '''
+395    # no caching here because get_display_info caches its results
+396    info = get_display_info()
+397
+398    all_methods = get_methods(method).values()
+399
+400    if method is not None:
+401        info = [i for i in info if i['method'] in all_methods]
+402
+403    if allow_duplicates:
+404        return info
+405
+406    try:
+407        # use filter_monitors to remove duplicates
+408        return filter_monitors(haystack=info)
+409    except NoValidDisplayError:
+410        return []
+411
+412
+413METHODS = (WMI, VCP)
+
+ + +
+ +
+
+
+ COM_MODEL = +None + + +
+ + +

The concurrency model and flags used when calling pythoncom.CoInitializeEx. +If left as None the library will call CoInitialize instead with whatever defaults it chooses.

+ +

Refer to the MS docs +for all the possible flags.

+ +

See also:

+ + +
+ + +
+
+ +
+ + def + enum_display_devices() -> collections.abc.Generator[win32api.PyDISPLAY_DEVICEType, None, None]: + + + +
+ + 
61def enum_display_devices() -> Generator[win32api.PyDISPLAY_DEVICEType, None, None]:
+62    '''
+63    Yields all display devices connected to the computer
+64    '''
+65    for monitor_enum in win32api.EnumDisplayMonitors():
+66        pyhandle = monitor_enum[0]
+67        monitor_info = win32api.GetMonitorInfo(pyhandle.handle)
+68        for adaptor_index in range(5):
+69            try:
+70                # EDD_GET_DEVICE_INTERFACE_NAME flag to populate DeviceID field
+71                device = win32api.EnumDisplayDevices(
+72                    monitor_info['Device'], adaptor_index, 1)
+73            except pywintypes.error:
+74                _logger.debug(
+75                    f'failed to get display device {monitor_info["Device"]} on adaptor index {adaptor_index}')
+76            else:
+77                yield device
+78                break
+
+ + +

Yields all display devices connected to the computer

+
+ + +
+
+ +
+ + def + get_display_info() -> List[dict]: + + + +
+ + 
 81def get_display_info() -> List[dict]:
+ 82    '''
+ 83    Gets information about all connected displays using WMI and win32api
+ 84
+ 85    Example:
+ 86        ```python
+ 87        import screen_brightness_control as s
+ 88
+ 89        info = s.windows.get_display_info()
+ 90        for display in info:
+ 91            print(display['name'])
+ 92        ```
+ 93    '''
+ 94    info = __cache__.get('windows_monitors_info_raw')
+ 95    if info is None:
+ 96        info = []
+ 97        # collect all monitor UIDs (derived from DeviceID)
+ 98        monitor_uids = {}
+ 99        for device in enum_display_devices():
+100            monitor_uids[device.DeviceID.split('#')[2]] = device
+101
+102        # gather list of laptop displays to check against later
+103        with _wmi_init() as wmi:
+104            try:
+105                laptop_displays = [
+106                    i.InstanceName
+107                    for i in wmi.WmiMonitorBrightness()
+108                ]
+109            except Exception as e:
+110                # don't do specific exception classes here because WMI does not play ball with it
+111                _logger.warning(
+112                    f'get_display_info: failed to gather list of laptop displays - {format_exc(e)}')
+113                laptop_displays = []
+114
+115            extras, desktop, laptop = [], 0, 0
+116            uid_keys = list(monitor_uids.keys())
+117            for monitor in wmi.WmiMonitorDescriptorMethods():
+118                model, serial, manufacturer, man_id, edid = None, None, None, None, None
+119                instance_name = monitor.InstanceName.replace(
+120                    '_0', '', 1).split('\\')[2]
+121                try:
+122                    pydevice = monitor_uids[instance_name]
+123                except KeyError:
+124                    # if laptop display WAS connected but was later put to sleep (#33)
+125                    if instance_name in laptop_displays:
+126                        laptop += 1
+127                    else:
+128                        desktop += 1
+129                    _logger.warning(
+130                        f'display {instance_name!r} is detected but not present in monitor_uids.'
+131                        ' Maybe it is asleep?'
+132                    )
+133                    continue
+134
+135                # get the EDID
+136                try:
+137                    edid = ''.join(
+138                        f'{char:02x}' for char in monitor.WmiGetMonitorRawEEdidV1Block(0)[0])
+139                    # we do the EDID parsing ourselves because calling wmi.WmiMonitorID
+140                    # takes too long
+141                    parsed = EDID.parse(edid)
+142                    man_id, manufacturer, model, name, serial = parsed
+143                    if name is None:
+144                        raise EDIDParseError(
+145                            'parsed EDID returned invalid display name')
+146                except EDIDParseError as e:
+147                    edid = None
+148                    _logger.warning(
+149                        f'exception parsing edid str for {monitor.InstanceName} - {format_exc(e)}')
+150                except Exception as e:
+151                    edid = None
+152                    _logger.error(
+153                        f'failed to get EDID string for {monitor.InstanceName} - {format_exc(e)}')
+154                finally:
+155                    if edid is None:
+156                        devid = pydevice.DeviceID.split('#')
+157                        serial = devid[2]
+158                        man_id = devid[1][:3]
+159                        model = devid[1][3:] or 'Generic Monitor'
+160                        del devid
+161                        if (brand := _monitor_brand_lookup(man_id)):
+162                            man_id, manufacturer = brand
+163
+164                if (serial, model) != (None, None):
+165                    data: dict = {
+166                        'name': f'{manufacturer} {model}',
+167                        'model': model,
+168                        'serial': serial,
+169                        'manufacturer': manufacturer,
+170                        'manufacturer_id': man_id,
+171                        'edid': edid,
+172                        'uid': uid_match.group(1) if (uid_match := re.search(r"UID(\d+)", instance_name)) else None,
+173                    }
+174                    if monitor.InstanceName in laptop_displays:
+175                        data['index'] = laptop
+176                        data['method'] = WMI
+177                        laptop += 1
+178                    else:
+179                        data['method'] = VCP
+180                        desktop += 1
+181
+182                    if instance_name in uid_keys:
+183                        # insert the data into the uid_keys list because
+184                        # uid_keys has the monitors sorted correctly. This
+185                        # means we don't have to re-sort the list later
+186                        uid_keys[uid_keys.index(instance_name)] = data
+187                    else:
+188                        extras.append(data)
+189
+190        info = uid_keys + extras
+191        if desktop:
+192            # now make sure desktop monitors have the correct index
+193            count = 0
+194            for item in info:
+195                if item['method'] == VCP:
+196                    item['index'] = count
+197                    count += 1
+198
+199        # return info only which has correct data
+200        info = [i for i in info if isinstance(i, dict)]
+201
+202        __cache__.store('windows_monitors_info_raw', info)
+203
+204    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): + + + +
+ + 
207class WMI(BrightnessMethod):
+208    '''
+209    A collection of screen brightness related methods using the WMI API.
+210    This class primarily works with laptop displays.
+211    '''
+212    @classmethod
+213    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+214        info = [i for i in get_display_info() if i['method'] == cls]
+215        if display is not None:
+216            info = filter_monitors(display=display, haystack=info)
+217        return info
+218
+219    @classmethod
+220    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+221        with _wmi_init() as wmi:
+222            brightness_method = wmi.WmiMonitorBrightnessMethods()
+223            if display is not None:
+224                brightness_method = [brightness_method[display]]
+225
+226            for method in brightness_method:
+227                method.WmiSetBrightness(value, 0)
+228
+229    @classmethod
+230    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+231        with _wmi_init() as wmi:
+232            brightness_method = wmi.WmiMonitorBrightness()
+233            if display is not None:
+234                brightness_method = [brightness_method[display]]
+235
+236            values = [i.CurrentBrightness for i in brightness_method]
+237            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]: + + + +
+ + 
212    @classmethod
+213    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+214        info = [i for i in get_display_info() if i['method'] == cls]
+215        if display is not None:
+216            info = filter_monitors(display=display, haystack=info)
+217        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): + + + +
+ + 
219    @classmethod
+220    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None):
+221        with _wmi_init() as wmi:
+222            brightness_method = wmi.WmiMonitorBrightnessMethods()
+223            if display is not None:
+224                brightness_method = [brightness_method[display]]
+225
+226            for method in brightness_method:
+227                method.WmiSetBrightness(value, 0)
+
+ + +
Arguments:
+ + +
+ + +
+
+ +
+
@classmethod
+ + def + get_brightness(cls, display: Optional[int] = None) -> List[int]: + + + +
+ + 
229    @classmethod
+230    def get_brightness(cls, display: Optional[int] = None) -> List[IntPercentage]:
+231        with _wmi_init() as wmi:
+232            brightness_method = wmi.WmiMonitorBrightness()
+233            if display is not None:
+234                brightness_method = [brightness_method[display]]
+235
+236            values = [i.CurrentBrightness for i in brightness_method]
+237            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): + + + +
+ + 
240class VCP(BrightnessMethod):
+241    '''Collection of screen brightness related methods using the DDC/CI commands'''
+242    _logger = _logger.getChild('VCP')
+243
+244    class _PHYSICAL_MONITOR(Structure):
+245        '''internal class, do not call'''
+246        _fields_ = [('handle', HANDLE),
+247                    ('description', WCHAR * 128)]
+248
+249    @classmethod
+250    def iter_physical_monitors(cls, start: int = 0) -> Generator[HANDLE, None, None]:
+251        '''
+252        A generator to iterate through all physical monitors
+253        and then close them again afterwards, yielding their handles.
+254        It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+255
+256        Args:
+257            start: skip the first X handles
+258
+259        Raises:
+260            ctypes.WinError: upon failure to enumerate through the monitors
+261        '''
+262        # user index keeps track of valid monitors
+263        user_index = 0
+264        # monitor index keeps track of valid and pseudo monitors
+265        monitor_index = 0
+266        display_devices = list(enum_display_devices())
+267
+268        with _wmi_init() as wmi:
+269            try:
+270                laptop_displays = [
+271                    i.InstanceName.replace('_0', '').split('\\')[2]
+272                    for i in wmi.WmiMonitorBrightness()
+273                ]
+274            except Exception as e:
+275                cls._logger.warning(
+276                    f'failed to gather list of laptop displays - {format_exc(e)}')
+277                laptop_displays = []
+278
+279        for monitor in map(lambda m: m[0].handle, win32api.EnumDisplayMonitors()):
+280            # Get physical monitor count
+281            count = DWORD()
+282            if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+283                raise WinError(None, 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+284            if count.value > 0:
+285                # Get physical monitor handles
+286                physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+287                if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+288                    raise WinError(None, 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+289                for item in physical_array:
+290                    # check that the monitor is not a pseudo monitor by
+291                    # checking its StateFlags for the
+292                    # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+293                    if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+294                        # check if monitor is actually a laptop display
+295                        if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+296                            if start is None or user_index >= start:
+297                                yield item.handle
+298                            # increment user index as a valid monitor was found
+299                            user_index += 1
+300                    # increment monitor index
+301                    monitor_index += 1
+302                    windll.dxva2.DestroyPhysicalMonitor(item.handle)
+303
+304    @classmethod
+305    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+306        info = [i for i in get_display_info() if i['method'] == cls]
+307        if display is not None:
+308            info = filter_monitors(display=display, haystack=info)
+309        return info
+310
+311    @classmethod
+312    def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+313        '''
+314        Args:
+315            display: the index of the specific display to query.
+316                If unspecified, all detected displays are queried
+317            max_tries: the maximum allowed number of attempts to
+318                read the VCP output from the display
+319
+320        Returns:
+321            See `BrightnessMethod.get_brightness`
+322        '''
+323        code = BYTE(0x10)
+324        values = []
+325        start = display if display is not None else 0
+326        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+327            current = __cache__.get(f'vcp_brightness_{index}')
+328            if current is None:
+329                cur_out = DWORD()
+330                attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+331                for attempt in range(max_tries):
+332                    if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+333                        current = cur_out.value
+334                        break
+335                    current = None
+336                    time.sleep(0.02 if attempt < 20 else 0.1)
+337                else:
+338                    cls._logger.error(
+339                        f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+340
+341            if current is not None:
+342                __cache__.store(
+343                    f'vcp_brightness_{index}', current, expires=0.1)
+344                values.append(current)
+345
+346            if display == index:
+347                # if we've got the display we wanted then exit here, no point iterating through all the others.
+348                # Cleanup function usually called in iter_physical_monitors won't get called if we break, so call now
+349                windll.dxva2.DestroyPhysicalMonitor(handle)
+350                break
+351
+352        return values
+353
+354    @classmethod
+355    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+356        '''
+357        Args:
+358            value: percentage brightness to set the display to
+359            display: The specific display you wish to query.
+360            max_tries: the maximum allowed number of attempts to
+361                send the VCP input to the display
+362        '''
+363        __cache__.expire(startswith='vcp_brightness_')
+364        code = BYTE(0x10)
+365        value_dword = DWORD(value)
+366        start = display if display is not None else 0
+367        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+368            attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+369            for attempt in range(max_tries):
+370                if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+371                    break
+372                time.sleep(0.02 if attempt < 20 else 0.1)
+373            else:
+374                cls._logger.error(
+375                    f'failed to set display:{index}->{value} after {attempt} tries')
+376
+377            if display == index:
+378                # we have the display we wanted, exit and cleanup
+379                windll.dxva2.DestroyPhysicalMonitor(handle)
+380                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]: + + + +
+ + 
249    @classmethod
+250    def iter_physical_monitors(cls, start: int = 0) -> Generator[HANDLE, None, None]:
+251        '''
+252        A generator to iterate through all physical monitors
+253        and then close them again afterwards, yielding their handles.
+254        It is not recommended to use this function unless you are familiar with `ctypes` and `windll`
+255
+256        Args:
+257            start: skip the first X handles
+258
+259        Raises:
+260            ctypes.WinError: upon failure to enumerate through the monitors
+261        '''
+262        # user index keeps track of valid monitors
+263        user_index = 0
+264        # monitor index keeps track of valid and pseudo monitors
+265        monitor_index = 0
+266        display_devices = list(enum_display_devices())
+267
+268        with _wmi_init() as wmi:
+269            try:
+270                laptop_displays = [
+271                    i.InstanceName.replace('_0', '').split('\\')[2]
+272                    for i in wmi.WmiMonitorBrightness()
+273                ]
+274            except Exception as e:
+275                cls._logger.warning(
+276                    f'failed to gather list of laptop displays - {format_exc(e)}')
+277                laptop_displays = []
+278
+279        for monitor in map(lambda m: m[0].handle, win32api.EnumDisplayMonitors()):
+280            # Get physical monitor count
+281            count = DWORD()
+282            if not windll.dxva2.GetNumberOfPhysicalMonitorsFromHMONITOR(monitor, byref(count)):
+283                raise WinError(None, 'call to GetNumberOfPhysicalMonitorsFromHMONITOR returned invalid result')
+284            if count.value > 0:
+285                # Get physical monitor handles
+286                physical_array = (cls._PHYSICAL_MONITOR * count.value)()
+287                if not windll.dxva2.GetPhysicalMonitorsFromHMONITOR(monitor, count.value, physical_array):
+288                    raise WinError(None, 'call to GetPhysicalMonitorsFromHMONITOR returned invalid result')
+289                for item in physical_array:
+290                    # check that the monitor is not a pseudo monitor by
+291                    # checking its StateFlags for the
+292                    # win32con DISPLAY_DEVICE_ATTACHED_TO_DESKTOP flag
+293                    if display_devices[monitor_index].StateFlags & win32con.DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+294                        # check if monitor is actually a laptop display
+295                        if display_devices[monitor_index].DeviceID.split('#')[2] not in laptop_displays:
+296                            if start is None or user_index >= start:
+297                                yield item.handle
+298                            # increment user index as a valid monitor was found
+299                            user_index += 1
+300                    # increment monitor index
+301                    monitor_index += 1
+302                    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]: + + + +
+ + 
304    @classmethod
+305    def get_display_info(cls, display: Optional[DisplayIdentifier] = None) -> List[dict]:
+306        info = [i for i in get_display_info() if i['method'] == cls]
+307        if display is not None:
+308            info = filter_monitors(display=display, haystack=info)
+309        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]: + + + +
+ + 
311    @classmethod
+312    def get_brightness(cls, display: Optional[int] = None, max_tries: int = 50) -> List[IntPercentage]:
+313        '''
+314        Args:
+315            display: the index of the specific display to query.
+316                If unspecified, all detected displays are queried
+317            max_tries: the maximum allowed number of attempts to
+318                read the VCP output from the display
+319
+320        Returns:
+321            See `BrightnessMethod.get_brightness`
+322        '''
+323        code = BYTE(0x10)
+324        values = []
+325        start = display if display is not None else 0
+326        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+327            current = __cache__.get(f'vcp_brightness_{index}')
+328            if current is None:
+329                cur_out = DWORD()
+330                attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+331                for attempt in range(max_tries):
+332                    if windll.dxva2.GetVCPFeatureAndVCPFeatureReply(handle, code, None, byref(cur_out), None):
+333                        current = cur_out.value
+334                        break
+335                    current = None
+336                    time.sleep(0.02 if attempt < 20 else 0.1)
+337                else:
+338                    cls._logger.error(
+339                        f'failed to get VCP feature reply for display:{index} after {attempt} tries')
+340
+341            if current is not None:
+342                __cache__.store(
+343                    f'vcp_brightness_{index}', current, expires=0.1)
+344                values.append(current)
+345
+346            if display == index:
+347                # if we've got the display we wanted then exit here, no point iterating through all the others.
+348                # Cleanup function usually called in iter_physical_monitors won't get called if we break, so call now
+349                windll.dxva2.DestroyPhysicalMonitor(handle)
+350                break
+351
+352        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): + + + +
+ + 
354    @classmethod
+355    def set_brightness(cls, value: IntPercentage, display: Optional[int] = None, max_tries: int = 50):
+356        '''
+357        Args:
+358            value: percentage brightness to set the display to
+359            display: The specific display you wish to query.
+360            max_tries: the maximum allowed number of attempts to
+361                send the VCP input to the display
+362        '''
+363        __cache__.expire(startswith='vcp_brightness_')
+364        code = BYTE(0x10)
+365        value_dword = DWORD(value)
+366        start = display if display is not None else 0
+367        for index, handle in enumerate(cls.iter_physical_monitors(start=start), start=start):
+368            attempt = 0  # avoid UnboundLocalError in else clause if max_tries is 0
+369            for attempt in range(max_tries):
+370                if windll.dxva2.SetVCPFeature(handle, code, value_dword):
+371                    break
+372                time.sleep(0.02 if attempt < 20 else 0.1)
+373            else:
+374                cls._logger.error(
+375                    f'failed to set display:{index}->{value} after {attempt} tries')
+376
+377            if display == index:
+378                # we have the display we wanted, exit and cleanup
+379                windll.dxva2.DestroyPhysicalMonitor(handle)
+380                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]: + + + +
+ + 
383def list_monitors_info(
+384    method: Optional[str] = None, allow_duplicates: bool = False, unsupported: bool = False
+385) -> List[dict]:
+386    '''
+387    Lists detailed information about all detected displays
+388
+389    Args:
+390        method: the method the display can be addressed by. See `.get_methods`
+391            for more info on available methods
+392        allow_duplicates: whether to filter out duplicate displays (displays with the same EDID) or not
+393        unsupported: include detected displays that are invalid or unsupported.
+394            This argument does nothing on Windows
+395    '''
+396    # no caching here because get_display_info caches its results
+397    info = get_display_info()
+398
+399    all_methods = get_methods(method).values()
+400
+401    if method is not None:
+402        info = [i for i in info if i['method'] in all_methods]
+403
+404    if allow_duplicates:
+405        return info
+406
+407    try:
+408        # use filter_monitors to remove duplicates
+409        return filter_monitors(haystack=info)
+410    except NoValidDisplayError:
+411        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.24.1/search.js b/docs/0.24.1/search.js new file mode 100644 index 0000000..d06e241 --- /dev/null +++ b/docs/0.24.1/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
  • allow_duplicates: controls whether to filter out duplicate displays or not.
    • \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,\tallow_duplicates: Optional[bool] = 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
  • allow_duplicates: controls whether to filter out duplicate displays or not.
    • \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,\tallow_duplicates: Optional[bool] = None,\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
  • stoppable: whether the fade can be stopped by starting a new fade on the same display
    • \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,\tstoppable: 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: controls 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    # The UID of the display\n    print('UID:', display['uid'])\n
\n
\n
\n", "signature": "(\tmethod: Optional[str] = None,\tallow_duplicates: Optional[bool] = None,\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
  • allow_duplicates: controls whether to filter out duplicate displays or not.
    • \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": "(\tmethod: Optional[str] = None,\tallow_duplicates: Optional[bool] = 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],\tuid: Optional[str] = None,\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.uid": {"fullname": "screen_brightness_control.Display.uid", "modulename": "screen_brightness_control", "qualname": "Display.uid", "kind": "variable", "doc": "

A unique identifier for the display. This is usually inferred from the display's connection to the machine.

\n", "annotation": ": Optional[str]", "default_value": "None"}, "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.\nCan execute in the current thread, blocking until completion,\nor in a separate thread, allowing concurrent operations.\nWhen set as non-blocking and stoppable, a new fade can halt the this operation.

\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
  • blocking: run this function in the current thread and block until it completes
    • \n
  • stoppable: whether this fade will be stopped by starting a new fade on the same display
    • \n
\n\n
Returns:
\n\n
\n

If blocking is False, returns a threading.Thread object representing the\n thread in which the fade operation is running.\n Otherwise, it returns None.

\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,\tblocking: bool = True,\tstoppable: bool = True) -> Optional[threading.Thread]:", "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 UID, 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.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
  • allow_duplicates: controls whether to filter out duplicate displays or not
    • \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] = [],\tallow_duplicates: Optional[bool] = None) -> List[dict]:", "funcdef": "def"}, "screen_brightness_control.config": {"fullname": "screen_brightness_control.config", "modulename": "screen_brightness_control.config", "kind": "module", "doc": "

Contains globally applicable configuration variables.

\n"}, "screen_brightness_control.config.default_params": {"fullname": "screen_brightness_control.config.default_params", "modulename": "screen_brightness_control.config", "qualname": "default_params", "kind": "function", "doc": "

This decorator sets default kwarg values using global configuration variables.

\n", "signature": "(func: Callable):", "funcdef": "def"}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"fullname": "screen_brightness_control.config.ALLOW_DUPLICATES", "modulename": "screen_brightness_control.config", "qualname": "ALLOW_DUPLICATES", "kind": "variable", "doc": "

Default value for the allow_duplicates parameter in top-level functions.

\n", "annotation": ": bool", "default_value": "False"}, "screen_brightness_control.config.METHOD": {"fullname": "screen_brightness_control.config.METHOD", "modulename": "screen_brightness_control.config", "qualname": "METHOD", "kind": "variable", "doc": "

Default value for the method parameter in top-level functions.

\n\n

For available values, see .get_methods

\n", "annotation": ": Optional[str]", "default_value": "None"}, "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.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.i2c_bus_from_drm_device": {"fullname": "screen_brightness_control.linux.i2c_bus_from_drm_device", "modulename": "screen_brightness_control.linux", "qualname": "i2c_bus_from_drm_device", "kind": "function", "doc": "

Extract the relevant I2C bus number from a device in /sys/class/drm.

\n\n

This function works by searching the directory for i2c-* and ddc/i2c-dev/i2c-* folders.

\n\n
Arguments:
\n\n
    \n
  • dir: the DRM directory, in the format /sys/class/drm/<device>
    • \n
\n\n
Returns:
\n\n
\n

Returns the I2C bus number as a string if found. Otherwise, returns None

\n
\n", "signature": "(dir: str) -> Optional[str]:", "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'>)"}, "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
  • uid (str)
    • \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.COM_MODEL": {"fullname": "screen_brightness_control.windows.COM_MODEL", "modulename": "screen_brightness_control.windows", "qualname": "COM_MODEL", "kind": "variable", "doc": "

The concurrency model and flags used when calling pythoncom.CoInitializeEx.\nIf left as None the library will call CoInitialize instead with whatever defaults it chooses.

\n\n

Refer to the MS docs\nfor all the possible flags.

\n\n

See also:

\n\n\n", "default_value": "None"}, "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": 123, "bases": 0, "doc": 266}, "screen_brightness_control.set_brightness": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 187, "bases": 0, "doc": 401}, "screen_brightness_control.fade_brightness": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 214, "bases": 0, "doc": 512}, "screen_brightness_control.list_monitors_info": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 82, "bases": 0, "doc": 534}, "screen_brightness_control.list_monitors": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 64, "bases": 0, "doc": 123}, "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": 213, "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.uid": {"qualname": 2, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 21}, "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": 194, "bases": 0, "doc": 256}, "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": 69}, "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.filter_monitors": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 152, "bases": 0, "doc": 269}, "screen_brightness_control.config": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 8}, "screen_brightness_control.config.default_params": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 13}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 16}, "screen_brightness_control.config.METHOD": {"qualname": 1, "fullname": 5, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 26}, "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.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.i2c_bus_from_drm_device": {"qualname": 5, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 85}, "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": 42, "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": 67}, "screen_brightness_control.windows": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "screen_brightness_control.windows.COM_MODEL": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 87}, "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": 119, "save": true}, "index": {"qualname": {"root": {"docs": {"screen_brightness_control.Display.__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": 4, "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.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.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": 21, "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.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.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": 20, "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}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"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.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.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": 10, "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}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"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}}}, "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.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 2}}}}, "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}, "screen_brightness_control.config.METHOD": {"tf": 1}}, "df": 2, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 27, "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.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.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": 11}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.__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": 4}}, "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}}, "df": 1}}}}}}}}}, "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.uid": {"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.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}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}}, "df": 1}}}}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"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": {}, "df": 0, "s": {"docs": {"screen_brightness_control.config.ALLOW_DUPLICATES": {"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}}}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.uid": {"tf": 1}}, "df": 1}}}, "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.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 2}}}}}}}}}, "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}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.config.ALLOW_DUPLICATES": {"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}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}}, "df": 1}}}, "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}}}}}}}}, "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}}}, "m": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"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}}}, "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.exceptions.MaxRetriesExceededError.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.I2CDevice.__init__": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.__init__": {"tf": 1}}, "df": 4, "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.uid": {"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.filter_monitors": {"tf": 1}, "screen_brightness_control.config": {"tf": 1}, "screen_brightness_control.config.default_params": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"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.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.i2c_bus_from_drm_device": {"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.COM_MODEL": {"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": 119, "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.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.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": 10, "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.uid": {"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.filter_monitors": {"tf": 1}, "screen_brightness_control.config": {"tf": 1}, "screen_brightness_control.config.default_params": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"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.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.i2c_bus_from_drm_device": {"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.COM_MODEL": {"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": 119, "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}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"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.uid": {"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.filter_monitors": {"tf": 1}, "screen_brightness_control.config": {"tf": 1}, "screen_brightness_control.config.default_params": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"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.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.i2c_bus_from_drm_device": {"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.COM_MODEL": {"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": 119}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.config": {"tf": 1}, "screen_brightness_control.config.default_params": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}}, "df": 4}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1}}}, "m": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"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.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.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": 21, "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}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"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.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.i2c_bus_from_drm_device": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.linux.METHODS": {"tf": 1}}, "df": 47}}}}, "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.helpers.MONITOR_MANUFACTURER_CODES": {"tf": 1}}, "df": 1, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 2}}}}, "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}, "screen_brightness_control.config.METHOD": {"tf": 1}}, "df": 2, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 27, "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.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.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": 11}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.__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": 4}}, "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}}, "df": 1}}}}}}}}}, "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.uid": {"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.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}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}}, "df": 1}}}}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"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": {}, "df": 0, "s": {"docs": {"screen_brightness_control.config.ALLOW_DUPLICATES": {"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}}}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.uid": {"tf": 1}}, "df": 1}}}, "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.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 2}}}}}}}}}, "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}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"screen_brightness_control.config.ALLOW_DUPLICATES": {"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}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}}, "df": 1}}}, "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, "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}}}}, "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.COM_MODEL": {"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": 15}}}}}}, "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.uid": {"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.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}, "screen_brightness_control.exceptions.MaxRetriesExceededError.message": {"tf": 1}, "screen_brightness_control.helpers.EDID.EDID_FORMAT": {"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": 17, "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}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.config.ALLOW_DUPLICATES": {"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.uid": {"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.config.METHOD": {"tf": 1}}, "df": 8}}}}}}}}}}}}, "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.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 4}}}, "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.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": 9, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.uid": {"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.config.METHOD": {"tf": 1}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 9}}, "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}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}}, "df": 1}}}}, "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}}}, "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.XRandr.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.METHODS": {"tf": 2.8284271247461903}, "screen_brightness_control.types.IntPercentage": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.METHODS": {"tf": 2}}, "df": 9}, "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}, "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}, "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}, "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}, "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}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "e": {"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}}}, "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}, "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}}}, "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}, "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": 10.04987562112089}, "screen_brightness_control.set_brightness": {"tf": 12.36931687685298}, "screen_brightness_control.fade_brightness": {"tf": 13.30413469565007}, "screen_brightness_control.list_monitors_info": {"tf": 8.246211251235321}, "screen_brightness_control.list_monitors": {"tf": 7.280109889280518}, "screen_brightness_control.get_methods": {"tf": 7}, "screen_brightness_control.Display.__init__": {"tf": 13.228756555322953}, "screen_brightness_control.Display.fade_brightness": {"tf": 12.68857754044952}, "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.filter_monitors": {"tf": 11.269427669584644}, "screen_brightness_control.config.default_params": {"tf": 3.7416573867739413}, "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.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.i2c_bus_from_drm_device": {"tf": 4.58257569495584}, "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": 56, "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.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.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": 25}}}}}, "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.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.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": 14}}, "r": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"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": {}, "df": 0, "s": {"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.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 7}}}}}}}}}, "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.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.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": 16}}}, "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}}}}}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.__init__": {"tf": 1}}, "df": 1}}}, "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.6457513110645907}, "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.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.XRandr.get_display_info": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}, "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": 28}, "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, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}}}}, "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}}, "df": 3}}}}}, "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.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": 11}}}, "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": 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.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.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": 41, "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}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.set_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.fade_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.__init__": {"tf": 2.6457513110645907}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 2}, "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.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": 36, "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.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": 13}}}}}}}, "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}}}}}, "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.7320508075688772}, "screen_brightness_control.set_brightness": {"tf": 2}, "screen_brightness_control.fade_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.__init__": {"tf": 2.6457513110645907}, "screen_brightness_control.Display.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}, "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.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.i2c_bus_from_drm_device": {"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": 27}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"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.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 7}}}}, "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}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"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}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.set_brightness": {"tf": 2}, "screen_brightness_control.fade_brightness": {"tf": 2}, "screen_brightness_control.list_monitors_info": {"tf": 1.4142135623730951}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 2}, "screen_brightness_control.Display.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"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.4142135623730951}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1.4142135623730951}}, "df": 12}}, "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.Display.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.linux.XRandr.get_display_info": {"tf": 1}}, "df": 4, "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}}}}}, "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.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.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": 11}}}}, "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}}}, "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}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.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": 9}}}}, "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}}, "df": 4}}}}, "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}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}}, "df": 1}}}, "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.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": 24}}}, "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}}, "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.7320508075688772}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}}, "df": 3}}, "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.Display.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.Display.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.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.I2C.DDCInterface.getvcp": {"tf": 1}}, "df": 3}}}}}, "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}}, "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}}, "df": 3}}}}}, "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.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.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": 24}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1}}, "df": 2}}}}, "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}}}}}}}}}}}}}}}}}, "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, "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.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": 6, "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.windows.WMI": {"tf": 1}, "screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 5, "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.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": 6, "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.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": 6}}}}}}}, "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.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": 6}}}}}}}, "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.4142135623730951}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}}, "df": 9, "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}}, "df": 1}}}}, "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.exceptions.MaxRetriesExceededError": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 6, "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}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "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}, "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": 6.164414002968976}, "screen_brightness_control.list_monitors": {"tf": 2}, "screen_brightness_control.get_methods": {"tf": 2.449489742783178}, "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": 9}, "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}}, "df": 2}}}, "4": {"0": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 2}}, "df": 1}, "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.704699910719626}, "screen_brightness_control.set_brightness": {"tf": 13.711309200802088}, "screen_brightness_control.fade_brightness": {"tf": 15.132745950421556}, "screen_brightness_control.list_monitors_info": {"tf": 17.549928774784245}, "screen_brightness_control.list_monitors": {"tf": 8}, "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.uid": {"tf": 1.7320508075688772}, "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.937253933193772}, "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.filter_monitors": {"tf": 11.090536506409418}, "screen_brightness_control.config": {"tf": 1.7320508075688772}, "screen_brightness_control.config.default_params": {"tf": 1.7320508075688772}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 2.23606797749979}, "screen_brightness_control.config.METHOD": {"tf": 3.1622776601683795}, "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.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.i2c_bus_from_drm_device": {"tf": 5.916079783099616}, "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": 5.0990195135927845}, "screen_brightness_control.windows": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.COM_MODEL": {"tf": 5.656854249492381}, "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": 119, "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.get_identifier": {"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": 13, "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.7320508075688772}, "screen_brightness_control.Display.get_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"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.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.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.i2c_bus_from_drm_device": {"tf": 1.7320508075688772}, "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": 31}, "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.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": 10}}}}}, "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.Display.fade_brightness": {"tf": 1}, "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": 9}}}}}}}}}, "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}}}}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 2}}}}}, "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, "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}}}, "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}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1, "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}}}}}}}}, "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}}}}}}}}}, "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.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.check_output": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 3, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}}}, "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}}, "df": 3, "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.47213595499958}, "screen_brightness_control.list_monitors_info": {"tf": 4.58257569495584}, "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.uid": {"tf": 1.7320508075688772}, "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.7416573867739413}, "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.filter_monitors": {"tf": 3.1622776601683795}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}, "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.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.i2c_bus_from_drm_device": {"tf": 2.23606797749979}, "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.COM_MODEL": {"tf": 2}, "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": 89, "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.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 4}, "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.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.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": 13}}, "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.uid": {"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.is_active": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.config.default_params": {"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.linux.i2c_bus_from_drm_device": {"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": {"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": 34}}, "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.Display.fade_brightness": {"tf": 2.23606797749979}}, "df": 2, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.Display.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.filter_monitors": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}}, "df": 5, "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.4142135623730951}, "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.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.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": 28}, "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": 2}, "screen_brightness_control.set_brightness": {"tf": 3}, "screen_brightness_control.fade_brightness": {"tf": 3.3166247903554}, "screen_brightness_control.list_monitors_info": {"tf": 2}, "screen_brightness_control.list_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.get_methods": {"tf": 1}, "screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.uid": {"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.filter_monitors": {"tf": 2.449489742783178}, "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.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.COM_MODEL": {"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": 68, "p": {"docs": {"screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}}, "df": 2}, "o": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"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.helpers.EDID.parse": {"tf": 1}}, "df": 1, "[": {"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}}}}, "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.7320508075688772}, "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": 8}}}}, "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.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": 10, "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}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 5}, "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}}}}}, "/": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"4": {"2": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}}}}}}, "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.types": {"tf": 1}}, "df": 3}}}, "s": {"docs": {"screen_brightness_control.config": {"tf": 1}}, "df": 1}}}}}, "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}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Display.uid": {"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.Display.fade_brightness": {"tf": 1}}, "df": 1}, "c": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "u": {"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.config": {"tf": 1}, "screen_brightness_control.config.default_params": {"tf": 1}}, "df": 2}}}}}}}}}}, "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, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.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}, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"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.windows.COM_MODEL": {"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}}}}}}}}, "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": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "x": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}}, "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.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 3, "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}}}, "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}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.helpers.percentage": {"tf": 1.7320508075688772}, "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}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.XRandr.executable": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.executable": {"tf": 1}}, "df": 2, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 3}}}}}, "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}}}}}}}}}}, "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.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": 11, "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.helpers.BrightnessMethod": {"tf": 1}, "screen_brightness_control.helpers.BrightnessMethodAdv": {"tf": 1}}, "df": 2}}}}}, "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": 2.8284271247461903}, "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.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.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.COM_MODEL": {"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.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": 44, "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.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": 8}}}}}}}}}}}}}}, "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": 2}, "screen_brightness_control.list_monitors_info": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "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.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": 16, "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.filter_monitors": {"tf": 1}}, "df": 4}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1}}, "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.7320508075688772}, "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.i2c_bus_from_drm_device": {"tf": 1}, "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.Display.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.Display.fade_brightness": {"tf": 2}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}}, "df": 5}}}, "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.6457513110645907}, "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}, "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.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.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": 58, "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}, "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.4142135623730951}, "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.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.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.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": 12}, "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.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.4142135623730951}, "screen_brightness_control.list_monitors": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.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": 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": 23, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.helpers.EDID.parse": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"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.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 7, "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.windows.VCP.get_brightness": {"tf": 1}}, "df": 4}}}}}, "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.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 4}}}}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}}, "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, "e": {"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.Display.fade_brightness": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}}}}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.fade_brightness": {"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.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": 8, "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.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": 14}}}}}}, "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.COM_MODEL": {"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": 12}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1, "t": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1, "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.config.METHOD": {"tf": 1}, "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": 18, "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.config.METHOD": {"tf": 1}, "screen_brightness_control.linux.XRandr": {"tf": 1}, "screen_brightness_control.linux.DDCUtil": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1.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": 13}}}}}, "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}}, "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}}}}}}}}}, "y": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}, "screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "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}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.uid": {"tf": 1}}, "df": 1}}}}}, "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}}}, "s": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"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.7320508075688772}, "screen_brightness_control.list_monitors_info": {"tf": 4.242640687119285}, "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.uid": {"tf": 1.4142135623730951}, "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.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.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": 51, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 2}, "screen_brightness_control.set_brightness": {"tf": 2}, "screen_brightness_control.fade_brightness": {"tf": 1.7320508075688772}, "screen_brightness_control.list_monitors_info": {"tf": 2.6457513110645907}, "screen_brightness_control.list_monitors": {"tf": 1.7320508075688772}, "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.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.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": 32}, "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.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": 10}}}}}}}}}}}}}}, "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": {}, "df": 0, "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.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}}}}}}}}, "r": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}}, "df": 2}}}, "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}}}}}}}, "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.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.filter_monitors": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 7, "s": {"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.filter_monitors": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 8}}}}}}}}}, "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.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": 26}}}}, "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}, "screen_brightness_control.config.default_params": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}}, "df": 7, "s": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 3}}}}}, "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}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.config.default_params": {"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}}, "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}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "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}}}}}}}}}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 4}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}}, "df": 7, "s": {"docs": {"screen_brightness_control.windows.enum_display_devices": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 4, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}, "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}}, "df": 1}}}}}}, "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}}}}}}, "p": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1}, "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, "i": {"2": {"docs": {}, "df": 0, "c": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1}}, "docs": {}, "df": 0}, "c": {"docs": {}, "df": 0, "i": {"docs": {"screen_brightness_control.windows.VCP": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"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.449489742783178}, "screen_brightness_control.Display": {"tf": 1}, "screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.uid": {"tf": 1}, "screen_brightness_control.Display.edid": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.fade_brightness": {"tf": 2.6457513110645907}, "screen_brightness_control.Display.from_dict": {"tf": 1}, "screen_brightness_control.Display.get_brightness": {"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.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.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}, "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": 46, "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.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.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.i2c_bus_from_drm_device": {"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": 47}}}}}}, "s": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}, "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.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": 23}}, "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.config.METHOD": {"tf": 1}, "screen_brightness_control.linux.list_monitors_info": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 10}}}}}}}}, "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.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.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.COM_MODEL": {"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": 25, "o": {"docs": {}, "df": 0, "w": {"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}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"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": 11, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}, "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.helpers.percentage": {"tf": 1}, "screen_brightness_control.types": {"tf": 1}, "screen_brightness_control.windows.COM_MODEL": {"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}}}}}}, "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.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.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}}, "df": 12, "y": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.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.types.DisplayIdentifier": {"tf": 1}}, "df": 6}, "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.4142135623730951}, "screen_brightness_control.Display.get_identifier": {"tf": 1.7320508075688772}, "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.i2c_bus_from_drm_device": {"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.COM_MODEL": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1.4142135623730951}}, "df": 24}}, "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.4142135623730951}, "screen_brightness_control.Display.get_brightness": {"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.i2c_bus_from_drm_device": {"tf": 1}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 16, "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}}}}, "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.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}}, "df": 7, "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.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}}, "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.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": 11}}}, "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}}}}}}}, "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, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.config": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {"screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"tf": 1}}, "df": 1, "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}}}}}}}}}}, "s": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.uid": {"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": 5, "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.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": 24, "a": {"docs": {}, "df": 0, "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}, "screen_brightness_control.Display.get_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1}, "screen_brightness_control.config.METHOD": {"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.COM_MODEL": {"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": 22}, "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}}, "df": 1}}}, "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": 2}, "screen_brightness_control.Display.set_brightness": {"tf": 1.7320508075688772}, "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": 11, "s": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1}, "screen_brightness_control.Display.set_brightness": {"tf": 1}, "screen_brightness_control.config.default_params": {"tf": 1}}, "df": 3}, "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.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": 13}}}, "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}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}}}}, "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}}}}}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 2}}}}}}}, "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}}}, "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.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": 14}}}}}, "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.filter_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.helpers.EDID.parse": {"tf": 1.7320508075688772}}, "df": 8}}, "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}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.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}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}}, "df": 1, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 2}}}}}, "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": 2}, "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.linux.i2c_bus_from_drm_device": {"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": 13, "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}}}}}}}}, "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}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "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": 5}}, "i": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.get_identifier": {"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}}}, "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}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}}, "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}}, "df": 1}}}}}}}, "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.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": 10}, "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.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": 8}}}}}}}, "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.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": 9, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 4}, "r": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.Display.uid": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}, "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": 11}}}, "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.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": 14}}}}}}}}}, "i": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.uid": {"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}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}}, "df": 1}}}, "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}}, "df": 1}}}}}}, "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.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 1}}}}}, "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.types.DisplayIdentifier": {"tf": 1}}, "df": 3}}, "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.types": {"tf": 1}}, "df": 4, "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}}}}}}}, "k": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"3": {"2": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}}}, "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.filter_monitors": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}, "screen_brightness_control.linux.I2C.GET_VCP_CMD": {"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.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.list_monitors_info": {"tf": 1}}, "df": 14, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 2}, "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.filter_monitors": {"tf": 1.7320508075688772}}, "df": 3}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.config.default_params": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"screen_brightness_control.config": {"tf": 1}}, "df": 1}}}}}}}}, "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.uid": {"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.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1.4142135623730951}, "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.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.i2c_bus_from_drm_device": {"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.COM_MODEL": {"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": 38, "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}}, "df": 4}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1, "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}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"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.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.7320508075688772}, "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": 14}}}, "e": {"docs": {"screen_brightness_control.helpers.EDID.hexdump": {"tf": 1.7320508075688772}, "screen_brightness_control.types": {"tf": 1}}, "df": 2}}, "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}}, "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.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}}}}, "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.Display.fade_brightness": {"tf": 1}}, "df": 3}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 3.872983346207417}, "screen_brightness_control.Display.fade_brightness": {"tf": 2.23606797749979}}, "df": 2, "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.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.linux.i2c_bus_from_drm_device": {"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.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}, "screen_brightness_control.helpers": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.Display.set_brightness": {"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.uid": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.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.linux.i2c_bus_from_drm_device": {"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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 2}}}}, "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}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1.7320508075688772}}, "df": 13, "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": 2.23606797749979}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}, "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.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.get_display_info": {"tf": 1}}, "df": 17, "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.filter_monitors": {"tf": 1.7320508075688772}, "screen_brightness_control.helpers.EDID.parse": {"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": 10, "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.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": 15}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.Display.uid": {"tf": 1}}, "df": 1}}}}}}, "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.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.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": 17}}}}}}}}}}, "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.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.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": 25}}}, "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}}}}}}, "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}}, "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}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "a": {"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.COM_MODEL": {"tf": 1}}, "df": 3}}}}}, "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.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": 10}}}, "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.XRandr.get_display_info": {"tf": 1}}, "df": 1}}}}}}, "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.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.is_active": {"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.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.i2c_bus_from_drm_device": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1}, "screen_brightness_control.windows.COM_MODEL": {"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": 29}, "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.uid": {"tf": 1}, "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.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": 29, "n": {"docs": {"screen_brightness_control.filter_monitors": {"tf": 1}}, "df": 1}}, "t": {"docs": {"screen_brightness_control.Display.index": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.Display.is_active": {"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.windows.COM_MODEL": {"tf": 1}, "screen_brightness_control.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 10, "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.windows.VCP.iter_physical_monitors": {"tf": 1}}, "df": 2}, "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.Display.uid": {"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.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}}, "df": 1}}}}}}}}, "w": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"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.fade_brightness": {"tf": 1.4142135623730951}, "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.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": 10}}}}, "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}}, "n": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 9}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.Display.method": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 3}}}, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 2}}}}}}}, "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.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.DDCUtil.get_display_info": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.7320508075688772}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}, "screen_brightness_control.windows.WMI.get_display_info": {"tf": 1}, "screen_brightness_control.windows.VCP.get_display_info": {"tf": 1}}, "df": 19}}, "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.COM_MODEL": {"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": 19, "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}}}}}}, "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}}}}}}}, "s": {"docs": {}, "df": 0, "h": {"docs": {"screen_brightness_control.windows.VCP.set_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.is_active": {"tf": 1}, "screen_brightness_control.linux.SysFiles": {"tf": 1}, "screen_brightness_control.linux.I2C": {"tf": 1}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}, "screen_brightness_control.windows.WMI": {"tf": 1}}, "df": 5}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}}, "df": 1}}}}, "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}}}, "r": {"docs": {}, "df": 0, "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, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"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}}}}}}}}, "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}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"screen_brightness_control.set_brightness": {"tf": 1.4142135623730951}}, "df": 1, "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.Display.index": {"tf": 1}, "screen_brightness_control.Display.serial": {"tf": 1}, "screen_brightness_control.Display.get_identifier": {"tf": 1}, "screen_brightness_control.filter_monitors": {"tf": 1.7320508075688772}, "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": 16, "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}}}}, "n": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1, "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.helpers.EDID.parse": {"tf": 1.4142135623730951}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 7}}, "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": 2}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "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.XRandr.set_brightness": {"tf": 1}, "screen_brightness_control.linux.DDCUtil.set_brightness": {"tf": 1}, "screen_brightness_control.windows.WMI.set_brightness": {"tf": 1}}, "df": 10}, "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.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": 18, "s": {"docs": {"screen_brightness_control.list_monitors": {"tf": 1.4142135623730951}, "screen_brightness_control.get_methods": {"tf": 1}}, "df": 2}}}}, "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.linux.i2c_bus_from_drm_device": {"tf": 1.4142135623730951}, "screen_brightness_control.windows.VCP.get_brightness": {"tf": 1}, "screen_brightness_control.windows.VCP.set_brightness": {"tf": 1}}, "df": 11}}}}}}, "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}, "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.types": {"tf": 1}}, "df": 1}}}}}}, "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}, "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.filter_monitors": {"tf": 1}, "screen_brightness_control.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"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.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": 23, "s": {"docs": {"screen_brightness_control.get_brightness": {"tf": 1}, "screen_brightness_control.Display.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.config.default_params": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}, "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.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": 15}, "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, "s": {"docs": {"screen_brightness_control.config": {"tf": 1}, "screen_brightness_control.config.default_params": {"tf": 1}}, "df": 2}}}}}, "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}}, "df": 2, "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.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": 18}}, "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.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": 12}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"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": 4}}}}}}}}, "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.helpers.EDID": {"tf": 1}, "screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 2}}}}}, "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}}}}}}}}}}}, "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.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": 11}, "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.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": 17, "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}}, "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.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"tf": 1}, "screen_brightness_control.types.IntPercentage": {"tf": 1}, "screen_brightness_control.types.Percentage": {"tf": 1.4142135623730951}}, "df": 8}}}, "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}}}}, "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}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1}}}, "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.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.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": 21, "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}, "screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 4}}}}}, "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}}}, "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}}}, "a": {"docs": {}, "df": 0, "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}}}}}, "t": {"docs": {"screen_brightness_control.linux.i2c_bus_from_drm_device": {"tf": 1}}, "df": 1}}, "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}}, "df": 1}, "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.1622776601683795}, "screen_brightness_control.get_methods": {"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": 6}}}, "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.types.DisplayIdentifier": {"tf": 1}}, "df": 2}, "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}}, "df": 1}}}}}, "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.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": 9, "s": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.linux.I2C": {"tf": 1}}, "df": 1, "s": {"docs": {"screen_brightness_control.linux.SysFiles": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1.4142135623730951}, "screen_brightness_control.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}}}}, "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.config.ALLOW_DUPLICATES": {"tf": 1}, "screen_brightness_control.config.METHOD": {"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}}}}}}, "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}}, "df": 2}, "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}}}, "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, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.linux.I2C.DDCInterface.write": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"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}}}}}}}}, "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}, "screen_brightness_control.config.default_params": {"tf": 1}}, "df": 2, "s": {"docs": {"screen_brightness_control.fade_brightness": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"screen_brightness_control.Display.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": 7}}}}, "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, "l": {"docs": {}, "df": 0, "t": {"docs": {"screen_brightness_control.Display.fade_brightness": {"tf": 1}}, "df": 1}}, "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}}}, "s": {"docs": {"screen_brightness_control.exceptions.MaxRetriesExceededError": {"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}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "l": {"docs": {"screen_brightness_control.windows.COM_MODEL": {"tf": 1.4142135623730951}}, "df": 1}}}}, "y": {"docs": {"screen_brightness_control.helpers.logarithmic_range": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {"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": 4, "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 cf7c82c..e88a76c 100644 --- a/extras/Examples.html +++ b/extras/Examples.html @@ -58,7 +58,7 @@

License

-
screen_brightness_control v0.24.0
+
screen_brightness_control v0.24.1
diff --git a/extras/FAQ.html b/extras/FAQ.html index 8d962e1..72d4195 100644 --- a/extras/FAQ.html +++ b/extras/FAQ.html @@ -60,7 +60,7 @@

License

-
screen_brightness_control v0.24.0
+
screen_brightness_control v0.24.1
diff --git a/extras/Installing On Linux.html b/extras/Installing On Linux.html index c4ec5ae..eb2100d 100644 --- a/extras/Installing On Linux.html +++ b/extras/Installing On Linux.html @@ -66,7 +66,7 @@

License

-
screen_brightness_control v0.24.0
+
screen_brightness_control v0.24.1
diff --git a/extras/Quick Start Guide.html b/extras/Quick Start Guide.html index a756ee3..3b01a27 100644 --- a/extras/Quick Start Guide.html +++ b/extras/Quick Start Guide.html @@ -61,7 +61,7 @@

License

-
screen_brightness_control v0.24.0
+
screen_brightness_control v0.24.1
diff --git a/source.html b/source.html index d7cdcde..a53d9d3 100644 --- a/source.html +++ b/source.html @@ -54,7 +54,7 @@

License

-
screen_brightness_control v0.24.0
+
screen_brightness_control v0.24.1
diff --git a/version_navigator.js b/version_navigator.js index 6348b0e..072286f 100644 --- a/version_navigator.js +++ b/version_navigator.js @@ -1,4 +1,4 @@ -var all_nav_links={"API Version":{"docs/0.24.0":[],"docs/0.23.0":[],"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.24.0"};function newElement(parent,elem){var element=document.createElement(elem);parent.appendChild(element);return element;} +var all_nav_links={"API Version":{"docs/0.24.1":["docs/0.24.0"],"docs/0.23.0":[],"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.24.1"};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;}