Support for negative literal numbers added

Author: jalakoo

mock_generators/logic/generate_values.py

@@ -2,6 +2,7 @@
 from models.generator import Generator, GeneratorType
 import logging
 import json
+import re
 
 # ORIGINAL GENERATOR ASSIGNMENT
 def actual_generator_for_raw_property(
@@ -94,11 +95,39 @@ def is_int(value: str) -> bool:
 
 def is_float(value: str) -> bool:
     try:
-        f = float(value)
+        _ = float(value)
         return True
     except ValueError:
         return False
 
+def find_longest_float_precision(float_list):
+    max_precision = 0
+    for num in float_list:
+        num_str = str(num)
+        if '.' in num_str:
+            decimal_part = num_str.split('.')[1]
+            precision = len(decimal_part)
+            max_precision = max(max_precision, precision)
+    return max_precision
+
+def extract_numbers(string):
+    # Use regex to find all number patterns in the string
+    number_list = re.findall(r"-?\d+(?:\.\d+)?", string)
+
+    # Convert the extracted strings to appropriate number types
+    number_list = [int(num) if num.isdigit() else float(num) for num in number_list]
+
+    return number_list
+
+def numbers_list_from(string):
+    # numbers = []
+    # ranges = string.split('-')
+    # for r in ranges:
+    #     numbers.extend(extract_numbers(r))
+    # return numbers 
+    options = re.split(r'(?<=[^-])-', string)
+    return options
+
 def literal_generator_from_value(
         value: str,
         generators: list[Generator]
@@ -134,9 +163,10 @@ def literal_generator_from_value(
     # Original specificaion took stringified JSON objects to notate generator and args to use. We're going to convert matching literal values to appropriate generators
 
     # Default is to use the literal generator
-    result = {
-        "string": [value]
-    }
+    result = None
+    # result = {
+    #     "string": [value]
+    # }
 
     # Check if value is an int or float
     if is_int(value):
@@ -145,32 +175,31 @@ def literal_generator_from_value(
             "int": [integer]
         }
 
-    if is_float(value):
+    if result is None and is_float(value):
         f = float(value)
         result = {
             "float": [f]
         }
 
     # NOTE: Not currently handling complex literals
 
-    # Check if value is a range of ints or floats
-    r = value.split("-")
-    if len(r) == 2:
-        # Single dash in string, possibly a literal range
-        values = [r[0], r[1]]
-        if all_ints(values):
-            result = {
-                "int_range": [int(r[0]), int(r[1])]
-            }
-        elif some_floats(values):
-            # Float range function expects 3 args - this one seems more sensible than other functions
-            result = {
-                "float_range": [float(r[0]), float(r[1]), 2]
-            }
- 
+    # Check if value is a range of positive ints or floats
+    if result is None:
+        numbers = numbers_list_from(value) 
+        if len(numbers) == 2:
+        # Check for correctly formatted int or float range string
+            precision = find_longest_float_precision(numbers)
+            if precision == 0:
+                    result = {
+                        "int_range": [int(numbers[0]), int(numbers[1])]
+                    }
+            else:
+                    result = {
+                        "float_range": [float(numbers[0]), float(numbers[1]), precision]
+                    }
 
     # Check for literal list of ints, floats, or strings
-    if value.startswith('[') and value.endswith(']'):
+    if result is None and value.startswith('[') and value.endswith(']'):
         values = value[1:-1].split(',')
         # Generators take a strange format where the args are always a string - including # lists of other data, like ints, floats. ie ["1,2,3"] is an expected arg type
         # because certain generators could take multiple args from different text fields
@@ -193,6 +222,10 @@ def literal_generator_from_value(
                 "string_from_list": values
             }
 
+    if result is None:
+        result = {
+            "string": [value]
+        }
     # Package and return from legacy process
     actual_string = json.dumps(result)
     return actual_generator_for_raw_property(actual_string, generators)

setup.py

@@ -0,0 +1,8 @@
+# Run `pipenv install -e . --dev` at least once so that pytest can import all files for testing
+from setuptools import find_packages, setup
+
+setup(
+    name="mock_generators",
+    package_dir={'': 'mock_generators'},
+    packages=find_packages(where='mock_generators'),
+)

tests/test_agraph_conversions.py

@@ -0,0 +1,78 @@
+import pytest
+from mock_generators.logic.agraph_conversions import convert_agraph_to_arrows, agraph_data_from_response, convert_agraph_nodes_to_arrows_nodes,convert_agraph_node_to_arrows_node, convert_agraph_edge_to_arrows_relationship,random_coordinates_for
+
+from streamlit_agraph import agraph, Node, Edge, Config
+
+class TestAgraphConversions:
+
+    def test_agrph_data_from_response(self):
+        response = """[
+    [
+        "Alice",
+        "ROOMMATE",
+        "Bob"
+    ],
+    [
+        "Bob",
+        "FRIEND_OF",
+        "Charlie"
+    ]
+    ]
+    """
+        nodes, edges, config = agraph_data_from_response(response)
+        print(f'{[node.__dict__ for node in nodes]}')
+        assert len(nodes) == 3, f'Expected 3 nodes, got {len(nodes)}: nodes: {[node.__dict__ for node in nodes]}'
+        assert len(edges) == 2, f'Expected 2 edges, got {len(edges)}: edges: {edges}'
+
+        print(f'config: {config.__dict__}')
+        assert config.width == "800px", f'Expected default config, got {config.__dict__}'
+        assert config.height == "800px", f'Expected default config, got {config.__dict__}'
+        assert config.backgroundColor == "#000000", f'Expected default config, got {config.__dict__}'
+
+    def test_convert_agraph_edge_to_arrows_relationship(self):
+        nodes = set()
+        nodes.add(Node(id="n1", label="Alice"))
+        nodes.add(Node(id="n2", label="Bob"))
+        edge = Edge(source="Alice", target="Bob", label="FRIEND_OF")
+
+        print(f'nodes: {[node.__dict__ for node in nodes]}')
+        print(f'edge: {edge.__dict__}')
+
+        arrows_nodes = convert_agraph_nodes_to_arrows_nodes(nodes)
+        arrows_edge = convert_agraph_edge_to_arrows_relationship(0, edge, arrows_nodes)
+
+        # NOTE: The edge may reverse the from and to ids
+        print(f'arrows edge: {arrows_edge}')
+        assert arrows_edge == {
+            "id": "n1",
+            "type": "FRIEND_OF",
+            "fromId": "n1",
+            "toId": "n2",
+            "properties": {},
+            "style": {}
+        } or {
+            "id": "n1",
+            "type": "FRIEND_OF",
+            "fromId": "n2",
+            "toId": "n1",
+            "properties": {},
+            "style": {}
+        }
+
+    def test_convert_agraph_node_to_arrows_node(self):
+        node = (Node(id="n1", label="Alice"))
+        print(f'agraph_node: {node.__dict__}')
+        coordinates = random_coordinates_for(1)
+        arrows_node = convert_agraph_node_to_arrows_node(0, node, coordinates[0][0], coordinates[0][1])
+        print(f'arrows_node: {arrows_node}')
+        assert arrows_node == {
+            "id": "n1",
+            "caption": "Alice",
+            "position": {
+                "x": coordinates[0][0],
+                "y": coordinates[0][1],
+            },
+            "labels": [],
+            "properties": {},
+            "style": {}
+        }

tests/test_generate_values.py

@@ -1,6 +1,6 @@
 import pytest
 from mock_generators.config import load_generators
-from mock_generators.logic.generate_values import literal_generator_from_value, actual_generator_for_raw_property, generator_for_raw_property, keyword_generator_for_raw_property
+from mock_generators.logic.generate_values import literal_generator_from_value, actual_generator_for_raw_property, generator_for_raw_property, keyword_generator_for_raw_property, find_longest_float_precision
 
 
 test_generators = load_generators("mock_generators/named_generators.json")
@@ -85,6 +85,21 @@ def test_integer_list_multi(self):
         except Exception as e:
             assert False, f'Exception: {e}'
 
+class TestLiteralSupport:
+    def test_find_longest_float_percision(self):
+        try:
+            test_floats = [1.01, 2.002, 3.004]
+            precision = find_longest_float_precision(test_floats)
+            assert precision == 3
+        except Exception as e:
+            assert False, f'Exception: {e}'
+
+        try:
+            test_floats = [1, -2]
+            precision = find_longest_float_precision(test_floats)
+            assert precision == 0
+        except Exception as e:
+            assert False, f'Exception: {e}'
 
 class TestLiteralGenerators:
     def test_integer(self):
@@ -102,14 +117,21 @@ def test_integer(self):
     def test_float(self):
         try:
             test_string = "1.0"
-            # This should be equivalent to the integer generator with arg of [1]
             generator, args = literal_generator_from_value(test_string, test_generators)
-            # Test generator returned creates acceptable value
             value = generator.generate(args)
             assert value == 1.0
         except Exception as e:
             assert False, f'Exception: {e}'
 
+    def test_negative_float(self):
+        try:
+            test_string = "-1.0"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value == -1.0
+        except Exception as e:
+            assert False, f'Exception: {e}'
+
 
     def test_int_range(self):
         try:
@@ -126,16 +148,77 @@ def test_int_range(self):
     def test_float_range(self):
         try:
             test_string = "1.0-2"
-            # This should be equivalent to the integer generator with arg of [1]
             generator, args = literal_generator_from_value(test_string, test_generators)
-            # Test generator returned creates acceptable value
             value = generator.generate(args)
             assert value <= 2.0
             assert value >= 1.0
         except Exception as e:
             assert False, f'Exception: {e}'
+        try:
+            test_string = "1-2.0"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= 2.0
+            assert value >= 1.0
+        except Exception as e:
+            assert False, f'Exception: {e}'
+        try:
+            test_string = "1.0-2.0"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= 2.0
+            assert value >= 1.0
+        except Exception as e:
+            assert False, f'Exception: {e}'
+        try:
+            test_string = "1--2.02"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= 1.00
+            assert value >= -2.01
+        except Exception as e:
+            assert False, f'Exception: {e}'
+        try:
+            test_string = "1.01--2.02"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= 1.01
+            assert value >= -2.01
+        except Exception as e:
+            assert False, f'Exception: {e}'
 
-
+        try:
+            test_string = "-10.0003-20"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= 20.0000
+            assert value >= -10.0003
+        except Exception as e:
+            assert False, f'Exception: {e}'
+        try:
+            test_string = "-10.01-20.02"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= 20.02
+            assert value >= -10.01
+        except Exception as e:
+            assert False, f'Exception: {e}'
+        try:
+            test_string = "-73--74.004"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= -73.000
+            assert value >= -74.004
+        except Exception as e:
+            assert False, f'Exception: {e}'
+        try:
+            test_string = "-73.979--74.004"
+            generator, args = literal_generator_from_value(test_string, test_generators)
+            value = generator.generate(args)
+            assert value <= -73.979
+            assert value >= -74.004
+        except Exception as e:
+            assert False, f'Exception: {e}'
     def test_int_list(self):
         try:
             test_string = "[1,2,3]"