Merge pull request #17 from johnomotani/int-float-convert

Implicitly convert any `Number` when `value_type=float`

.flake8

@@ -1,11 +1,10 @@
 [flake8]
 max-line-length = 88
-ignore = (
+ignore =
  E741, # 'ambiguous variable names' forbids using 'I', 'O' or 'l'
  W503, # 'line break before binary operator', but this is allowed and useful inside brackets
  E203, # 'whitespace before ':'', but black formats some slice expressions with space before ':'
  E231, # missing whitespace after ',', but black formats some expressions without space after ','
-)
 exclude =
  optionsfactory/_version.py
  versioneer.py

optionsfactory/_utils.py

@@ -1,4 +1,10 @@
+from numbers import Number
+
+
 def _checked(value, *, meta=None, name=None):
+ if (meta is not None) and meta.value_type is float and isinstance(value, Number):
+ # Allow converting any numerical type to float
+ value = float(value)
  if (
  (meta is not None)
  and (meta.value_type is not None)

optionsfactory/optionsfactory.py

@@ -88,8 +88,8 @@ def doc(self):
  return {key: value.doc for key, value in self.__defaults.items()}
 
  def add(self, **kwargs):
- """Create a more specific version of the factory with extra options. For example,
- may be useful for a subclass like
+ """Create a more specific version of the factory with extra options. For
+ example, may be useful for a subclass like
 
  class Parent:
  options_factory = OptionsFactory(...)

optionsfactory/tests/test_mutableoptions.py

@@ -141,6 +141,37 @@ def test_defaults(self):
  with pytest.raises(KeyError):
  opts.is_default("x")
 
+ opts["f"] = 3
+
+ assert opts.a == 3
+ assert opts.b == 3
+ assert opts.c == 3
+ assert opts.d == 6.0
+ assert opts.e == 3
+ assert opts.f == 3.0
+ assert opts.g == 11
+ assert opts.h == 5
+
+ assert opts["a"] == 3
+ assert opts["b"] == 3
+ assert opts["c"] == 3
+ assert opts["d"] == 6.0
+ assert opts["e"] == 3
+ assert opts["f"] == 3.0
+ assert opts["g"] == 11
+ assert opts["h"] == 5
+
+ assert not opts.is_default("a")
+ assert opts.is_default("b")
+ assert opts.is_default("c")
+ assert opts.is_default("d")
+ assert opts.is_default("e")
+ assert not opts.is_default("f")
+ assert opts.is_default("g")
+ assert opts.is_default("h")
+ with pytest.raises(KeyError):
+ opts.is_default("x")
+
  assert "a" in opts
  assert "b" in opts
  assert "c" in opts
@@ -155,22 +186,23 @@ def test_defaults(self):
  assert sorted([k for k in opts]) == sorted(
  ["a", "b", "c", "d", "e", "f", "g", "h"]
  )
- assert sorted(opts.values()) == sorted([3, 3, 3, 5.0, 3, 2.0, 11, 5])
+ assert sorted(opts.values()) == sorted([3, 3, 3, 6.0, 3, 3.0, 11, 5])
  assert sorted(opts.items()) == sorted(
  [
  ("a", 3),
  ("b", 3),
  ("c", 3),
- ("d", 5.0),
+ ("d", 6.0),
  ("e", 3),
- ("f", 2.0),
+ ("f", 3.0),
  ("g", 11),
  ("h", 5),
  ]
  )
 
- # Reset "a" to default
+ # Reset "a" and "f" to default
  del opts["a"]
+ del opts["f"]
  assert opts.a == 1
  assert opts.b == 1
  assert opts.c == 1
@@ -322,8 +354,7 @@ def test_initialise(self):
  opts = factory.create({"f": 2.5})
  with pytest.raises(TypeError):
  opts = factory.create({"f": "2.0"})
- with pytest.raises(TypeError):
- opts = factory.create({"f": 2})
+ assert factory.create({"f": 2}).f == 2.0
  with pytest.raises(ValueError):
  opts = factory.create({"g": -1})
  with pytest.raises(ValueError):
@@ -1054,8 +1085,7 @@ def test_initialise(self):
  opts = factory.create_immutable({"f": 2.5})
  with pytest.raises(TypeError):
  opts = factory.create_immutable({"f": "2.0"})
- with pytest.raises(TypeError):
- opts = factory.create_immutable({"f": 2})
+ assert factory.create_immutable({"f": 2}).f == 2.0
  with pytest.raises(ValueError):
  opts = factory.create_immutable({"g": -1})
  with pytest.raises(ValueError):

optionsfactory/tests/test_options.py

@@ -252,8 +252,135 @@ def test_initialise(self):
  opts = factory.create({"f": 2.5})
  with pytest.raises(TypeError):
  opts = factory.create({"f": "2.0"})
+ assert factory.create({"f": 2}).f == 2.0
+ with pytest.raises(ValueError):
+ opts = factory.create({"g": -1})
+ with pytest.raises(ValueError):
+ opts = factory.create({"g": 30})
+ with pytest.raises(TypeError):
+ opts = factory.create({"g": 3.5})
+ with pytest.raises(ValueError):
+ opts = factory.create({"h": -7})
+ assert factory.create({"h": -21}).h == -21
+ with pytest.raises(TypeError):
+ opts = factory.create({"h": 3.5})
+ with pytest.raises(ValueError):
+ opts = factory.create({"a": -7})
+ assert factory.create({"a": -23}).h == -21
+ with pytest.raises(TypeError):
+ opts = factory.create({"a": 3.5})
+
+ def test_initialise_with_conversion_to_float(self):
+ factory = OptionsFactory(
+ a=1,
+ b=lambda options: options.a,
+ c=lambda options: options["a"],
+ d=lambda options: options.b + options.c,
+ e=WithMeta("b", value_type=int),
+ f=WithMeta(2.0, doc="option f", value_type=float, allowed=[2.0, 3.0]),
+ g=WithMeta(
+ 11,
+ doc="option g",
+ value_type=int,
+ check_all=[is_positive, lambda x: x < 20],
+ ),
+ h=WithMeta(
+ lambda options: options.a + 2,
+ doc="option h",
+ value_type=int,
+ check_any=[is_positive, lambda x: x < -20],
+ ),
+ )
+
+ opts = factory.create({"a": 4, "b": 5, "f": 3, "g": 13, "z": 17})
+
+ assert opts.a == 4
+ assert opts.b == 5
+ assert opts.c == 4
+ assert opts.d == 9
+ assert opts.e == 5
+ assert opts.f == 3.0
+ assert isinstance(opts.f, float)
+ assert opts.g == 13
+ assert opts.h == 6
+
+ # "z" should have been ignored
+ with pytest.raises(AttributeError):
+ opts.z
+
+ assert opts["a"] == 4
+ assert opts["b"] == 5
+ assert opts["c"] == 4
+ assert opts["d"] == 9
+ assert opts["e"] == 5
+ assert opts["f"] == 3.0
+ assert isinstance(opts["f"], float)
+ assert opts["g"] == 13
+ assert opts["h"] == 6
+
+ # "z" should have been ignored
+ with pytest.raises(KeyError):
+ opts["z"]
+
+ assert opts.doc["a"] is None
+ assert opts.doc["b"] is None
+ assert opts.doc["c"] is None
+ assert opts.doc["d"] is None
+ assert opts.doc["e"] is None
+ assert opts.doc["f"] == "option f"
+ assert opts.doc["g"] == "option g"
+ assert opts.doc["h"] == "option h"
+
+ with pytest.raises(TypeError):
+ opts.a = 2
+
  with pytest.raises(TypeError):
- opts = factory.create({"f": 2})
+ opts["a"] = 2
+
+ assert not opts.is_default("a")
+ assert not opts.is_default("b")
+ assert opts.is_default("c")
+ assert opts.is_default("d")
+ assert opts.is_default("e")
+ assert not opts.is_default("f")
+ assert not opts.is_default("g")
+ assert opts.is_default("h")
+ with pytest.raises(KeyError):
+ opts.is_default("x")
+
+ assert "a" in opts
+ assert "b" in opts
+ assert "c" in opts
+ assert "d" in opts
+ assert "e" in opts
+ assert "f" in opts
+ assert "g" in opts
+ assert "h" in opts
+ assert not ("x" in opts)
+
+ assert len(opts) == 8
+ assert sorted([k for k in opts]) == sorted(
+ ["a", "b", "c", "d", "e", "f", "g", "h"]
+ )
+ assert sorted(opts.values()) == sorted([4, 5, 4, 9, 5, 3.0, 13, 6])
+ assert sorted(opts.items()) == sorted(
+ [
+ ("a", 4),
+ ("b", 5),
+ ("c", 4),
+ ("d", 9),
+ ("e", 5),
+ ("f", 3.0),
+ ("g", 13),
+ ("h", 6),
+ ]
+ )
+
+ with pytest.raises(ValueError):
+ opts = factory.create({"f": 2.5})
+ with pytest.raises(TypeError):
+ opts = factory.create({"f": "2.0"})
+ assert factory.create({"f": 2}).f == 2.0
  with pytest.raises(ValueError):
  opts = factory.create({"g": -1})
  with pytest.raises(ValueError):

optionsfactory/tests/test_withmeta.py

@@ -43,8 +43,13 @@ def test_value_type(self):
  assert x.evaluate_expression({}) == 3.0
 
  x.value = 3
- with pytest.raises(TypeError):
- x.evaluate_expression({})
+ assert x.evaluate_expression({}) == 3.0
+
+ def test_float_conversion(self):
+ x = WithMeta(3, value_type=float)
+ assert x.value_type is float
+ assert x.evaluate_expression({}) == 3.0
+ assert isinstance(x.evaluate_expression({}), float)
 
  def test_value_type_sequence(self):
  x = WithMeta(3.0, value_type=[float, NoneType])

optionsfactory/withmeta.py

@@ -1,4 +1,5 @@
 from collections.abc import Sequence
+from numbers import Number
 
 from ._utils import _checked
 
@@ -65,7 +66,11 @@ def __init__(
  self.check_any = value.check_any
  return
 
- self.value = value
+ if value_type is float and isinstance(value, Number):
+ # Allow converting any numerical type to float
+ self.value = float(value)
+ else:
+ self.value = value
  self.doc = doc
 
  if isinstance(value_type, Sequence):