hydra-core 1.4.0.dev3__tar.gz → 1.4.0.dev4__tar.gz

{hydra_core-1.4.0.dev3/hydra_core.egg-info → hydra_core-1.4.0.dev4}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: hydra-core
-Version: 1.4.0.dev3
+Version: 1.4.0.dev4
 Summary: A framework for elegantly configuring complex applications
 Home-page: https://github.com/facebookresearch/hydra
 Author: Omry Yadan
 Author-email: omry@fb.com
 License: MIT
 Keywords: command-line configuration yaml tab-completion
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{hydra_core-1.4.0.dev3 → hydra_core-1.4.0.dev4}/hydra/__init__.py

@@ -1,7 +1,7 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
 
 # Source of truth for Hydra's version
-__version__ = "1.4.0.dev3"
+__version__ = "1.4.0.dev4"
 from hydra import utils
 from hydra.errors import MissingConfigException
 from hydra.main import main

{hydra_core-1.4.0.dev3 → hydra_core-1.4.0.dev4}/hydra/_internal/grammar/grammar_functions.py

@@ -1,5 +1,6 @@
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
 import builtins
+import decimal
 import json
 import random
 from copy import copy
@@ -361,27 +362,57 @@ def _sort_sweep(
     elif isinstance(sweep, RangeSweep):
         assert sweep.start is not None
         assert sweep.stop is not None
-        if not reverse:
-            # ascending
-            if sweep.start > sweep.stop:
-                start = sweep.stop + abs(sweep.step)
-                stop = sweep.start + abs(sweep.step)
-                sweep.start = start
-                sweep.stop = stop
-                sweep.step = -sweep.step
-        else:
-            # descending
-            if sweep.start < sweep.stop:
-                start = sweep.stop - abs(sweep.step)
-                stop = sweep.start - abs(sweep.step)
-                sweep.start = start
-                sweep.stop = stop
-                sweep.step = -sweep.step
+        if (sweep.step > 0) == reverse:
+            _reverse_range_sweep(sweep)
         return sweep
     else:
         assert False
 
 
+def _reverse_range_sweep(sweep: RangeSweep) -> None:
+    r = sweep.range()
+    if isinstance(r, builtins.range):
+        count = len(r)
+        if count > 1:
+            first = r[0]
+            last = r[-1]
+            sweep.start = last
+            sweep.step = -sweep.step
+            sweep.stop = first + sweep.step
+    else:
+        start = decimal.Decimal(str(sweep.start))
+        stop = decimal.Decimal(str(sweep.stop))
+        step = decimal.Decimal(str(sweep.step))
+        count = _float_range_count(start=start, stop=stop, step=step)
+        if count > 1:
+            first = start
+            last = start + (count - 1) * step
+            sweep.start = last
+            sweep.step = -step
+            sweep.stop = first + sweep.step / 2
+
+
+def _float_range_count(
+    start: decimal.Decimal, stop: decimal.Decimal, step: decimal.Decimal
+) -> int:
+    if step == 0:
+        return 0
+    if step > 0:
+        if start >= stop:
+            return 0
+        distance = stop - start
+    else:
+        if start <= stop:
+            return 0
+        distance = start - stop
+    step = abs(step)
+    quotient, remainder = divmod(distance, step)
+    count = int(quotient)
+    if remainder != 0:
+        count += 1
+    return count
+
+
 def glob(
     include: Union[List[str], str], exclude: Optional[Union[List[str], str]] = None
 ) -> Glob:

{hydra_core-1.4.0.dev3 → hydra_core-1.4.0.dev4}/hydra/core/override_parser/types.py

@@ -89,14 +89,15 @@ class ChoiceSweep(Sweep):
 
 @dataclass
 class FloatRange:
-    start: Union[decimal.Decimal, float]
-    stop: Union[decimal.Decimal, float]
-    step: Union[decimal.Decimal, float]
+    start: Union[decimal.Decimal, float, int]
+    stop: Union[decimal.Decimal, float, int]
+    step: Union[decimal.Decimal, float, int]
+    _idx: int = field(default=0, init=False, repr=False, compare=False)
 
     def __post_init__(self) -> None:
-        self.start = decimal.Decimal(self.start)
-        self.stop = decimal.Decimal(self.stop)
-        self.step = decimal.Decimal(self.step)
+        self.start = decimal.Decimal(str(self.start))
+        self.stop = decimal.Decimal(str(self.stop))
+        self.step = decimal.Decimal(str(self.step))
 
     def __iter__(self) -> Any:
         return self
@@ -105,18 +106,17 @@ class FloatRange:
         assert isinstance(self.start, decimal.Decimal)
         assert isinstance(self.stop, decimal.Decimal)
         assert isinstance(self.step, decimal.Decimal)
+        current = self.start + self.step * self._idx
         if self.step > 0:
-            if self.start < self.stop:
-                ret = float(self.start)
-                self.start += self.step
-                return ret
+            if current < self.stop:
+                self._idx += 1
+                return float(current)
             else:
                 raise StopIteration
         elif self.step < 0:
-            if self.start > self.stop:
-                ret = float(self.start)
-                self.start += self.step
-                return ret
+            if current > self.stop:
+                self._idx += 1
+                return float(current)
             else:
                 raise StopIteration
         else:
@@ -131,9 +131,9 @@ class RangeSweep(Sweep):
     Discrete range of numbers
     """
 
-    start: Optional[Union[int, float]] = None
-    stop: Optional[Union[int, float]] = None
-    step: Union[int, float] = 1
+    start: Optional[Union[int, float, decimal.Decimal]] = None
+    stop: Optional[Union[int, float, decimal.Decimal]] = None
+    step: Union[int, float, decimal.Decimal] = 1
 
     shuffle: bool = False
 

{hydra_core-1.4.0.dev3 → hydra_core-1.4.0.dev4/hydra_core.egg-info}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: hydra-core
-Version: 1.4.0.dev3
+Version: 1.4.0.dev4
 Summary: A framework for elegantly configuring complex applications
 Home-page: https://github.com/facebookresearch/hydra
 Author: Omry Yadan
 Author-email: omry@fb.com
 License: MIT
 Keywords: command-line configuration yaml tab-completion
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{hydra_core-1.4.0.dev3 → hydra_core-1.4.0.dev4}/setup.py

@@ -44,7 +44,6 @@ with open("README.md") as fh:
         packages=find_namespace_packages(include=["hydra", "hydra.*"]),
         include_package_data=True,
         classifiers=[
-            "License :: OSI Approved :: MIT License",
             "Development Status :: 4 - Beta",
             "Programming Language :: Python :: 3.10",
             "Programming Language :: Python :: 3.11",

{hydra_core-1.4.0.dev3 → hydra_core-1.4.0.dev4}/tests/test_overrides_parser.py

@@ -12,6 +12,7 @@ except ImportError:
 from pytest import mark, param, raises, warns
 
 from hydra import version
+from hydra._internal.grammar import grammar_functions
 from hydra._internal.grammar.functions import Functions
 from hydra._internal.grammar.utils import escape_special_characters
 from hydra.core.override_parser.overrides_parser import (
@@ -1403,14 +1404,30 @@ def test_tag_sweep(value: str, expected: str) -> None:
         ),
         param(
             "sort(range(1.5,-0.5,-0.5))",
-            RangeSweep(start=0.0, stop=2.0, step=0.5),
+            RangeSweep(start=0.0, stop=1.75, step=0.5),
             id="sort(range(1.5,-0.5,-0.5))",
         ),
         param(
             "sort(range(0,2,0.5),reverse=true)",
-            RangeSweep(start=1.5, stop=-0.5, step=-0.5),
+            RangeSweep(start=1.5, stop=-0.25, step=-0.5),
             id="range:sort:reverse)",
         ),
+        # ranges that do not land exactly on ``stop`` (last element != stop - step)
+        param(
+            "sort(range(0,5,2),reverse=True)",
+            RangeSweep(start=4, stop=-2, step=-2),
+            id="sort:range:non_landing:reverse",
+        ),
+        param(
+            "sort(range(4,-1,-2))",
+            RangeSweep(start=0, stop=6, step=2),
+            id="sort:range:non_landing:ascending",
+        ),
+        param(
+            "sort(range(7,0,-3))",
+            RangeSweep(start=1, stop=10, step=3),
+            id="sort:range:non_landing:ascending2",
+        ),
         param(
             "shuffle(range(1, 10))",
             RangeSweep(start=1, stop=10, step=1, shuffle=True),
@@ -1423,6 +1440,36 @@ def test_sort(value: str, expected: str) -> None:
     assert ret == expected
 
 
+@mark.parametrize(
+    "start, stop, step",
+    [
+        param(0, 5, 2, id="int:non_landing"),
+        param(4, -1, -2, id="int:non_landing:neg_step"),
+        param(7, 0, -3, id="int:non_landing:neg_step2"),
+        param(1, 10, 1, id="int:landing"),
+        param(0, 1, 1, id="int:single_element"),
+        param(0, 0, 1, id="int:empty"),
+        param(1, 0, 1, id="int:empty_positive_step"),
+        param(0, 2, 0.5, id="float:landing"),
+        param(0, 1.3, 0.5, id="float:non_landing"),
+        param(1.3, 0, -0.5, id="float:non_landing:neg_step"),
+        param(0, 1, 0.1, id="float:decimal_step"),
+        param(0, 1, 0.2, id="float:decimal_step2"),
+        param(0, 0.3, 0.1, id="float:short_decimal_step"),
+        param(1, 0, -0.1, id="float:negative_decimal_step"),
+    ],
+)
+def test_sort_range_materializes_to_sorted_values(
+    start: float, stop: float, step: float
+) -> None:
+    original = list(grammar_functions.range(start, stop, step).range())
+    for reverse in (False, True):
+        sweep = grammar_functions.sort(
+            grammar_functions.range(start, stop, step), reverse=reverse
+        )
+        assert list(sweep.range()) == sorted(original, reverse=reverse)
+
+
 @mark.parametrize(
     "value, expected",
     [