def create_raw_nodes(resource):
"""
Creates nodes for each column from the csv
:param resource: The Resource object
:return: Raw node data
"""
columns = R.item_path(['data', 'settings', 'columns'], resource)
raw_data = R.item_path(['data', 'raw_data'], resource)
return R.map(lambda line: R.from_pairs(zip(columns, line.split(';'))),
raw_data)
def user_scope_instances_by_id(user_scope_key, user_state_data):
# Resolve the user scope instances
return R.from_pairs(
R.map(
lambda user_scope: [
R.item_path_or(None, [scope_key_lookup[user_scope_key], 'id'], user_scope),
user_scope
],
R.prop_or([], user_scope_key, user_state_data)
)
)
def convert_foreign_key_to_id(scope_obj):
# Find ForeignKey attributes and map the class field name to the foreign key id field
# E.g. region to region_id, user to user_id, etc
converters = R.compose(
R.from_pairs, R.map(lambda field: [field.name, field.attname]),
R.filter(lambda field: R.isinstance(ForeignKey, field)))(
model._meta.fields)
# Convert scopo_obj[related_field] = {id: x} to scope_obj[related_field_id] = x
return R.from_pairs(
R.map_with_obj_to_values(
lambda key, value: [converters[key],
R.prop('id', value)]
if R.has(key, converters) else [key, value], scope_obj))
def create_raw_links(delineator, resource):
"""
Creates links from the csv if present
:param resource: The Resource object
:return: Raw node data
"""
columns = R.item_path(['data', 'settings', 'columns'], resource)
raw_data = R.item_path(['data', 'rawData'], resource)
# Sometimes we split nodes and edges in the raw data into
# dict(nodes=..., edges=...). Sometimes the raw data is just nodes
# and we get the edges from the node data
raw_links = R.prop_or(None, 'links', raw_data)
return R.map(
lambda line: R.from_pairs(
zip(
columns,
R.map(lambda s: s.strip(), line.split(delineator))
)
),
raw_links
) if raw_links else raw_data
def generate_sankey_data(resource):
"""
Generates nodes and links for the given Resouce object
:param resource: Resource object
:return: A dict containing nodes and links. nodes are a dict key by stage name
Results can be assigned to resource.data.sankey and saved
"""
settings = R.item_path(['data', 'settings'], resource)
stages = R.prop('stages', settings)
stage_key = R.prop('stageKey', settings)
value_key = R.prop('valueKey', settings)
location_key = R.prop('locationKey', settings)
node_name_key = R.prop('nodeNameKey', settings)
node_color_key = R.prop_or(None, 'nodeColorKey', settings)
default_location = R.prop('defaultLocation', settings)
delineator = R.prop_or(';', 'delineator', settings)
# A dct of stages by name
stage_by_name = stages_by_name(stages)
link_start_node_key = R.prop_or(None, 'linkStartNodeKey', settings)
link_end_node_key = R.prop_or(None, 'linkEndNodeKey', settings)
link_value_key = R.prop_or(None, 'linkValueKey', settings)
link_color_key = R.prop_or(None, 'linkColorKey', settings)
def accumulate_nodes(accum, raw_node, i):
"""
Accumulate each node, keying by the name of the node's stage key
Since nodes share stage keys these each result is an array of nodes
:param accum:
:param raw_node:
:param i:
:return:
"""
location_obj = resolve_coordinates(default_location, R.prop_or(None, location_key, raw_node), i)
location = R.prop('location', location_obj)
is_generalized = R.prop('isGeneralized', location_obj)
# The key where then node is stored is the stage key
node_stage = raw_node[stage_key]
# Get key from name or it's already a key
key = R.prop('key', R.prop_or(dict(key=node_stage), node_stage, stage_by_name))
# Copy all properties from resource.data except settings and raw_data
# Also grab raw_node properties
# This is for arbitrary properties defined in the data
# We put them in properties and propertyValues since graphql hates arbitrary key/values
properties = R.merge(
R.omit(['settings', 'rawData'], R.prop('data', resource)),
raw_node
)
properties[node_name_key] = humanize(properties[node_name_key])
return R.merge(
# Omit accum[key] since we'll concat it with the new node
R.omit([key], accum),
{
# concat accum[key] or [] with the new node
key: R.concat(
R.prop_or([], key, accum),
# Note that the value is an array so we can combine nodes with the same stage key
[
dict(
value=string_to_float(R.prop(value_key, raw_node)),
type='Feature',
geometry=dict(
type='Point',
coordinates=location
),
name=R.prop(node_name_key, raw_node),
isGeneralized=is_generalized,
properties=list(R.keys(properties)),
propertyValues=list(R.values(properties))
)
]
)
}
)
raw_nodes = create_raw_nodes(delineator, resource)
# Reduce the nodes
nodes_by_stage = R.reduce(
lambda accum, i_and_node: accumulate_nodes(accum, i_and_node[1], i_and_node[0]),
{},
enumerate(raw_nodes)
)
nodes = R.flatten(R.values(nodes_by_stage))
# See if there are explicit links
if R.item_path_or(False, ['data', 'settings', 'link_start_node_key'], resource):
raw_links = create_raw_links(delineator, resource)
node_key_key = R.prop('nodeNameKey', settings)
nodes_by_key = R.from_pairs(R.map(
lambda node: [prop_lookup(node, node_key_key), node],
nodes
))
links = R.map(
lambda link: dict(
source_node=nodes_by_key[link[link_start_node_key]],
target_node=nodes_by_key[link[link_end_node_key]],
value=link[link_value_key],
color=R.prop_or(None, link_color_key, link)
),
raw_links
)
else:
# Guess links from nodes and stages
links = create_links(stages, value_key, nodes_by_stage)
return dict(
nodes=nodes,
nodes_by_stage=nodes_by_stage,
# We might have explicit links or have to generate all possible based on the nodes
links=links
)