Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 216 insertions, 216 deletions

diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/layout/dimension.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/layout/dimension.py
index 04c21637cb..128e51388f 100644
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/layout/dimension.py
+++ b/contrib/python/prompt-toolkit/py3/prompt_toolkit/layout/dimension.py
@@ -1,217 +1,217 @@
-"""
-Layout dimensions are used to give the minimum, maximum and preferred
-dimensions for containers and controls.
-"""
-from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
-
-__all__ = [
-    "Dimension",
-    "D",
-    "sum_layout_dimensions",
-    "max_layout_dimensions",
-    "AnyDimension",
-    "to_dimension",
-    "is_dimension",
-]
-
-if TYPE_CHECKING:
-    from typing_extensions import TypeGuard
-
-
-class Dimension:
-    """
-    Specified dimension (width/height) of a user control or window.
-
-    The layout engine tries to honor the preferred size. If that is not
-    possible, because the terminal is larger or smaller, it tries to keep in
-    between min and max.
-
-    :param min: Minimum size.
-    :param max: Maximum size.
-    :param weight: For a VSplit/HSplit, the actual size will be determined
-                   by taking the proportion of weights from all the children.
-                   E.g. When there are two children, one with a weight of 1,
-                   and the other with a weight of 2, the second will always be
-                   twice as big as the first, if the min/max values allow it.
-    :param preferred: Preferred size.
-    """
-
-    def __init__(
-        self,
-        min: Optional[int] = None,
-        max: Optional[int] = None,
-        weight: Optional[int] = None,
-        preferred: Optional[int] = None,
-    ) -> None:
-        if weight is not None:
-            assert weight >= 0  # Also cannot be a float.
-
-        assert min is None or min >= 0
-        assert max is None or max >= 0
-        assert preferred is None or preferred >= 0
-
-        self.min_specified = min is not None
-        self.max_specified = max is not None
-        self.preferred_specified = preferred is not None
-        self.weight_specified = weight is not None
-
-        if min is None:
-            min = 0  # Smallest possible value.
-        if max is None:  # 0-values are allowed, so use "is None"
+""" 
+Layout dimensions are used to give the minimum, maximum and preferred 
+dimensions for containers and controls. 
+""" 
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union 
+ 
+__all__ = [ 
+    "Dimension", 
+    "D", 
+    "sum_layout_dimensions", 
+    "max_layout_dimensions", 
+    "AnyDimension", 
+    "to_dimension", 
+    "is_dimension", 
+] 
+ 
+if TYPE_CHECKING: 
+    from typing_extensions import TypeGuard 
+ 
+ 
+class Dimension: 
+    """ 
+    Specified dimension (width/height) of a user control or window. 
+ 
+    The layout engine tries to honor the preferred size. If that is not 
+    possible, because the terminal is larger or smaller, it tries to keep in 
+    between min and max. 
+ 
+    :param min: Minimum size. 
+    :param max: Maximum size. 
+    :param weight: For a VSplit/HSplit, the actual size will be determined 
+                   by taking the proportion of weights from all the children. 
+                   E.g. When there are two children, one with a weight of 1, 
+                   and the other with a weight of 2, the second will always be 
+                   twice as big as the first, if the min/max values allow it. 
+    :param preferred: Preferred size. 
+    """ 
+ 
+    def __init__( 
+        self, 
+        min: Optional[int] = None, 
+        max: Optional[int] = None, 
+        weight: Optional[int] = None, 
+        preferred: Optional[int] = None, 
+    ) -> None: 
+        if weight is not None: 
+            assert weight >= 0  # Also cannot be a float. 
+ 
+        assert min is None or min >= 0 
+        assert max is None or max >= 0 
+        assert preferred is None or preferred >= 0 
+ 
+        self.min_specified = min is not None 
+        self.max_specified = max is not None 
+        self.preferred_specified = preferred is not None 
+        self.weight_specified = weight is not None 
+ 
+        if min is None: 
+            min = 0  # Smallest possible value. 
+        if max is None:  # 0-values are allowed, so use "is None" 
             max = 1000**10  # Something huge.
-        if preferred is None:
-            preferred = min
-        if weight is None:
-            weight = 1
-
-        self.min = min
-        self.max = max
-        self.preferred = preferred
-        self.weight = weight
-
-        # Don't allow situations where max < min. (This would be a bug.)
-        if max < min:
-            raise ValueError("Invalid Dimension: max < min.")
-
-        # Make sure that the 'preferred' size is always in the min..max range.
-        if self.preferred < self.min:
-            self.preferred = self.min
-
-        if self.preferred > self.max:
-            self.preferred = self.max
-
-    @classmethod
-    def exact(cls, amount: int) -> "Dimension":
-        """
-        Return a :class:`.Dimension` with an exact size. (min, max and
-        preferred set to ``amount``).
-        """
-        return cls(min=amount, max=amount, preferred=amount)
-
-    @classmethod
-    def zero(cls) -> "Dimension":
-        """
-        Create a dimension that represents a zero size. (Used for 'invisible'
-        controls.)
-        """
-        return cls.exact(amount=0)
-
-    def is_zero(self) -> bool:
-        "True if this `Dimension` represents a zero size."
-        return self.preferred == 0 or self.max == 0
-
-    def __repr__(self) -> str:
-        fields = []
-        if self.min_specified:
-            fields.append("min=%r" % self.min)
-        if self.max_specified:
-            fields.append("max=%r" % self.max)
-        if self.preferred_specified:
-            fields.append("preferred=%r" % self.preferred)
-        if self.weight_specified:
-            fields.append("weight=%r" % self.weight)
-
-        return "Dimension(%s)" % ", ".join(fields)
-
-
-def sum_layout_dimensions(dimensions: List[Dimension]) -> Dimension:
-    """
-    Sum a list of :class:`.Dimension` instances.
-    """
-    min = sum(d.min for d in dimensions)
-    max = sum(d.max for d in dimensions)
-    preferred = sum(d.preferred for d in dimensions)
-
-    return Dimension(min=min, max=max, preferred=preferred)
-
-
-def max_layout_dimensions(dimensions: List[Dimension]) -> Dimension:
-    """
-    Take the maximum of a list of :class:`.Dimension` instances.
-    Used when we have a HSplit/VSplit, and we want to get the best width/height.)
-    """
-    if not len(dimensions):
-        return Dimension.zero()
-
-    # If all dimensions are size zero. Return zero.
-    # (This is important for HSplit/VSplit, to report the right values to their
-    # parent when all children are invisible.)
-    if all(d.is_zero() for d in dimensions):
-        return dimensions[0]
-
-    # Ignore empty dimensions. (They should not reduce the size of others.)
-    dimensions = [d for d in dimensions if not d.is_zero()]
-
-    if dimensions:
-        # Take the highest minimum dimension.
-        min_ = max(d.min for d in dimensions)
-
-        # For the maximum, we would prefer not to go larger than then smallest
-        # 'max' value, unless other dimensions have a bigger preferred value.
-        # This seems to work best:
-        #  - We don't want that a widget with a small height in a VSplit would
-        #    shrink other widgets in the split.
-        # If it doesn't work well enough, then it's up to the UI designer to
-        # explicitly pass dimensions.
-        max_ = min(d.max for d in dimensions)
-        max_ = max(max_, max(d.preferred for d in dimensions))
-
-        # Make sure that min>=max. In some scenarios, when certain min..max
-        # ranges don't have any overlap, we can end up in such an impossible
-        # situation. In that case, give priority to the max value.
-        # E.g. taking (1..5) and (8..9) would return (8..5). Instead take (8..8).
-        if min_ > max_:
-            max_ = min_
-
-        preferred = max(d.preferred for d in dimensions)
-
-        return Dimension(min=min_, max=max_, preferred=preferred)
-    else:
-        return Dimension()
-
-
-# Anything that can be converted to a dimension.
-AnyDimension = Union[
-    None,  # None is a valid dimension that will fit anything.
-    int,
-    Dimension,
-    # Callable[[], 'AnyDimension']  # Recursive definition not supported by mypy.
-    Callable[[], Any],
-]
-
-
-def to_dimension(value: AnyDimension) -> Dimension:
-    """
-    Turn the given object into a `Dimension` object.
-    """
-    if value is None:
-        return Dimension()
-    if isinstance(value, int):
-        return Dimension.exact(value)
-    if isinstance(value, Dimension):
-        return value
-    if callable(value):
-        return to_dimension(value())
-
-    raise ValueError("Not an integer or Dimension object.")
-
-
-def is_dimension(value: object) -> "TypeGuard[AnyDimension]":
-    """
-    Test whether the given value could be a valid dimension.
-    (For usage in an assertion. It's not guaranteed in case of a callable.)
-    """
-    if value is None:
-        return True
-    if callable(value):
-        return True  # Assume it's a callable that doesn't take arguments.
-    if isinstance(value, (int, Dimension)):
-        return True
-    return False
-
-
-# Common alias.
-D = Dimension
-
-# For backward-compatibility.
-LayoutDimension = Dimension
+        if preferred is None: 
+            preferred = min 
+        if weight is None: 
+            weight = 1 
+ 
+        self.min = min 
+        self.max = max 
+        self.preferred = preferred 
+        self.weight = weight 
+ 
+        # Don't allow situations where max < min. (This would be a bug.) 
+        if max < min: 
+            raise ValueError("Invalid Dimension: max < min.") 
+ 
+        # Make sure that the 'preferred' size is always in the min..max range. 
+        if self.preferred < self.min: 
+            self.preferred = self.min 
+ 
+        if self.preferred > self.max: 
+            self.preferred = self.max 
+ 
+    @classmethod 
+    def exact(cls, amount: int) -> "Dimension": 
+        """ 
+        Return a :class:`.Dimension` with an exact size. (min, max and 
+        preferred set to ``amount``). 
+        """ 
+        return cls(min=amount, max=amount, preferred=amount) 
+ 
+    @classmethod 
+    def zero(cls) -> "Dimension": 
+        """ 
+        Create a dimension that represents a zero size. (Used for 'invisible' 
+        controls.) 
+        """ 
+        return cls.exact(amount=0) 
+ 
+    def is_zero(self) -> bool: 
+        "True if this `Dimension` represents a zero size." 
+        return self.preferred == 0 or self.max == 0 
+ 
+    def __repr__(self) -> str: 
+        fields = [] 
+        if self.min_specified: 
+            fields.append("min=%r" % self.min) 
+        if self.max_specified: 
+            fields.append("max=%r" % self.max) 
+        if self.preferred_specified: 
+            fields.append("preferred=%r" % self.preferred) 
+        if self.weight_specified: 
+            fields.append("weight=%r" % self.weight) 
+ 
+        return "Dimension(%s)" % ", ".join(fields) 
+ 
+ 
+def sum_layout_dimensions(dimensions: List[Dimension]) -> Dimension: 
+    """ 
+    Sum a list of :class:`.Dimension` instances. 
+    """ 
+    min = sum(d.min for d in dimensions) 
+    max = sum(d.max for d in dimensions) 
+    preferred = sum(d.preferred for d in dimensions) 
+ 
+    return Dimension(min=min, max=max, preferred=preferred) 
+ 
+ 
+def max_layout_dimensions(dimensions: List[Dimension]) -> Dimension: 
+    """ 
+    Take the maximum of a list of :class:`.Dimension` instances. 
+    Used when we have a HSplit/VSplit, and we want to get the best width/height.) 
+    """ 
+    if not len(dimensions): 
+        return Dimension.zero() 
+ 
+    # If all dimensions are size zero. Return zero. 
+    # (This is important for HSplit/VSplit, to report the right values to their 
+    # parent when all children are invisible.) 
+    if all(d.is_zero() for d in dimensions): 
+        return dimensions[0] 
+ 
+    # Ignore empty dimensions. (They should not reduce the size of others.) 
+    dimensions = [d for d in dimensions if not d.is_zero()] 
+ 
+    if dimensions: 
+        # Take the highest minimum dimension. 
+        min_ = max(d.min for d in dimensions) 
+ 
+        # For the maximum, we would prefer not to go larger than then smallest 
+        # 'max' value, unless other dimensions have a bigger preferred value. 
+        # This seems to work best: 
+        #  - We don't want that a widget with a small height in a VSplit would 
+        #    shrink other widgets in the split. 
+        # If it doesn't work well enough, then it's up to the UI designer to 
+        # explicitly pass dimensions. 
+        max_ = min(d.max for d in dimensions) 
+        max_ = max(max_, max(d.preferred for d in dimensions)) 
+ 
+        # Make sure that min>=max. In some scenarios, when certain min..max 
+        # ranges don't have any overlap, we can end up in such an impossible 
+        # situation. In that case, give priority to the max value. 
+        # E.g. taking (1..5) and (8..9) would return (8..5). Instead take (8..8). 
+        if min_ > max_: 
+            max_ = min_ 
+ 
+        preferred = max(d.preferred for d in dimensions) 
+ 
+        return Dimension(min=min_, max=max_, preferred=preferred) 
+    else: 
+        return Dimension() 
+ 
+ 
+# Anything that can be converted to a dimension. 
+AnyDimension = Union[ 
+    None,  # None is a valid dimension that will fit anything. 
+    int, 
+    Dimension, 
+    # Callable[[], 'AnyDimension']  # Recursive definition not supported by mypy. 
+    Callable[[], Any], 
+] 
+ 
+ 
+def to_dimension(value: AnyDimension) -> Dimension: 
+    """ 
+    Turn the given object into a `Dimension` object. 
+    """ 
+    if value is None: 
+        return Dimension() 
+    if isinstance(value, int): 
+        return Dimension.exact(value) 
+    if isinstance(value, Dimension): 
+        return value 
+    if callable(value): 
+        return to_dimension(value()) 
+ 
+    raise ValueError("Not an integer or Dimension object.") 
+ 
+ 
+def is_dimension(value: object) -> "TypeGuard[AnyDimension]": 
+    """ 
+    Test whether the given value could be a valid dimension. 
+    (For usage in an assertion. It's not guaranteed in case of a callable.) 
+    """ 
+    if value is None: 
+        return True 
+    if callable(value): 
+        return True  # Assume it's a callable that doesn't take arguments. 
+    if isinstance(value, (int, Dimension)): 
+        return True 
+    return False 
+ 
+ 
+# Common alias. 
+D = Dimension 
+ 
+# For backward-compatibility. 
+LayoutDimension = Dimension