Address literal updated

Pipfile

@@ -14,6 +14,7 @@ faker = "*"
 streamlit-player = "*"
 requests = "*"
 pandas = "*"
+random-address = "*"
 
 [dev-packages]
 mock-generators = {editable = true, path = "."}

mock_generators/generators/address_usa.py

@@ -0,0 +1,10 @@
+from random_address import real_random_address_by_state
+import random
+
+def generate(args: list[any]):
+    # Generate a dictionary with valid random address information
+    states = [
+        "AL", "AR", "CA", "CO", "CT", "DC", "FL", "GA", "HI", "KY", "MA" "MD", "TN", "TX", "OK", "VT"
+    ]
+    state_code = random.choice(states)
+    return real_random_address_by_state(state_code)

mock_generators/generators/73853311.py → mock_generators/generators/exhaustive_random.py

@@ -1,5 +1,4 @@
 from random import shuffle
-import logging
 
 # Do not change function name or arguments
 def generate(
@@ -10,5 +9,5 @@ def generate(
     node_values = args
     shuffle(node_values)
     choice = node_values.pop(0)
-    # logging.info(f'73853311: choice: {choice}, values remaining: {len(node_values)}')
+
     return (choice, node_values)

mock_generators/generators/postcode.py

@@ -0,0 +1,5 @@
+from faker import Faker
+fake = Faker()
+
+def generate(args: list[any]):
+    return fake.postcode()

mock_generators/generators/pure_random.py

@@ -0,0 +1,9 @@
+import random
+# Do not change function name or arguments
+def generate(
+    args: list[any]
+    ) -> tuple[dict, list[dict]]:
+
+    targets = args[:]
+    result = random.choice(targets)
+    return (result, targets)

mock_generators/generators/state.py

@@ -0,0 +1,9 @@
+import random
+
+def generate(args: list[any]):
+    states = ["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DC", "DE", "FL", "GA", 
+            "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", 
+            "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", 
+            "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", 
+            "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"]
+    return random.choice(states)

mock_generators/generators/street.py

@@ -0,0 +1,5 @@
+from faker import Faker
+fake = Faker()
+
+def generate(args: list[any]):
+    return fake.street_address()

mock_generators/logic/generate_mapping.py

@@ -6,10 +6,60 @@
 from models.relationship_mapping import RelationshipMapping
 from models.property_mapping import PropertyMapping
 from models.generator import Generator
-from logic.generate_values import generator_for_raw_property
+from logic.generate_values import generator_for_raw_property, actual_generator_for_raw_property, assignment_generator_for
 import logging
 import uuid
 
+
+def generate_addresses_to(
+    raw_properties: dict[str, str],
+    generators: dict[str, Generator]):
+
+    # Insert all values - they will be read as literals during the node generation process
+    raw_properties['street'] = f'{{"street":[]}}'
+    raw_properties['city'] = f'{{"city":[]}}'
+    raw_properties['state'] = f'{{"state":[]}}'
+    raw_properties['zip'] = f'{{"postcode":[]}}'
+    raw_properties['country'] = f'{{"country":[]}}'
+    return raw_properties
+
+def xgenerate_addresses_to(
+    raw_properties: dict[str, str],
+    generators: dict[str, Generator]):
+
+    generator, args = actual_generator_for_raw_property('{"address_usa": []}', generators)
+    value = generator.generate(args)
+    # Insert all values - they will be read as literals during the node generation process
+    try:
+        address1 = value.get('address1', None)
+        if address1 is not None:
+            raw_properties['address1'] = f'{{"string":["{address1}"]}}'
+        address2 = value.get('address2', None)
+        if address2 is not None:
+            raw_properties['address2'] = f'{{"string":["{address2}"]}}'
+        city = value.get('city', None)
+        if city is not None:
+            raw_properties['city'] = f'{{"string":["{city}"]}}'
+        state = value.get('state', None)
+        if state is not None:
+            raw_properties['state'] = f'{{"string":["{state}"]}}'
+        postalCode = value.get('postalCode', None)
+        if postalCode is not None:
+            raw_properties['postalCode'] = f'{{"string":["{postalCode}"]}}'
+        lat = value.get('coordinates', None).get('lat', None)
+        if lat is not None:
+            raw_properties['latitude'] = f'{{"string":["{lat}"]}}'
+        lng = value.get('coordinates', None).get('lng', None)
+        if lng is not None:
+            raw_properties['longitude'] = f'{{"string":["{lng}"]}}'
+        # Add country
+        raw_properties['country'] = f'{{"string":["USA"]}}'
+    except Exception as e:
+        logging.error(f'Problem extracting data from address object: {value}: ERROR: {e}')
+
+    return raw_properties
+
+
 def propertymappings_for_raw_properties(
     raw_properties: dict[str, str], 
     generators: dict[str, Generator]
@@ -29,16 +79,57 @@ def propertymappings_for_raw_properties(
     if generators is None or len(generators) == 0:
         raise Exception(f'generate_mapping.py: propertymappings_for_raw_properties: No generators assignment received.')
 
+    # Special handling for addresses
+    raw_keys = raw_properties.keys()
+    # Assign uuid if not key property assignment was made
+    if "{key}" not in raw_keys and "KEY" not in raw_keys:
+        raw_properties["KEY"] = "_uid"
+        raw_properties["_uid"] = f'{{"uuid":[]}}'
+    if "ADDRESS" in raw_keys:
+        raw_properties.pop("ADDRESS")
+        raw_properties = generate_addresses_to(raw_properties, generators)
+        # Going to an address generator to create following properties:
+        # address_line_1, address_line_2, city, state, zip, latitude, longitude
+        # generator, args = actual_generator_for_raw_property('{"address_usa": []}', generators)
+        # value = generator.generate(args)
+        # # Insert all values - they will be read as literals during the node generation process
+        # try:
+        #     address1 = value.get('address1', None)
+        #     if address1 is not None:
+        #         raw_properties['address1'] = f'{{"string":["{address1}"]}}'
+        #     address2 = value.get('address2', None)
+        #     if address2 is not None:
+        #         raw_properties['address2'] = f'{{"string":["{address2}"]}}'
+        #     city = value.get('city', None)
+        #     if city is not None:
+        #         raw_properties['city'] = f'{{"string":["{city}"]}}'
+        #     state = value.get('state', None)
+        #     if state is not None:
+        #         raw_properties['state'] = f'{{"string":["{state}"]}}'
+        #     postalCode = value.get('postalCode', None)
+        #     if postalCode is not None:
+        #         raw_properties['postalCode'] = f'{{"string":["{postalCode}"]}}'
+        #     lat = value.get('coordinates', None).get('lat', None)
+        #     if lat is not None:
+        #         raw_properties['latitude'] = f'{{"string":["{lat}"]}}'
+        #     lng = value.get('coordinates', None).get('lng', None)
+        #     if lng is not None:
+        #         raw_properties['longitude'] = f'{{"string":["{lng}"]}}'
+        #     # Add country
+        #     raw_properties['country'] = f'{{"string":["USA"]}}'
+        # except Exception as e:
+        #     logging.error(f'Problem extracting data from address object: {value}: ERROR: {e}')
+
     for key, value in raw_properties.items():
 
         # Skip any keys with { } (brackets) as these are special cases for defining count/assignment/filter generators
         if key.startswith('{') and key.endswith('}'):
             continue
 
-        # TODO: Skip special COUNT and KEY literals
+        # Skip special COUNT and KEY literals
         if key == "COUNT" or key == "KEY":
                 continue
-    
+
         try:
             generator, args = generator_for_raw_property(value, generators)
             if generator is None:
@@ -207,10 +298,12 @@ def relationshipmappings_from(
                 count_generator_config = '{"int_range": [1,3]}'
                 logging.info(f"Relationship properties is missing COUNT or '{{count}}' key from properties: {properties}: Using default int_range generator")
 
-        assignment_generator_config = properties.get("{assignment}", None)
-        # If missing, use ExhaustiveRandom
+        assignment_generator_config = properties.get("ASSIGNMENT", None)
         if assignment_generator_config is None:
-            assignment_generator_config = "{\"exhaustive_random\":[]}"
+            assignment_generator_config = properties.get("{assignment}", None)
+            # If missing, use ExhaustiveRandom
+            if assignment_generator_config is None:
+                assignment_generator_config = "{\"exhaustive_random\":[]}"
 
         # Get proper generators for count generator
         try:
@@ -227,9 +320,9 @@ def relationshipmappings_from(
             continue
 
         try:
-            assignment_generator, assignment_args = generator_for_raw_property(assignment_generator_config, generators)
+            assignment_generator, assignment_args = assignment_generator_for(assignment_generator_config, generators)
         except Exception as e:
-            logging.warning(f"generate_mappings: relationshipmappings_from: could not create assignment generator for relationship: {relationship_dict}: {e}")
+            logging.warning(f"generate_mappings: relationshipmappings_from: could not get assignment generator for relationship: {relationship_dict}: {e}")
             continue
 
         from_node = nodes.get(from_id, None)