diff --git a/docs/Project.toml b/docs/Project.toml
index b6d965a..30fefed 100644
--- a/docs/Project.toml
+++ b/docs/Project.toml
@@ -14,5 +14,5 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 VegaLite = "112f6efa-9a02-5b7d-90c0-432ed331239a"
 
 [compat]
-PowerModels = "^0.19.2"
-PowerModelsDistribution = "^0.14.5, ^0.15"
+PowerModels = "^0.19.2, ^0.20, ^0.21"
+PowerModelsDistribution = "^0.14.5, ^0.15, ^0.16"
diff --git a/docs/make.jl b/docs/make.jl
index 70860e8..993bfab 100644
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -1,7 +1,7 @@
 using Documenter, PowerPlots, VegaLite, UUIDs, PowerModels, PowerModelsDistribution
 
 function Base.show(io::IO, m::MIME"text/html", v::VegaLite.VLSpec)
-    divid = string("vl", replace(string(uuid4()), "-"=>""))
+    divid = string("vl", replace(string(uuid4()), "-" => ""))
     print(io, "<div id='$divid' style=\"width:100%;height:100%;\"></div>")
     print(io, "<script type='text/javascript'>requirejs.config({paths:{'vg-embed': 'https://cdn.jsdelivr.net/npm/vega-embed@6?noext','vega-lib': 'https://cdn.jsdelivr.net/npm/vega-lib?noext','vega-lite': 'https://cdn.jsdelivr.net/npm/vega-lite@4?noext','vega': 'https://cdn.jsdelivr.net/npm/vega@5?noext'}}); require(['vg-embed'],function(vegaEmbed){vegaEmbed('#$divid',")
     VegaLite.our_json_print(io, v)
@@ -11,7 +11,11 @@ end
 makedocs(
     warnonly = true,
     modules = [PowerPlots],
-    format = Documenter.HTML(mathengine = Documenter.MathJax()),
+    format = Documenter.HTML(mathengine = Documenter.MathJax(),
+        size_threshold_warn = 2^20,
+        size_threshold = nothing,
+        example_size_threshold = nothing,
+    ),
     sitename = "PowerPlots",
     authors = "Noah Rhodes",
     pages = [
diff --git a/src/core/attribute_validation.jl b/src/core/attribute_validation.jl
index 93a22f5..cb78781 100644
--- a/src/core/attribute_validation.jl
+++ b/src/core/attribute_validation.jl
@@ -1,67 +1,77 @@
 
 "Validates the given plot_attributes according to their type"
 function _validate_plot_attributes!(plot_attributes::Dict{Symbol, Any})
-    for attr in keys(plot_attributes)
-      if !haskey(default_plot_attributes, attr)
-        Memento.warn(_LOGGER, "Ignoring unexpected attribute $(repr(attr))")
-      end
-    end
+  for (k,v) in plot_attributes
+    _validate_plot_attributes!(plot_attributes, k,v)
+  end
+end
 
-    # validate color attributes
-    for attr in _color_attributes
-        color = plot_attributes[attr]
-        if !(typeof(color) <: Union{String, Symbol, AbstractVector})
-          Memento.warn(_LOGGER, "Color value for $(repr(attr)) should be given as symbol or string")
-        else
-          try
-            if typeof(color) <: AbstractVector
-                parse.(Colors.Colorant, color) # parses all colors as CSS color
-            else
-                parse(Colors.Colorant, color) # try to parse the color as a CSS color
-                plot_attributes[attr] = [color] # package color into an array
-            end
-          catch e
-            Memento.warn(_LOGGER, "Invalid color $(repr(color)) given for $(repr(attr))")
-          end
-        end
-    end
+"Validates the given plot_attributes according to their type"
+function _validate_plot_attributes!(plot_attributes::Dict{Symbol,Any}, k::Symbol, v::Dict{Symbol,Any})
+  for (k1,v1) in v
+    _validate_plot_attributes!(v, k1,v1)
+  end
+end
 
-    # validate numeric attributes
-    for attr in _numeric_attributes
-      value = plot_attributes[attr]
-      if !(typeof(value) <: Union{Number, String})
-        Memento.warn(_LOGGER, "Value for $(repr(attr)) should be given as a number or numeric String")
-      elseif typeof(value) <: String
-        try
-            parse(Float64, value)
-        catch e
-            Memento.warn(_LOGGER, "Invalid number $(repr(value)) given for $(repr(attr))")
-        end
-      end
-    end
+"Validates the given plot_attributes according to their type"
+function _validate_plot_attributes!(plot_attributes::Dict{Symbol,Any}, attr::Symbol, v::Any)
+  if attr in _color_attributes
+    _validate_color_attribute!(plot_attributes, attr, v)
+  elseif attr in _numeric_attributes
+    _validate_numeric_attribute!(plot_attributes, attr, v)
+  elseif attr in _label_attributes
+    _validate_label_attribute!(plot_attributes, attr, v)
+  elseif attr in _boolean_attributes
+    _validate_boolean_attribute!(plot_attributes, attr, v)
+  end
+end
 
-    # validate data label attributes
-    for attr in _label_attributes
-      value = plot_attributes[attr]
-      if !(typeof(value) <: Union{String, Symbol})
-        Memento.warn(_LOGGER, "Value for $(repr(attr)) should be given as a String or Symbol")
+function _validate_color_attribute!(plot_attributes::Dict{Symbol,Any}, attr::Symbol, v::Any)
+  if !(typeof(v) <: Union{String, Symbol, AbstractVector})
+    Memento.warn(_LOGGER, "Color value for $(repr(attr)) should be given as symbol or string")
+  else
+    try
+      if typeof(v) <: AbstractVector
+        parse.(Colors.Colorant, v) # parses all colors as CSS color
+      else
+        parse(Colors.Colorant, v) # try to parse the color as a CSS color
+        plot_attributes[attr] = [v] # package color into an array
       end
+    catch e
+      Memento.warn(_LOGGER, "Invalid color $(repr(v)) given for $(repr(attr))")
     end
+  end
+end
 
-    # validate boolean attributes
-    for attr in _boolean_attributes
-      value = plot_attributes[attr]
-      if !(typeof(value) <: Bool)
-        Memento.warn(_LOGGER, "Value for $(repr(attr)) should be given as a Bool")
-      end
+function _validate_numeric_attribute!(plot_attributes::Dict{Symbol,Any}, attr::Symbol, v::Any)
+  if !(typeof(v) <: Union{Number, String})
+    Memento.warn(_LOGGER, "Value for $(repr(attr)) should be given as a number or numeric String")
+  elseif typeof(v) <: String
+    try
+      parse(Float64, v)
+    catch e
+      Memento.warn(_LOGGER, "Invalid number $(repr(v)) given for $(repr(attr))")
     end
+  end
 end
 
+function _validate_label_attribute!(plot_attributes::Dict{Symbol,Any}, attr::Symbol, v::Any)
+  if !(typeof(v) <: Union{String, Symbol})
+    Memento.warn(_LOGGER, "Value for $(repr(attr)) should be given as a String or Symbol")
+  end
+end
+
+function _validate_boolean_attribute!(plot_attributes::Dict{Symbol,Any}, attr::Symbol, v::Any)
+  if !(typeof(v) <: Bool)
+    Memento.warn(_LOGGER, "Value for $(repr(attr)) should be given as a Bool")
+  end
+end
 
 "Checks that the given column plot_attributes[data_attr] exists in the data"
-function _validate_data(data::DataFrames.DataFrame, data_column::Any, data_name::String)
+function _validate_data(data::DataFrames.DataFrame, data_column::Any, data_name::Symbol)
     if !(typeof(data_column) <: Union{String, Symbol})
-        return
+      Memento.warn(_LOGGER, "Value for $(repr(attr)) should be given as a String or Symbol")
+      return
     end
     if !(data_column in names(data) || data_column in propertynames(data))
         Memento.warn(_LOGGER, "Data column $(repr(data_column)) does not exist for $(data_name)")
diff --git a/src/core/data.jl b/src/core/data.jl
index 3dd5e40..a94a05d 100644
--- a/src/core/data.jl
+++ b/src/core/data.jl
@@ -3,7 +3,7 @@
  function get_parallel_edges(data, edge_types=supported_edge_types)
     edge_pairs = Dict()
     for edge_type in edge_types # supported edge_types
-        for (id,edge) in get(data, edge_type, Dict())
+        for (id,edge) in get(data, string(edge_type), Dict())
             bus_pair = (min(edge["f_bus"],edge["t_bus"]), max(edge["f_bus"],edge["t_bus"])) # get unique direction
             if !haskey(edge_pairs, bus_pair)
                 edge_pairs[bus_pair] = []
@@ -22,6 +22,7 @@ end
 
 "Add x/y coords for all any parallel branches, and offset the endpoints so each branch is visible"
 function offset_parallel_edges!(data,offset; edge_types=supported_edge_types)
+    get_parallel_edges(data, edge_types)
     for (bus_pair, edges) in get_parallel_edges(data, edge_types)
         n_edges = length(edges)
         xcoord_1 = data["bus"]["$(bus_pair[1])"]["xcoord_1"]
@@ -37,10 +38,10 @@ function offset_parallel_edges!(data,offset; edge_types=supported_edge_types)
 
         for i in eachindex(edges)
             (edge_type, edge_id) = edges[i]
-            data[edge_type][edge_id]["ycoord_1"] = ycoord_1 + offset_range[i]*normal_direction[2]
-            data[edge_type][edge_id]["ycoord_2"] = ycoord_2 + offset_range[i]*normal_direction[2]
-            data[edge_type][edge_id]["xcoord_1"] = xcoord_1 + offset_range[i]*normal_direction[1]
-            data[edge_type][edge_id]["xcoord_2"] = xcoord_2 + offset_range[i]*normal_direction[1]
+            data[string(edge_type)][edge_id]["ycoord_1"] = ycoord_1 + offset_range[i]*normal_direction[2]
+            data[string(edge_type)][edge_id]["ycoord_2"] = ycoord_2 + offset_range[i]*normal_direction[2]
+            data[string(edge_type)][edge_id]["xcoord_1"] = xcoord_1 + offset_range[i]*normal_direction[1]
+            data[string(edge_type)][edge_id]["xcoord_2"] = xcoord_2 + offset_range[i]*normal_direction[1]
         end
     end
     return data
diff --git a/src/core/options.jl b/src/core/options.jl
index 26544a7..cd849e6 100644
--- a/src/core/options.jl
+++ b/src/core/options.jl
@@ -10,132 +10,54 @@ const color_schemes=Dict{Symbol,Any}(
     :yellows => colorscheme2array(ColorSchemes.ColorScheme(range(Colors.colorant"#8C6D31", Colors.colorant"#E7CB94", length=5))),
 )
 
-
-# Default plot attributes
 default_plot_attributes = Dict{Symbol, Any}(
-  :gen_color => color_schemes[:oranges],
-  :bus_color => color_schemes[:greens],
-  :load_color => color_schemes[:reds],
-  :branch_color => color_schemes[:blues],
-  :switch_color => color_schemes[:grays],
-  :transformer_color => color_schemes[:yellows],
-  :connector_color => [:gray],
-  :dcline_color => color_schemes[:purples],
-  :storage_color => color_schemes[:oranges],
-  :flow_color => :black,
-  :gen_size => 2e2,
-  :bus_size => 5e2,
-  :load_size => 2e2,
-  :branch_size => 5,
-  :switch_size => 5,
-  :transformer_size => 5,
-  :connector_size => 3,
-  :dcline_size => 5,
-  :storage_size => 2e2,
   :width => 500,
   :height => 500,
-  :gen_data => "ComponentType",
-  :bus_data => "ComponentType",
-  :load_data => "ComponentType",
-  :branch_data => "ComponentType",
-  :switch_data => "ComponentType",
-  :transformer_data => "ComponentType",
-  :connector_data => "ComponentType",
-  :dcline_data => "ComponentType",
-  :storage_data => "ComponentType",
-  :gen_data_type => "nominal",
-  :bus_data_type => "nominal",
-  :load_data_type => "nominal",
-  :branch_data_type => "nominal",
-  :switch_data_type => "nominal",
-  :transformer_data_type => "nominal",
-  :dcline_data_type => "nominal",
-  :storage_data_type => "nominal",
+  :parallel_edge_offset=>0.05,
+)
+
+default_edge_attributes = Dict{Symbol, Any}(
+  :color => color_schemes[:blues],
+  :size => 5,
+  :data => "ComponentType",
+  :data_type => "nominal",
+  :flow_color => :black,
+  :flow_arrow_size_range=>[500,3000],
   :show_flow => false,
   :show_flow_legend => false,
-  :flow_arrow_size_range=>[500,3000],
-  :parallel_edge_offset => 0.05,
-  :connector_dash=>[4,4],
-);
+)
 
-# Returns a deepcopy of the default_plot_attributes, used to initialize plot_attributes in utils.jl
-function copy_default_attributes()
-  return deepcopy(default_plot_attributes);
-end
+default_connector_attributes = Dict{Symbol, Any}(
+  :color => [:gray],
+  :size => 3,
+  :dash => [4, 4],
+  :data => "ComponentType",
+  :data_type => "nominal",
+)
 
-# Dictionary of aliases of properties
-# Aliases are replaced by their key in plot_attributes
-# for example, nodecolor/markercolor/marker_color, edgecolor/edge_color/ec can be used to
-# set nodecolor and edgecolor respectively
-const attribute_aliases = Dict(
-  :gen_color => [:gencolor, :generatorcolor, :generator_color, :node_color],
-  :bus_color => [:buscolor, :substationcolor, :substation_color, :node_color],
-  :load_color => [:loadcolor, :demandcolor, :demand_color, :node_color],
-  :branch_color => [:branchcolor, :transmissionlinecolor, :transmissionline_color,:transmission_line_color, :edge_color],
-  :switch_color => [:switchcolor, :edge_color],
-  :transformer_color => [:transformercolor, :edge_color],
-  :connector_color => [:connectorcolor, :edge_color],
-  :storage_color => [:storagecolor, :batterycolor, :battery_color, :node_color],
-  :dcline_color => [:dclinecolor, :dc_line_color, :edge_color],
-  :bus_size => [:bussize, :node_size],
-  :gen_size => [:gensize, :node_size],
-  :load_size => [:loadsize, :node_size],
-  :storage_size => [:storagesize, :node_size],
-  :branch_size => [:branchsize, :line_size, :edge_size],
-  :switch_size => [:switchsize, :edge_size],
-  :transformer_size => [:transformersize, :edge_size],
-  :dcline_size => [:dclinesize, :line_size, :edge_size],
-  :connector_size => [:connectorsize, :edge_size],
-  :flow_arrow_size_range =>[:flow_size, :flowsize, :arrow_size, :arrowsize],
-  :flow_color => [:flowcolor, :arrow_color, :arrowcolor],
-  :show_flow => [:flow, :showflow, :arrows, :show_arrows, :showarrows, :flows, :show_flows, :showflows],
-  :show_flow_legend => [:flowlegend, :flow_legend, :arrowlegend, :arrow_legend, :show_arrow_legend],
+default_node_attributes = Dict{Symbol, Any}(
+  :color => color_schemes[:greens],
+  :size => 5e2,
+  :data => "ComponentType",
+  :data_type => "nominal",
 )
 
+
 const _color_attributes = [ # color (String or Symbol) type parameters
-  :gen_color,
-  :bus_color,
-  :load_color,
-  :branch_color,
-  :connector_color,
-  :switch_color,
-  :transformer_color,
-  :storage_color,
-  :dcline_color,
-  :flow_color
+  :color,
 ]
 const _numeric_attributes = [ # numeric parameters
-  :gen_size,
-  :bus_size,
-  :load_size,
-  :branch_size,
-  :connector_size,
-  :switch_size,
-  :transformer_size,
-  :dcline_size,
-  :storage_size,
+  :size,
   :width,
   :height,
   :parallel_edge_offset,
 ]
 const _label_attributes = [ # label (String or Symbol) type parameters
-  :gen_data,
-  :bus_data,
-  :load_data,
-  :branch_data,
-  :dcline_data,
-  :switch_data,
-  :transformer_data,
-  :storage_data,
-  :gen_data_type,
-  :bus_data_type,
-  :branch_data_type,
-  :switch_data_type,
-  :transformer_data_type,
-  :dcline_data_type,
-  :storage_data_type
+  :data,
+  :data_type
 ]
 const _boolean_attributes = [ # boolean type parameters
   :show_flow,
   :show_flow_legend,
 ]
+
diff --git a/src/core/types.jl b/src/core/types.jl
index 52ad11d..66f8a7c 100644
--- a/src/core/types.jl
+++ b/src/core/types.jl
@@ -1,8 +1,8 @@
 
-const supported_component_types = ["bus","gen","branch","dcline","load", "switch", "transformer"]
-const supported_node_types = ["bus","gen","load"]
-const supported_edge_types = ["branch","dcline", "switch", "transformer"]
 
+const supported_connected_types = [:gen,:load,:storage]
+const supported_node_types = [:bus]
+const supported_edge_types = [:branch,:dcline,:switch,:transformer]
 
 """
     PowerModelsGraph
@@ -17,40 +17,40 @@ four fields: a Graphs.SimpleDiGraph, a map from the node ids to the components,
 """
 mutable struct PowerModelsGraph
     graph::Graphs.SimpleGraph
-    node_comp_map::Dict{Int,Tuple{String, String}}
-    edge_comp_map::Dict{Tuple{Int,Int},Tuple{String, String}}
-    edge_connector_map::Dict{Tuple{Int,Int},Tuple{String, String}}
+    node_comp_map::Dict{Int,Tuple{Symbol, Int}}
+    edge_comp_map::Dict{Tuple{Int,Int},Tuple{Symbol, Int}}
+    edge_connector_map::Dict{Tuple{Int,Int},Tuple{Symbol, Int}}
 
-    function PowerModelsGraph(data::Dict{String,<:Any}, node_types::Array{String,1}, edge_types::Array{String,1})
+    function PowerModelsGraph(data::Dict{String,<:Any}, node_components::Array{Symbol,1}, edge_components::Array{Symbol,1}, connected_components::Array{Symbol,1})
 
-        node_count = sum(length(keys(get(data,node_type,Dict()))) for node_type in node_types)
-        G = Graphs.SimpleGraph(node_count) # create graph
+        graph_node_count = sum(length(keys(get(data,string(comp_type),Dict()))) for comp_type in [node_components...,connected_components...])
+        G = Graphs.SimpleGraph(graph_node_count) # create graph
 
-        node_comp_array = Vector{Tuple{String,String}}(undef,node_count)
+        node_comp_array = Vector{Tuple{Symbol,Int}}(undef,graph_node_count)
         i_1 = 1
-        for comp_type in node_types
-            if haskey(data,comp_type)
-                for comp_id in sort(collect(keys(data[comp_type]))) #sort seems to get better layout results?
+        for comp_type in [node_components...,connected_components...]
+            if haskey(data,string(comp_type))
+                for comp_id in sort(parse.(Int,collect(keys(data[string(comp_type)])))) #sort seems to get better layout results?
                     node_comp_array[i_1] = (comp_type,comp_id)
                     i_1+=1
                 end
             end
         end
-        comp_node_map = Dict(zip(node_comp_array,1:node_count))
-        node_comp_map = Dict(zip(1:node_count,node_comp_array))
+        comp_node_map = Dict(zip(node_comp_array,1:graph_node_count))
+        node_comp_map = Dict(zip(1:graph_node_count,node_comp_array))
 
 
-
-        edge_comp_count = sum(length(keys(get(data,edge_type,Dict()))) for edge_type in edge_types)
-        edge_comp_array = Vector{Tuple{String,String}}(undef,edge_comp_count)
+        edge_comp_count = sum(length(keys(get(data,string(comp_type),Dict()))) for comp_type in edge_components)
+        edge_comp_array = Vector{Tuple{Symbol,Int}}(undef,edge_comp_count)
         edge_node_array = Vector{Tuple{Int,Int}}(undef,edge_comp_count)
         i_2 = 1
-        for comp_type in edge_types # add edges
-            if haskey(data,comp_type)
-                for (comp_id,comp) in data[comp_type]
-                    edge_comp_array[i_2] = (comp_type,comp_id)
-                    s = comp_node_map[("bus",string(comp["f_bus"]))]
-                    d = comp_node_map[("bus",string(comp["t_bus"]))]
+        for comp_type in edge_components # add edges
+            if haskey(data,string(comp_type))
+                for (comp_id,comp) in data[string(comp_type)]
+                    edge_comp_array[i_2] = (comp_type,parse(Int,comp_id))
+                    #TODO  generically identify the node type and keys of source and destination
+                    s = comp_node_map[(:bus,comp["f_bus"])]
+                    d = comp_node_map[(:bus,comp["t_bus"])]
                     edge_node_array[i_2] = (s,d)
                     Graphs.add_edge!(G, s, d)
                     i_2+=1
@@ -59,29 +59,20 @@ mutable struct PowerModelsGraph
         end
         edge_comp_map = Dict(zip(edge_node_array,edge_comp_array))
 
-        # sum does not work when "bus" is only node_type
-        # edge_connector_count = sum(length(keys(get(data,node_type,Dict()))) for node_type in node_types if node_type != "bus")
-        edge_connector_count = 0
-        for node_type in node_types
-            if node_type != "bus"
-                edge_connector_count+= length(keys(get(data,node_type,Dict())))
-            end
-        end
+        edge_connector_count = sum(length(keys(get(data,string(comp_type),Dict()))) for comp_type in connected_components; init=0)
 
-        edge_connector_array = Vector{Tuple{String,String}}(undef,edge_connector_count)
+        edge_connector_array = Vector{Tuple{Symbol,Int}}(undef,edge_connector_count)
         edge_node_array = Vector{Tuple{Int,Int}}(undef,edge_connector_count)
         i_3 = 1
-        for comp_type in node_types #add connectors
-            if comp_type != "bus"
-                if haskey(data,comp_type)
-                    for (comp_id,comp) in data[comp_type]
-                        edge_connector_array[i_3] = (comp_type,comp_id)
-                        s = comp_node_map[("bus",string(comp["$(comp_type)_bus"]))]
-                        d = comp_node_map[(comp_type,comp_id)]
-                        edge_node_array[i_3] = (s,d)
-                        Graphs.add_edge!(G, s, d)
-                        i_3+=1
-                    end
+        for comp_type in connected_components #add connectors
+            if haskey(data,string(comp_type))
+                for (comp_id,comp) in data[string(comp_type)]
+                    edge_connector_array[i_3] = (comp_type,parse(Int,comp_id))
+                    s = comp_node_map[(:bus,comp["$(string(comp_type))_bus"])]
+                    d = comp_node_map[(comp_type,parse(Int,comp_id))]
+                    edge_node_array[i_3] = (s,d)
+                    Graphs.add_edge!(G, s, d)
+                    i_3+=1
                 end
             end
         end
@@ -94,9 +85,11 @@ end
 
 ""
 function PowerModelsGraph(data::Dict{String,<:Any};
-    node_types=supported_node_types::Array{String,1},
-    edge_types=supported_edge_types::Array{String,1})
-    return PowerModelsGraph(data, node_types, edge_types)
+    node_components=supported_node_types::Array{Symbol,1},
+    edge_components=supported_edge_types::Array{Symbol,1},
+    connected_components=supported_connected_types::Array{Symbol,1}
+    )
+    return PowerModelsGraph(data, node_components, edge_components, connected_components)
 end
 
 
@@ -107,82 +100,73 @@ A structure containing a dataframe for each component type.
 """
 mutable struct PowerModelsDataFrame
     metadata::DataFrames.DataFrame
-    bus::DataFrames.DataFrame
-    gen::DataFrames.DataFrame
-    branch::DataFrames.DataFrame
-    dcline::DataFrames.DataFrame
-    load::DataFrames.DataFrame
-    connector::DataFrames.DataFrame
-    switch::DataFrames.DataFrame
-    transformer::DataFrames.DataFrame
-
-    function PowerModelsDataFrame(case::Dict{String,<:Any})
+    components::Dict{Symbol,DataFrames.DataFrame}
+
+    function PowerModelsDataFrame(case::Dict{String,<:Any}; components=nothing)
         data = deepcopy(case)
-        comp_dataframes = tuple((DataFrames.DataFrame() for i in 1:length(supported_component_types)+2)...) # +2 is for metadata and connector
-        if InfrastructureModels.ismultinetwork(data)
-            for (nw_id, net) in data["nw"]
 
-                net["nw_id"]=nw_id # give each network, component its parent nw_id
-                for comp_type in [supported_component_types..., "connector"]
-                    for (comp_id, comp) in get(net,comp_type,Dict())
-                        comp["nw_id"] = nw_id
-                    end
+        if InfrastructureModels.ismultinetwork(data)
+            if isnothing(components)
+                components = Symbol[]
+                for (id,nw) in data["nw"]
+                    append!(components, [Symbol(k) for (k,v) in nw if v isa Dict ])
                 end
-
-                comp_dataframes_new = _PowerModelsDataFrame(net::Dict{String,<:Any}, comp_dataframes...)
+                components = unique(components)
             end
+            comp_dataframes = Dict(comp_type=>DataFrames.DataFrame() for comp_type in components)
+
 
-            #combine toplevel and network metadata
             data["nw_id"] = "top_level"
-            _metadata_to_dataframe(data, comp_dataframes[1])
-        else
-            ## not a multinetwork
-            comp_dataframes = _PowerModelsDataFrame(data::Dict{String,<:Any}, comp_dataframes...)
+            metadata = DataFrames.DataFrame()
+            _metadata_to_dataframe!(data, metadata)
 
-        end
-        new(comp_dataframes...)
-    end
-end
+            for (nw_id, net) in data["nw"]
 
+                net["nw_id"]=nw_id # give each network, component its parent nw_id
+                for comp_type in components
+                    for (comp_id, comp) in get(net,string(comp_type),Dict())
+                        comp["nw_id"] = nw_id # give each component its nw_id
+                        comp["ComponentType"] = comp_type # give each component its type name
+                    end
 
-""
-function _PowerModelsDataFrame(sn_net::Dict{String,<:Any}, metadata, bus, gen, branch, dcline, load, connector, switch, transformer)
+                     #combine toplevel and network metadata
+                     _metadata_to_dataframe!(net, metadata)
+                    _comp_dict_to_dataframe!(get(net,string(comp_type), Dict{String,Any}()), comp_dataframes[comp_type])
+                end
+            end
+        else # not a multinetwork
+            if isnothing(components)
+                components = [Symbol(k) for (k,v) in data if v isa Dict]
+            end
+            comp_dataframes = Dict(comp_type=>DataFrames.DataFrame() for comp_type in components)
 
-        data = deepcopy(sn_net) # prevent overwriting input data
+            metadata = DataFrames.DataFrame()
+            _metadata_to_dataframe!(data, metadata)
+
+            for comp_type in components
+                for (id,comp) in get(data, string(comp_type), Dict{String,Any}())
+                    comp["ComponentType"] = comp_type
+                end
+                _comp_dict_to_dataframe!(get(data,string(comp_type), Dict{String,Any}()), comp_dataframes[comp_type])
 
-        ## add comp_type to each component
-        for comp_type in [supported_component_types..., "connector"]
-            for (comp_id, comp) in get(data,comp_type,Dict())
-                comp["ComponentType"] = comp_type
             end
         end
 
-
-        ## Assign component DataFrames
-        _metadata_to_dataframe(data, metadata)
-        _comp_dict_to_dataframe(get(data,"bus", Dict{String,Any}()), bus)
-        _comp_dict_to_dataframe(get(data,"gen", Dict{String,Any}()), gen)
-        _comp_dict_to_dataframe(get(data,"branch", Dict{String,Any}()), branch)
-        _comp_dict_to_dataframe(get(data,"dcline", Dict{String,Any}()), dcline)
-        _comp_dict_to_dataframe(get(data,"load", Dict{String,Any}()), load)
-        _comp_dict_to_dataframe(get(data,"connector",Dict{String,Any}()), connector)
-        _comp_dict_to_dataframe(get(data,"switch",Dict{String,Any}()), switch)
-        _comp_dict_to_dataframe(get(data,"transformer",Dict{String,Any}()), transformer)
-
-    return (metadata,bus,gen,branch,dcline,load,connector,switch,transformer)
+        new(metadata, comp_dataframes)
+    end
 end
 
 
 "convert non-component data into a dataframe"
-function _metadata_to_dataframe(data, metadata)
+function _metadata_to_dataframe!(data, metadata)
     ## Seperate componets Dicts from metadata
     metadata_key = Symbol[]
     metadata_val = Any[]
     for (k,v) in sort(collect(data); by=x->x[1])
         if typeof(v) <: Dict && InfrastructureModels._iscomponentdict(v)
-            if ~(k in [supported_component_types..., "connector"])
-                Memento.warn(_PM._LOGGER, "Component type $k is not yet not supported")
-            end
+            # if ~(k in [supported_component_types..., "connector"])
+            #     Memento.warn(_PM._LOGGER, "Component type $k is not yet not supported")
+            # end
         else
             push!(metadata_key,Symbol(k))
             push!(metadata_val,v)
@@ -195,8 +179,8 @@ function _metadata_to_dataframe(data, metadata)
 end
 
 
-"convert a componet dictionary such as `bus` into a dataframe."
-function _comp_dict_to_dataframe(comp_dict::Dict{String,<:Any}, df)
+"convert a component dictionary such as `bus` into a dataframe."
+function _comp_dict_to_dataframe!(comp_dict::Dict{String,<:Any}, df)
     if length(comp_dict) <= 0 ## Should there be an empty dataframe, or a nonexistent dataframe?
         return df
     end
@@ -215,5 +199,5 @@ end
 
 "convert a componet dictionary such as `bus` into a dataframe."
 function comp_dict_to_dataframe(comp_dict::Dict{String,<:Any})
-    return _comp_dict_to_dataframe(comp_dict, DataFrames.DataFrame())
+    return _comp_dict_to_dataframe!(comp_dict, DataFrames.DataFrame())
 end
diff --git a/src/core/utils.jl b/src/core/utils.jl
index afa2aa3..a51a174 100644
--- a/src/core/utils.jl
+++ b/src/core/utils.jl
@@ -1,88 +1,43 @@
-#===
-Below are functions copied from `utils.jl` in GraphRecipes
-See: https://github.com/JuliaPlots/GraphRecipes.jl/blob/master/src/utils.jl
-===#
 
-# gets the alias replacement name to replace the attribute sym in plot_attributes
-function _replacement_kwarg(sym, name, plot_attributes, attribute_aliases)
-  replacement = name
-  for alias in attribute_aliases[sym]
-      if haskey(plot_attributes, alias)
-          replacement = plot_attributes[alias]
-      end
-  end
-  replacement
-end
 
-# adds the original keyword of all aliases into plot_attributes
-# and sets it to the alias value
-macro process_aliases(plot_attributes, attribute_aliases)
-  ex = Expr(:block)
-  attributes = getfield(__module__, attribute_aliases) |> keys
-  ex.args = [Expr(:(=), :($(esc(plot_attributes))[$(Meta.quot(sym))]),
-                  :($(esc(_replacement_kwarg))($(QuoteNode(sym)), $(esc(sym)),
-                    $(esc(plot_attributes)), $(esc(attribute_aliases))))) for sym in attributes]
-  ex
+function initialize_default_attributes(edge_components, node_components, connected_components)
+  plot_attributes = deepcopy(default_plot_attributes)
+    for comp_type in edge_components
+        plot_attributes[comp_type] = deepcopy(default_edge_attributes)
+    end
+    for comp_type in [node_components..., connected_components...]
+        plot_attributes[comp_type] = deepcopy(default_node_attributes)
+    end
+    plot_attributes[:connector] = deepcopy(default_connector_attributes)
+    return plot_attributes
 end
-push!(_EXCLUDE_SYMBOLS, Symbol("@process_aliases"))
 
-# called after aliases are processed via @process_aliases
-# removes any alias keys from plot_attributes
-function _remove_aliases!(sym, plot_attributes, attribute_aliases)
-  for alias in attribute_aliases[sym]
-      if haskey(plot_attributes, alias)
-          delete!(plot_attributes, alias)
-      end
-  end
+function apply_kwarg_attributes!(plot_attributes, kwargs)
+    for (k,v) in kwargs
+      _apply_kwarg_attributes!(plot_attributes, k, v)
+    end
 end
 
-#===
-New PowerPlots code below
-===#
-
-# Adds the given keyword args as entries into plot_attributes
-function _convert_to_attributes!(plot_attributes, kwargs)
-  for (var, val) in kwargs
-    plot_attributes[var] = val
+function _apply_kwarg_attributes!(plot_attributes::Dict, k::Symbol, v::Any)
+  if !haskey(plot_attributes, k)
+    Memento.warn(_LOGGER, "Ignoring unexpected attribute $(repr(k))")
   end
+  plot_attributes[k] = v
 end
 
-function _attributes_as_variables(plot_attributes, kwargs)
-  ex = Expr(:block)
-  ex.args = [(haskey(kwargs, var) ? Expr(:(=), var, Meta.quot(kwargs[var]))
-     : Expr(:(=), var, Meta.quot(val))) for (var, val) in plot_attributes]
-  return ex
-end
-
-macro prepare_plot_attributes(kwargs)
-  ex = quote
-    _kwargs = $(esc(kwargs));
-    plot_attributes = copy_default_attributes(); # get a copy of the default attributes
-    _attributes_as_variables(plot_attributes, _kwargs) |> eval; # create variables from the default attributes
-    _convert_to_attributes!(plot_attributes, _kwargs); # add kwargs into plot_attributes
-    @process_aliases plot_attributes attribute_aliases; # process the aliases and add original attributes
-    # remove alias names from plot_attributes
-    for arg in keys(attribute_aliases)
-      _remove_aliases!(arg, plot_attributes, attribute_aliases)
-    end;
-  end;
-  push!(ex.args, Expr(:(=), esc(:plot_attributes), :plot_attributes)); # create external plot_attributes dict
-  ex
+function _apply_kwarg_attributes!(plot_attributes::Dict, k::Symbol, v::Vector{Pair{Symbol,Any}})
+  for (k1,v1) in v
+    _apply_kwarg_attributes!(plot_attributes[k], k1, v1)
+  end
 end
-push!(_EXCLUDE_SYMBOLS, Symbol("@prepare_plot_attributes"))
-
-# #=== Example Usage ===#
-# function powerplot(case; spring_constant=1e-3, kwargs...)
-#   # Copy the line below at the start of the plot method
-#   @prepare_plot_attributes(kwargs); # creates the plot_attributes dictionary
-
-#   println(plot_attributes) # TODO remove this in real code (it's just for debug)
-
-#   # Rest of plotting code...
-# end
 
 
 "Convert a color scheme `cs` into an array of string hex colors, usable by VegaLite"
 function colorscheme2array(cs::ColorSchemes.ColorScheme)
     return a = ["#$(Colors.hex(c))" for c in cs]
 end
+
+
+function ucfirst(s::AbstractString)
+    return uppercase(s[1]) * s[2:end]
+end
\ No newline at end of file
diff --git a/src/layouts/common.jl b/src/layouts/common.jl
index 466c1af..c01fb78 100644
--- a/src/layouts/common.jl
+++ b/src/layouts/common.jl
@@ -34,25 +34,34 @@ Create a layout for a powermodels data dictionary.  This function creates a grap
 and `edge_types`.  A layout function is then applied, by default `layout_graph_kamada_kawai!`.  A new case dictionary with the positions of the
 components is returned.
 """
-function layout_network(case::Dict{String,<:Any};
+function layout_network(case::Dict{String,<:Any}; kwargs...)
+    layout_network!(deepcopy(case); kwargs...)
+end
+
+"""
+Create a layout for a powermodels data dictionary.  This function creates a graph according to the specified keyword arguments `node_types`
+and `edge_types`.  A layout function is then applied, by default `layout_graph_kamada_kawai!`.  A new case dictionary with the positions of the
+components is returned.
+"""
+function layout_network!(data::Dict{String,<:Any};
     fixed = false,
     layout_algorithm = kamada_kawai,
-    node_types::Array{String,1}=supported_node_types,
-    edge_types::Array{String,1}=supported_edge_types,
+    node_components::Array{Symbol,1}=supported_node_types,
+    edge_components::Array{Symbol,1}=supported_edge_types,
+    connected_components::Array{Symbol,1}=supported_connected_types,
     connector_weight=0.5,
     edge_weight=1.0,
     kwargs...
     )
 
-    data = deepcopy(case)
-    PMG = PowerModelsGraph(data,node_types,edge_types)
+    PMG = PowerModelsGraph(data,node_components,edge_components,connected_components)
 
     # calculate weights
     weights = zeros(size(PMG.graph))
     for ((s,d),(comp_type,comp_id)) in PMG.edge_comp_map
 
-        if haskey(case[comp_type][comp_id],"weight")
-            w = compcase[comp_type][comp_id]["weight"]
+        if haskey(data[string(comp_type)][string(comp_id)],"weight")
+            w = data[string(comp_type)][string(comp_id)]["weight"]
         else
             w=edge_weight
         end
@@ -62,8 +71,8 @@ function layout_network(case::Dict{String,<:Any};
         end
     end
     for ((s,d),(comp_type,comp_id)) in PMG.edge_connector_map
-        if haskey(case[comp_type][comp_id],"weight")
-            w = compcase[comp_type][comp_id]["weight"]
+        if haskey(data[string(comp_type)][string(comp_id)],"weight")
+            w = data[string(comp_type)][string(comp_id)]["weight"]
         else
             w=connector_weight
         end
@@ -82,8 +91,8 @@ function layout_network(case::Dict{String,<:Any};
         initialpos = Vector{GeometryBasics.Point{2,Float64}}(undef, N)
         for i in 1:length(fixed_pos)
             (comp_type, comp_id) = PMG.node_comp_map[i]
-            fixed_pos[i] = haskey(data[comp_type][comp_id], "xcoord_1") && haskey(data[comp_type][comp_id], "ycoord_1")
-            initialpos[i] = GeometryBasics.Point(get(data[comp_type][comp_id], "xcoord_1", NaN), get(data[comp_type][comp_id], "ycoord_1", NaN))
+            fixed_pos[i] = haskey(data[string(comp_type)][string(comp_id)], "xcoord_1") && haskey(data[string(comp_type)][string(comp_id)], "ycoord_1")
+            initialpos[i] = GeometryBasics.Point(get(data[string(comp_type)][string(comp_id)], "xcoord_1", NaN), get(data[string(comp_type)][string(comp_id)], "ycoord_1", NaN))
         end
         fixed_initial_pos = [j for j in initialpos if !isnan(j)]
         center = sum(fixed_initial_pos)/length(fixed_initial_pos)
@@ -117,7 +126,7 @@ function layout_network(case::Dict{String,<:Any};
     end
 
     apply_node_positions!(data,positions, PMG)
-    extract_layout_extent!(data, positions)
+    # extract_layout_extent!(data, positions)
 
     return data
 end
@@ -127,15 +136,15 @@ end
 function apply_node_positions!(data,positions, PMG)
     # Set Node Positions
     for (node,(comp_type,comp_id)) in PMG.node_comp_map
-        data[comp_type][comp_id]["xcoord_1"] = positions[node][1]
-        data[comp_type][comp_id]["ycoord_1"] = positions[node][2]
+        data[string(comp_type)][string(comp_id)]["xcoord_1"] = positions[node][1]
+        data[string(comp_type)][string(comp_id)]["ycoord_1"] = positions[node][2]
     end
     # Set Edge positions
     for ((s,d),(comp_type,comp_id)) in PMG.edge_comp_map
-        data[comp_type][comp_id]["xcoord_1"] = positions[s][1]
-        data[comp_type][comp_id]["ycoord_1"] = positions[s][2]
-        data[comp_type][comp_id]["xcoord_2"] = positions[d][1]
-        data[comp_type][comp_id]["ycoord_2"] = positions[d][2]
+        data[string(comp_type)][string(comp_id)]["xcoord_1"] = positions[s][1]
+        data[string(comp_type)][string(comp_id)]["ycoord_1"] = positions[s][2]
+        data[string(comp_type)][string(comp_id)]["xcoord_2"] = positions[d][1]
+        data[string(comp_type)][string(comp_id)]["ycoord_2"] = positions[d][2]
     end
 
 
@@ -150,7 +159,7 @@ function apply_node_positions!(data,positions, PMG)
             "ycoord_1" => positions[s][2],
             "xcoord_2" => positions[d][1],
             "ycoord_2" => positions[d][2],
-            "source_id"=> (comp_type,comp_id)
+            "source_id"=> (string(comp_type),comp_id)
         )
         id+=1
     end
@@ -158,29 +167,29 @@ function apply_node_positions!(data,positions, PMG)
     return data
 end
 
-"Extract layout coordinate extent for scaling purposes"
-function extract_layout_extent!(data::Dict{String,<:Any}, positions)
-    # find the extremes
-    min_x = min_y = Inf
-    max_x = max_y = -Inf
-    for pos in positions
-        x, y = pos
-        min_x, min_y = min(min_x, x), min(min_y, y)
-        max_x, max_y = max(max_x, x), max(max_y, y)
-    end
-
-    width, height = (max_x - min_x), (max_y - min_y)
-    padding = min(50, 0.2 * (width + height) / 2) # set padding to be minimum of 50 px or 20% the average of the width and height
-
-    # add to data
-    data["layout_extent"] = Dict{String, Any}()
-    data["layout_extent"]["min_x"] = min_x
-    data["layout_extent"]["min_y"] = min_y
-    data["layout_extent"]["max_x"] = max_x
-    data["layout_extent"]["max_y"] = max_y
-    data["layout_extent"]["width"] = width
-    data["layout_extent"]["height"] = height
-    data["layout_extent"]["padding"] = padding
-
-    return data
-end
\ No newline at end of file
+# "Extract layout coordinate extent for scaling purposes"
+# function extract_layout_extent!(data::Dict{String,<:Any}, positions)
+#     # find the extremes
+#     min_x = min_y = Inf
+#     max_x = max_y = -Inf
+#     for pos in positions
+#         x, y = pos
+#         min_x, min_y = min(min_x, x), min(min_y, y)
+#         max_x, max_y = max(max_x, x), max(max_y, y)
+#     end
+
+#     width, height = (max_x - min_x), (max_y - min_y)
+#     padding = min(50, 0.2 * (width + height) / 2) # set padding to be minimum of 50 px or 20% the average of the width and height
+
+#     # add to data
+#     # data["layout_extent"] = Dict{String, Any}()
+#     data["layout_min_x"] = min_x
+#     data["layout_min_y"] = min_y
+#     data["layout_max_x"] = max_x
+#     data["layout_max_y"] = max_y
+#     # data["layout_extent"]["layout_width"] = width
+#     # data["layout_extent"]["layout_height"] = height
+#     # data["layout_extent"]["layout_padding"] = padding
+
+#     return data
+# end
\ No newline at end of file
diff --git a/src/plots/plot.jl b/src/plots/plot.jl
index e94ff47..f80d50b 100644
--- a/src/plots/plot.jl
+++ b/src/plots/plot.jl
@@ -14,11 +14,10 @@ Create a plower plot. Check github repo for documentation on kwarg options.
 function powerplot(
     case::Dict{String,<:Any};
     layout_algorithm=kamada_kawai,
-    components=supported_component_types,
+    edge_components=[:branch],
+    node_components=[:bus],
+    connected_components=[:gen,:load],
     fixed=false,
-    invalid_keys = Dict("branch"  => ["mu_angmin", "mu_angmax", "mu_sf", "shift", "rate_b", "rate_c", "g_to", "g_fr", "mu_st", "source_id", "f_bus", "t_bus",  "qf", "angmin", "angmax", "qt", "tap"],#["b_fr","b_to", "xcoord_1", "xcoord_2", "ycoord_1", "ycoord_2", "pf", "src","dst","rate_a","br_r","br_x","index","br_status"],
-    "bus"     => ["mu_vmax", "lam_q", "mu_vmin", "source_id","lam_p"],#["xcoord_1", "ycoord_1", "bus_type", "name", "vmax",  "vmin", "index", "va", "vm", "base_kv"],
-    "gen"     => ["vg","gen_bus","cost","ncost", "qc1max","qc2max", "ramp_agc", "qc1min", "qc2min", "pc1", "ramp_q", "mu_qmax", "ramp_30", "mu_qmin", "shutdown", "startup","ramp_10","source_id", "mu_pmax", "pc2", "mu_pmin","apf",]),#["xcoord_1", "ycoord_1",  "pg", "qg",  "pmax",   "mbase", "index", "cost", "qmax",  "qmin", "pmin", "gen_status"]),
     kwargs...)
 
     if InfrastructureModels.ismultinetwork(case)
@@ -28,66 +27,43 @@ function powerplot(
     # copy data for modification by plots
     data = deepcopy(case)
 
-    # remove components that are not to be plotted
-    for component_type in supported_component_types
-        if !(component_type in components) && haskey(data, component_type)
-            delete!(data, component_type)
-        end
-    end
-
-    @prepare_plot_attributes(kwargs) # creates the plot_attributes dictionary
+    # Create plot_atrributes by taking kwargs and updating default values.  If kwarg is doesn't exist in an defaults, give error
+    plot_attributes = initialize_default_attributes(edge_components, node_components, connected_components)
+    apply_kwarg_attributes!(plot_attributes, kwargs)
     _validate_plot_attributes!(plot_attributes) # check the attributes for valid input types
 
-    data = layout_network(data; layout_algorithm=layout_algorithm, fixed=fixed, kwargs...)
+    data = layout_network(case; layout_algorithm=layout_algorithm, fixed=fixed, node_components=node_components,
+         edge_components=edge_components, connected_components=connected_components, kwargs...)
 
     # fix parallel branch coordinates
-    offset_parallel_edges!(data,
-        plot_attributes[:parallel_edge_offset],
-        edge_types=intersect(components, supported_edge_types)
-    )
+    offset_parallel_edges!(data, plot_attributes[:parallel_edge_offset], edge_types=edge_components)
 
-    remove_information!(data, invalid_keys)
+    # remove_information!(data, invalid_keys)
     PMD = PowerModelsDataFrame(data)
 
     # make the plots
     p = plot_base(data, plot_attributes)
-    if !(isempty(PMD.branch))
-        _validate_data_type(plot_attributes, :branch_data_type)
-        _validate_data(PMD.branch, plot_attributes[:branch_data], "branch")
-        p = p+plot_branch(PMD, plot_attributes)
-    end
-    if !(isempty(PMD.dcline))
-        _validate_data_type(plot_attributes, :dcline_data_type)
-        _validate_data(PMD.dcline, plot_attributes[:dcline_data], "DC line")
-        p = p+plot_dcline(PMD, plot_attributes)
-    end
-    if !(isempty(PMD.switch))
-        p = p+plot_switch(PMD, plot_attributes)
-        _validate_data_type(plot_attributes, :switch_data_type)
-        _validate_data(PMD.switch, plot_attributes[:switch_data], "switch")
-    end
-    if !(isempty(PMD.transformer))
-        p = p+plot_transformer(PMD, plot_attributes)
-        _validate_data_type(plot_attributes, :transformer_data_type)
-        _validate_data(PMD.transformer, plot_attributes[:transformer_data], "transformer")
-    end
-    if !(isempty(PMD.connector))
-        p = p+plot_connector(PMD, plot_attributes)
-    end
-    if !(isempty(PMD.bus))
-        p = p+plot_bus(PMD, plot_attributes)
-        _validate_data_type(plot_attributes, :bus_data_type)
-        _validate_data(PMD.bus, plot_attributes[:bus_data], "bus")
+    for comp_type in edge_components
+        if !(isempty(PMD.components[comp_type]))
+            _validate_data_type(plot_attributes[comp_type], :data_type)
+            _validate_data(PMD.components[comp_type], plot_attributes[comp_type][:data], comp_type)
+            p = p + plot_edge(PMD.components[comp_type], comp_type, plot_attributes[comp_type])
+        end
     end
-    if !(isempty(PMD.gen))
-        _validate_data_type(plot_attributes, :gen_data_type)
-        _validate_data(PMD.gen, plot_attributes[:gen_data], "gen")
-        p = p+plot_gen(PMD, plot_attributes)
+    for comp_type in [:connector]
+        if !(isempty(PMD.components[comp_type]))
+            _validate_data_type(plot_attributes[comp_type], :data_type)
+            _validate_data(PMD.components[comp_type], plot_attributes[comp_type][:data], comp_type)
+            p = p + plot_connector(PMD.components[comp_type], plot_attributes[comp_type])
+        end
     end
-    if !(isempty(PMD.load))
-        _validate_data_type(plot_attributes, :load_data_type)
-        _validate_data(PMD.load, plot_attributes[:load_data], "load")
-        p = p+plot_load(PMD, plot_attributes)
+    for comp_type in [node_components..., connected_components...]
+        if !(isempty(PMD.components[comp_type]))
+            plot_attributes[comp_type]
+            _validate_data_type(plot_attributes[comp_type], :data_type)
+            _validate_data(PMD.components[comp_type], plot_attributes[comp_type][:data], comp_type)
+            p = p + plot_node(PMD.components[comp_type], comp_type, plot_attributes[comp_type])
+        end
     end
     return p
 end
@@ -108,7 +84,9 @@ used to plot geographic map data underneath a power grid.
 function powerplot!(plt_layer::VegaLite.VLSpec, case::Dict{String,<:Any};
     layout_algorithm=kamada_kawai,
     fixed=false,
-    components=supported_component_types,
+    node_components=[:bus],
+    edge_components=[:branch],
+    connected_components=[:gen,:load],
     invalid_keys = Dict("branch"  => ["mu_angmin", "mu_angmax", "mu_sf", "shift", "rate_b", "rate_c", "g_to", "g_fr", "mu_st", "source_id", "f_bus", "t_bus",  "qf", "angmin", "angmax", "qt", "tap"],#["b_fr","b_to", "xcoord_1", "xcoord_2", "ycoord_1", "ycoord_2", "pf", "src","dst","rate_a","br_r","br_x","index","br_status"],
     "bus"     => ["mu_vmax", "lam_q", "mu_vmin", "source_id","lam_p"],#["xcoord_1", "ycoord_1", "bus_type", "name", "vmax",  "vmin", "index", "va", "vm", "base_kv"],
     "gen"     => ["vg","gen_bus","cost","ncost", "qc1max","qc2max", "ramp_agc", "qc1min", "qc2min", "pc1", "ramp_q", "mu_qmax", "ramp_30", "mu_qmin", "shutdown", "startup","ramp_10","source_id", "mu_pmax", "pc2", "mu_pmin","apf",]),#["xcoord_1", "ycoord_1",  "pg", "qg",  "pmax",   "mbase", "index", "cost", "qmax",  "qmin", "pmin", "gen_status"]),
@@ -118,7 +96,7 @@ function powerplot!(plt_layer::VegaLite.VLSpec, case::Dict{String,<:Any};
         return _powerplot_mn!(plt_layer, case; layout_algorithm=layout_algorithm, fixed=fixed, invalid_keys=invalid_keys, kwargs...)
     end
 
-    @prepare_plot_attributes(kwargs) # creates the plot_attributes dictionary
+    # @prepare_plot_attributes(kwargs) # creates the plot_attributes dictionary
     _validate_plot_attributes!(plot_attributes) # check the attributes for valid input types
 
     data = layout_network(case; layout_algorithm=layout_algorithm, fixed=fixed, kwargs...)
@@ -190,7 +168,7 @@ function _powerplot_mn(case::Dict{String,<:Any};
 
     data = deepcopy(case)
 
-    @prepare_plot_attributes(kwargs) # creates the plot_attributes dictionary
+    # @prepare_plot_attributes(kwargs) # creates the plot_attributes dictionary
     _validate_plot_attributes!(plot_attributes) # check the attributes for valid input types
 
     for (nwid,net) in data["nw"]
@@ -267,7 +245,7 @@ function _powerplot_mn!(plt_layer::VegaLite.VLSpec, case::Dict{String,<:Any};
     "gen"     => ["vg","gen_bus","cost","ncost", "qc1max","qc2max", "ramp_agc", "qc1min", "qc2min", "pc1", "ramp_q", "mu_qmax", "ramp_30", "mu_qmin", "shutdown", "startup","ramp_10","source_id", "mu_pmax", "pc2", "mu_pmin","apf",]),#["xcoord_1", "ycoord_1",  "pg", "qg",  "pmax",   "mbase", "index", "cost", "qmax",  "qmin", "pmin", "gen_status"]),
     kwargs... )
 
-    @prepare_plot_attributes(kwargs) # creates the plot_attributes dictionary
+    # @prepare_plot_attributes(kwargs) # creates the plot_attributes dictionary
     _validate_plot_attributes!(plot_attributes) # check the attributes for valid input types
 
     data = deepcopy(case)
@@ -347,17 +325,21 @@ end
 
 
 function plot_base(data::Dict{String, <:Any}, plot_attributes::Dict{Symbol,Any})
-    min_x = data["layout_extent"]["min_x"]
-    max_x = data["layout_extent"]["max_x"]
-    min_y = data["layout_extent"]["min_y"]
-    max_y = data["layout_extent"]["max_y"]
+    # min_x = data["layout_min_x"]
+    # max_x = data["layout_max_x"]
+    # min_y = data["layout_min_y"]
+    # max_y = data["layout_max_y"]
 
     return p = VegaLite.@vlplot(
         width=plot_attributes[:width],
         height=plot_attributes[:height],
         config={view={stroke=nothing}},
-        x={axis=nothing,scale={domain=[min_x,max_x]}},
-        y={axis=nothing,scale={domain=[min_y,max_y]}},
+        x={axis=nothing,
+            # scale={domain=[min_x,max_x]}
+        },
+        y={axis=nothing,
+            # scale={domain=[min_y,max_y]}
+        },
         resolve={
             scale={
                 color=:independent
@@ -367,7 +349,7 @@ function plot_base(data::Dict{String, <:Any}, plot_attributes::Dict{Symbol,Any})
 end
 
 
-function plot_base_mn(case::Dict{String,Any},plot_attributes::Dict{Symbol,Any})
+function plot_base_mn(case::Dict{String,Any}, plot_attributes::Dict{Symbol,Any})
     return p = VegaLite.@vlplot(
     width=plot_attributes[:width],
     height=plot_attributes[:height],
@@ -391,8 +373,7 @@ function plot_base_mn(case::Dict{String,Any},plot_attributes::Dict{Symbol,Any})
     )
 end
 
-
-function plot_branch(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+function plot_edge(edge_data::DataFrames.DataFrame, comp_type::Symbol, plot_attributes::Dict{Symbol,Any})
     flow_legend = true
     if plot_attributes[:show_flow_legend] in [nothing, false, :false, "false", :no, "no"]
         flow_legend = nothing
@@ -403,7 +384,7 @@ function plot_branch(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any
     end
 
     return VegaLite.@vlplot(
-        data=PMD.branch,
+        data=edge_data,
         layer=[
             {
                 mark ={
@@ -415,13 +396,13 @@ function plot_branch(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any
                 x2={:xcoord_2,type="quantitative"},
                 y={:ycoord_1,type="quantitative"},
                 y2={:ycoord_2,type="quantitative"},
-                size={value=plot_attributes[:branch_size]},
+                size={value=plot_attributes[:size]},
                 color={
-                    field=plot_attributes[:branch_data],
-                    type=plot_attributes[:branch_data_type],
-                    title="Branch",
+                    field=plot_attributes[:data],
+                    type=plot_attributes[:data_type],
+                    title=comp_type,
                     scale={
-                        range=plot_attributes[:branch_color]
+                        range=plot_attributes[:color]
                     },
                     # legend={orient="bottom-right"}
                 },
@@ -465,286 +446,408 @@ function plot_branch(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any
     )
 end
 
-
-function plot_switch(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
-    flow_legend = true
-    if plot_attributes[:show_flow_legend] in [nothing, false, :false, "false", :no, "no"]
-        flow_legend = nothing
-    end
-    flow_opacity = 1.0
-    if plot_attributes[:show_flow] in [nothing, false, :false, "false", :no, "no"]
-        flow_opacity = 0.0
-    end
-
-    return VegaLite.@vlplot(
-        data=PMD.switch,
-        layer=[
-            {
-                mark ={
-                    :rule,
-                    tooltip=("content" => "data"),
-                    opacity =  1.0,
-                },
-                x={:xcoord_1,type="quantitative"},
-                x2={:xcoord_2,type="quantitative"},
-                y={:ycoord_1,type="quantitative"},
-                y2={:ycoord_2,type="quantitative"},
-                size={value=plot_attributes[:switch_size]},
-                color={
-                    field=plot_attributes[:switch_data],
-                    type=plot_attributes[:switch_data_type],
-                    title="Switch",
-                    scale={
-                        range=plot_attributes[:switch_color]
-                    },
-                    # legend={orient="bottom-right"}
-                },
-            },
-            {
-                transform=[
-                    {
-                        calculate="(datum.xcoord_1 + datum.xcoord_2)/2",
-                        as="mid_x"
-                    },
-                    {
-                        calculate="(datum.ycoord_1 + datum.ycoord_2)/2",
-                        as="mid_y"
-                    },
-                    {
-                        calculate="180*(if(datum.pf >= 0,
-                            atan2(datum.xcoord_2 - datum.xcoord_1, datum.ycoord_2 - datum.ycoord_1),
-                            atan2(datum.xcoord_1 - datum.xcoord_2, datum.ycoord_1 - datum.ycoord_2)
-                        ))/PI",
-                        as="angle"
-                    },
-                    {
-                        calculate="abs(datum.pt)",
-                        as="power"
-                    }
-                ],
-                mark={
-                    :point,
-                    shape=:wedge,
-                    filled=true,
-                    opacity=flow_opacity,
-                    color=plot_attributes[:flow_color],
-                },
-                x={:mid_x,type="quantitative"},
-                y={:mid_y,type="quantitative"},
-                size={:power, scale={range=plot_attributes[:flow_arrow_size_range]}, type="quantitative", legend=flow_legend},
-                angle={:angle, scale={domain=[0,360], range=[0,360]}, type="quantitative"}
-            }
-        ]
-    )
-end
-
-
-
-function plot_transformer(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
-    flow_legend = true
-    if plot_attributes[:show_flow_legend] in [nothing, false, :false, "false", :no, "no"]
-        flow_legend = nothing
-    end
-    flow_opacity = 1.0
-    if plot_attributes[:show_flow] in [nothing, false, :false, "false", :no, "no"]
-        flow_opacity = 0.0
-    end
-
-    return VegaLite.@vlplot(
-        data=PMD.transformer,
-        layer=[
-            {
-                mark ={
-                    :rule,
-                    tooltip=("content" => "data"),
-                    opacity =  1.0,
-                },
-                x={:xcoord_1,type="quantitative"},
-                x2={:xcoord_2,type="quantitative"},
-                y={:ycoord_1,type="quantitative"},
-                y2={:ycoord_2,type="quantitative"},
-                size={value=plot_attributes[:transformer_size]},
-                color={
-                    field=plot_attributes[:transformer_data],
-                    type=plot_attributes[:transformer_data_type],
-                    title="Transformer",
-                    scale={
-                        range=plot_attributes[:transformer_color]
-                    },
-                    # legend={orient="bottom-right"}
-                },
-            },
-            {
-                transform=[
-                    {
-                        calculate="(datum.xcoord_1 + datum.xcoord_2)/2",
-                        as="mid_x"
-                    },
-                    {
-                        calculate="(datum.ycoord_1 + datum.ycoord_2)/2",
-                        as="mid_y"
-                    },
-                    {
-                        calculate="180*(if(datum.pf >= 0,
-                            atan2(datum.xcoord_2 - datum.xcoord_1, datum.ycoord_2 - datum.ycoord_1),
-                            atan2(datum.xcoord_1 - datum.xcoord_2, datum.ycoord_1 - datum.ycoord_2)
-                        ))/PI",
-                        as="angle"
-                    },
-                    {
-                        calculate="abs(datum.pt)",
-                        as="power"
-                    }
-                ],
-                mark={
-                    :point,
-                    shape=:wedge,
-                    filled=true,
-                    opacity=flow_opacity,
-                    color=plot_attributes[:flow_color],
-                },
-                x={:mid_x,type="quantitative"},
-                y={:mid_y,type="quantitative"},
-                size={:power, scale={range=plot_attributes[:flow_arrow_size_range]}, type="quantitative", legend=flow_legend},
-                angle={:angle, scale={domain=[0,360], range=[0,360]}, type="quantitative"}
-            }
-        ]
-    )
-end
-
-
-function plot_dcline(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+function plot_node(node_data::DataFrames.DataFrame, comp_type::Symbol, plot_attributes::Dict{Symbol,Any})
     return VegaLite.@vlplot(
+        data = node_data,
         mark ={
-            :rule,
-            tooltip=("content" => "data"),
+            :circle,
+            "tooltip" =("content" => "data"),
             opacity =  1.0,
         },
-        data=PMD.dcline,
         x={:xcoord_1,type="quantitative"},
-        x2={:xcoord_2,type="quantitative"},
         y={:ycoord_1,type="quantitative"},
-        y2={:ycoord_2,type="quantitative"},
-        size={value=plot_attributes[:dcline_size]},
+        size={value=plot_attributes[:size]},
         color={
-            field=plot_attributes[:dcline_data],
-            type=plot_attributes[:dcline_data_type],
-            title="DCLine",
+            field=plot_attributes[:data],
+            type=plot_attributes[:data_type],
+            title=ucfirst(string(comp_type)),
             scale={
-                range=plot_attributes[:dcline_color]
+                range=plot_attributes[:color]
             },
             # legend={orient="bottom-right"}
         },
     )
 end
 
-function plot_connector(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+function plot_connector(connector_data::DataFrames.DataFrame, plot_attributes::Dict{Symbol,Any})
     return VegaLite.@vlplot(
         mark ={
             :rule,
             "tooltip" =("content" => "data"),
             opacity =  1.0,
         },
-        data=PMD.connector,
+        data=connector_data,
         x={:xcoord_1,type="quantitative"},
         x2={:xcoord_2,type="quantitative"},
         y={:ycoord_1,type="quantitative"},
         y2={:ycoord_2,type="quantitative"},
-        size={value=plot_attributes[:connector_size]},
-        strokeDash={value=plot_attributes[:connector_dash]},
+        size={value=plot_attributes[:size]},
+        strokeDash={value=plot_attributes[:dash]},
         color={
             field="ComponentType",
             type="nominal",
             title="Connector",
             scale={
-                range=plot_attributes[:connector_color]
-            },
-            # legend={orient="bottom-right"}
-        },
-    )
-end
-
-function plot_bus(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
-    return VegaLite.@vlplot(
-        data = PMD.bus,
-        mark ={
-            :circle,
-            "tooltip" =("content" => "data"),
-            opacity =  1.0,
-        },
-        x={:xcoord_1,type="quantitative"},
-        y={:ycoord_1,type="quantitative"},
-        size={value=plot_attributes[:bus_size]},
-        color={
-            field=plot_attributes[:bus_data],
-            type=plot_attributes[:bus_data_type],
-            title="Bus",
-            scale={
-                range=plot_attributes[:bus_color]
+                range=plot_attributes[:color]
             },
             # legend={orient="bottom-right"}
         },
     )
 end
 
-function plot_gen(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
-    return VegaLite.@vlplot(
-        data = PMD.gen,
-        mark ={
-            :circle,
-            "tooltip" =("content" => "data"),
-            opacity =  1.0,
-        },
-        x={:xcoord_1,type="quantitative"},
-        y={:ycoord_1,type="quantitative"},
-        size={value=plot_attributes[:gen_size]},
-        color={
-            field=plot_attributes[:gen_data],
-            type=plot_attributes[:gen_data_type],
-            title="Gen",
-            scale={
-                range=plot_attributes[:gen_color]
-            }
-            # legend={orient="bottom-right"}
-        },
-    )
-end
-
-
-function plot_load(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
-    return VegaLite.@vlplot(
-        data = PMD.load,
-        mark ={
-            :circle,
-            "tooltip" =("content" => "data"),
-            opacity =  1.0,
-        },
-        x={:xcoord_1,type="quantitative"},
-        y={:ycoord_1,type="quantitative"},
-        size={value=plot_attributes[:load_size]},
-        color={
-            field=plot_attributes[:load_data],
-            type=plot_attributes[:load_data_type],
-            title="Load",
-            scale={
-                range=plot_attributes[:load_color]
-            }
-            # legend={orient="bottom-right"}
-        },
-    )
-end
-
-"Remove keys from componet dictionaries based on input invalid keys"
-function remove_information!(data::Dict{String,<:Any}, invalid_keys::Dict{String,<:Any})
-    for comp_type in ["bus","branch","gen"]
-        if haskey(data, comp_type)
-            for (id, comp) in data[comp_type]
-                for key in keys(comp)
-                    if (key in invalid_keys[comp_type])
-                        delete!(comp,key)
-                    end
-                end
-            end
-        end
-    end
-end
\ No newline at end of file
+# function plot_branch(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     flow_legend = true
+#     if plot_attributes[:show_flow_legend] in [nothing, false, :false, "false", :no, "no"]
+#         flow_legend = nothing
+#     end
+#     flow_opacity = 1.0
+#     if plot_attributes[:show_flow] in [nothing, false, :false, "false", :no, "no"]
+#         flow_opacity = 0.0
+#     end
+
+#     return VegaLite.@vlplot(
+#         data=PMD.branch,
+#         layer=[
+#             {
+#                 mark ={
+#                     :rule,
+#                     tooltip=("content" => "data"),
+#                     opacity =  1.0,
+#                 },
+#                 x={:xcoord_1,type="quantitative"},
+#                 x2={:xcoord_2,type="quantitative"},
+#                 y={:ycoord_1,type="quantitative"},
+#                 y2={:ycoord_2,type="quantitative"},
+#                 size={value=plot_attributes[:branch_size]},
+#                 color={
+#                     field=plot_attributes[:branch_data],
+#                     type=plot_attributes[:branch_data_type],
+#                     title="Branch",
+#                     scale={
+#                         range=plot_attributes[:branch_color]
+#                     },
+#                     # legend={orient="bottom-right"}
+#                 },
+#             },
+#             {
+#                 transform=[
+#                     {
+#                         calculate="(datum.xcoord_1 + datum.xcoord_2)/2",
+#                         as="mid_x"
+#                     },
+#                     {
+#                         calculate="(datum.ycoord_1 + datum.ycoord_2)/2",
+#                         as="mid_y"
+#                     },
+#                     {
+#                         calculate="180*(if(datum.pf >= 0,
+#                             atan2(datum.xcoord_2 - datum.xcoord_1, datum.ycoord_2 - datum.ycoord_1),
+#                             atan2(datum.xcoord_1 - datum.xcoord_2, datum.ycoord_1 - datum.ycoord_2)
+#                         ))/PI",
+#                         as="angle"
+#                     },
+#                     {
+#                         calculate="if(isValid(datum.pt), abs(datum.pt), 0.0)",
+#                         as="power"
+#                     }
+#                 ],
+#                 mark={
+#                     :point,
+#                     shape=:wedge,
+#                     filled=true,
+#                     tooltip=("content" => "data"),
+#                     opacity=flow_opacity,
+#                     color=plot_attributes[:flow_color],
+#                 },
+#                 x={:mid_x,type="quantitative"},
+#                 y={:mid_y,type="quantitative"},
+#                 size={:power, scale={range=plot_attributes[:flow_arrow_size_range]}, type="quantitative", legend=flow_legend},
+#                 angle={:angle, scale={domain=[0,360], range=[0,360]}, type="quantitative"}
+#             }
+#         ]
+#     )
+# end
+
+
+# function plot_switch(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     flow_legend = true
+#     if plot_attributes[:show_flow_legend] in [nothing, false, :false, "false", :no, "no"]
+#         flow_legend = nothing
+#     end
+#     flow_opacity = 1.0
+#     if plot_attributes[:show_flow] in [nothing, false, :false, "false", :no, "no"]
+#         flow_opacity = 0.0
+#     end
+
+#     return VegaLite.@vlplot(
+#         data=PMD.switch,
+#         layer=[
+#             {
+#                 mark ={
+#                     :rule,
+#                     tooltip=("content" => "data"),
+#                     opacity =  1.0,
+#                 },
+#                 x={:xcoord_1,type="quantitative"},
+#                 x2={:xcoord_2,type="quantitative"},
+#                 y={:ycoord_1,type="quantitative"},
+#                 y2={:ycoord_2,type="quantitative"},
+#                 size={value=plot_attributes[:switch_size]},
+#                 color={
+#                     field=plot_attributes[:switch_data],
+#                     type=plot_attributes[:switch_data_type],
+#                     title="Switch",
+#                     scale={
+#                         range=plot_attributes[:switch_color]
+#                     },
+#                     # legend={orient="bottom-right"}
+#                 },
+#             },
+#             {
+#                 transform=[
+#                     {
+#                         calculate="(datum.xcoord_1 + datum.xcoord_2)/2",
+#                         as="mid_x"
+#                     },
+#                     {
+#                         calculate="(datum.ycoord_1 + datum.ycoord_2)/2",
+#                         as="mid_y"
+#                     },
+#                     {
+#                         calculate="180*(if(datum.pf >= 0,
+#                             atan2(datum.xcoord_2 - datum.xcoord_1, datum.ycoord_2 - datum.ycoord_1),
+#                             atan2(datum.xcoord_1 - datum.xcoord_2, datum.ycoord_1 - datum.ycoord_2)
+#                         ))/PI",
+#                         as="angle"
+#                     },
+#                     {
+#                         calculate="abs(datum.pt)",
+#                         as="power"
+#                     }
+#                 ],
+#                 mark={
+#                     :point,
+#                     shape=:wedge,
+#                     filled=true,
+#                     opacity=flow_opacity,
+#                     color=plot_attributes[:flow_color],
+#                 },
+#                 x={:mid_x,type="quantitative"},
+#                 y={:mid_y,type="quantitative"},
+#                 size={:power, scale={range=plot_attributes[:flow_arrow_size_range]}, type="quantitative", legend=flow_legend},
+#                 angle={:angle, scale={domain=[0,360], range=[0,360]}, type="quantitative"}
+#             }
+#         ]
+#     )
+# end
+
+
+
+# function plot_transformer(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     flow_legend = true
+#     if plot_attributes[:show_flow_legend] in [nothing, false, :false, "false", :no, "no"]
+#         flow_legend = nothing
+#     end
+#     flow_opacity = 1.0
+#     if plot_attributes[:show_flow] in [nothing, false, :false, "false", :no, "no"]
+#         flow_opacity = 0.0
+#     end
+
+#     return VegaLite.@vlplot(
+#         data=PMD.transformer,
+#         layer=[
+#             {
+#                 mark ={
+#                     :rule,
+#                     tooltip=("content" => "data"),
+#                     opacity =  1.0,
+#                 },
+#                 x={:xcoord_1,type="quantitative"},
+#                 x2={:xcoord_2,type="quantitative"},
+#                 y={:ycoord_1,type="quantitative"},
+#                 y2={:ycoord_2,type="quantitative"},
+#                 size={value=plot_attributes[:transformer_size]},
+#                 color={
+#                     field=plot_attributes[:transformer_data],
+#                     type=plot_attributes[:transformer_data_type],
+#                     title="Transformer",
+#                     scale={
+#                         range=plot_attributes[:transformer_color]
+#                     },
+#                     # legend={orient="bottom-right"}
+#                 },
+#             },
+#             {
+#                 transform=[
+#                     {
+#                         calculate="(datum.xcoord_1 + datum.xcoord_2)/2",
+#                         as="mid_x"
+#                     },
+#                     {
+#                         calculate="(datum.ycoord_1 + datum.ycoord_2)/2",
+#                         as="mid_y"
+#                     },
+#                     {
+#                         calculate="180*(if(datum.pf >= 0,
+#                             atan2(datum.xcoord_2 - datum.xcoord_1, datum.ycoord_2 - datum.ycoord_1),
+#                             atan2(datum.xcoord_1 - datum.xcoord_2, datum.ycoord_1 - datum.ycoord_2)
+#                         ))/PI",
+#                         as="angle"
+#                     },
+#                     {
+#                         calculate="abs(datum.pt)",
+#                         as="power"
+#                     }
+#                 ],
+#                 mark={
+#                     :point,
+#                     shape=:wedge,
+#                     filled=true,
+#                     opacity=flow_opacity,
+#                     color=plot_attributes[:flow_color],
+#                 },
+#                 x={:mid_x,type="quantitative"},
+#                 y={:mid_y,type="quantitative"},
+#                 size={:power, scale={range=plot_attributes[:flow_arrow_size_range]}, type="quantitative", legend=flow_legend},
+#                 angle={:angle, scale={domain=[0,360], range=[0,360]}, type="quantitative"}
+#             }
+#         ]
+#     )
+# end
+
+
+# function plot_dcline(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     return VegaLite.@vlplot(
+#         mark ={
+#             :rule,
+#             tooltip=("content" => "data"),
+#             opacity =  1.0,
+#         },
+#         data=PMD.dcline,
+#         x={:xcoord_1,type="quantitative"},
+#         x2={:xcoord_2,type="quantitative"},
+#         y={:ycoord_1,type="quantitative"},
+#         y2={:ycoord_2,type="quantitative"},
+#         size={value=plot_attributes[:dcline_size]},
+#         color={
+#             field=plot_attributes[:dcline_data],
+#             type=plot_attributes[:dcline_data_type],
+#             title="DCLine",
+#             scale={
+#                 range=plot_attributes[:dcline_color]
+#             },
+#             # legend={orient="bottom-right"}
+#         },
+#     )
+# end
+
+# function plot_connector(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     return VegaLite.@vlplot(
+#         mark ={
+#             :rule,
+#             "tooltip" =("content" => "data"),
+#             opacity =  1.0,
+#         },
+#         data=PMD.connector,
+#         x={:xcoord_1,type="quantitative"},
+#         x2={:xcoord_2,type="quantitative"},
+#         y={:ycoord_1,type="quantitative"},
+#         y2={:ycoord_2,type="quantitative"},
+#         size={value=plot_attributes[:size]},
+#         strokeDash={value=plot_attributes[:dash]},
+#         color={
+#             field="ComponentType",
+#             type="nominal",
+#             title="Connector",
+#             scale={
+#                 range=plot_attributes[:color]
+#             },
+#             # legend={orient="bottom-right"}
+#         },
+#     )
+# end
+
+# function plot_bus(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     return VegaLite.@vlplot(
+#         data = PMD.bus,
+#         mark ={
+#             :circle,
+#             "tooltip" =("content" => "data"),
+#             opacity =  1.0,
+#         },
+#         x={:xcoord_1,type="quantitative"},
+#         y={:ycoord_1,type="quantitative"},
+#         size={value=plot_attributes[:bus_size]},
+#         color={
+#             field=plot_attributes[:bus_data],
+#             type=plot_attributes[:bus_data_type],
+#             title="Bus",
+#             scale={
+#                 range=plot_attributes[:bus_color]
+#             },
+#             # legend={orient="bottom-right"}
+#         },
+#     )
+# end
+
+# function plot_gen(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     return VegaLite.@vlplot(
+#         data = PMD.gen,
+#         mark ={
+#             :circle,
+#             "tooltip" =("content" => "data"),
+#             opacity =  1.0,
+#         },
+#         x={:xcoord_1,type="quantitative"},
+#         y={:ycoord_1,type="quantitative"},
+#         size={value=plot_attributes[:gen_size]},
+#         color={
+#             field=plot_attributes[:gen_data],
+#             type=plot_attributes[:gen_data_type],
+#             title="Gen",
+#             scale={
+#                 range=plot_attributes[:gen_color]
+#             }
+#             # legend={orient="bottom-right"}
+#         },
+#     )
+# end
+
+
+# function plot_load(PMD::PowerModelsDataFrame, plot_attributes::Dict{Symbol,Any})
+#     return VegaLite.@vlplot(
+#         data = PMD.load,
+#         mark ={
+#             :circle,
+#             "tooltip" =("content" => "data"),
+#             opacity =  1.0,
+#         },
+#         x={:xcoord_1,type="quantitative"},
+#         y={:ycoord_1,type="quantitative"},
+#         size={value=plot_attributes[:load_size]},
+#         color={
+#             field=plot_attributes[:load_data],
+#             type=plot_attributes[:load_data_type],
+#             title="Load",
+#             scale={
+#                 range=plot_attributes[:load_color]
+#             }
+#             # legend={orient="bottom-right"}
+#         },
+#     )
+# end
+
+# "Remove keys from componet dictionaries based on input invalid keys"
+# function remove_information!(data::Dict{String,<:Any}, invalid_keys::Dict{String,<:Any})
+#     for comp_type in ["bus","branch","gen"]
+#         if haskey(data, comp_type)
+#             for (id, comp) in data[comp_type]
+#                 for key in keys(comp)
+#                     if (key in invalid_keys[comp_type])
+#                         delete!(comp,key)
+#                     end
+#                 end
+#             end
+#         end
+#     end
+# end
\ No newline at end of file
diff --git a/test/runtests.jl b/test/runtests.jl
index 1eeefd2..2bbf1f7 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -85,12 +85,12 @@ data = PowerModels.parse_file("$(joinpath(dirname(pathof(PowerModels)), ".."))/t
         case = PowerModels.parse_file("$(joinpath(dirname(pathof(PowerModels)), ".."))/test/data/matpower/case5.m")
         df = PowerModelsDataFrame(data)
         @test typeof(df) <:PowerModelsDataFrame
-        @test size(df.branch) == (7,20)
+        @test size(df.components[:branch]) == (7,20)
 
         data_mn = PowerModels.replicate(data,2)
         df_mn = PowerModelsDataFrame(data_mn)
         @test typeof(df_mn) <:PowerModelsDataFrame # these functions didn't error
-        @test size(df_mn.branch) == (14,21)
+        @test size(df_mn.components[:branch]) == (14,21)
 
         comp_df = comp_dict_to_dataframe(data["branch"])
         @test size(comp_df) == (7,19)
diff --git a/test/scratchspace.jl b/test/scratchspace.jl
index 5099661..cd3798d 100644
--- a/test/scratchspace.jl
+++ b/test/scratchspace.jl
@@ -1,18 +1,51 @@
 
 # Scratch space for testing development features
+using TestEnv; TestEnv.activate()
 
 using PowerPlots
 using PowerModels
 using PowerPlots, PowerModels
 data = parse_file("$(joinpath(dirname(pathof(PowerModels)), ".."))/test/data/matpower/case5.m")
+data = parse_file("$(joinpath(dirname(pathof(PowerModels)), ".."))/test/data/matpower/case5_strg.m")
 
 ################################################
 ## No code should be commited in this section ##
 ################################################
 
 
+pmg = PowerModelsGraph(data,[:bus],[:branch],[:gen,:load])
 
+data = layout_network(data; node_components=[:bus], edge_components=[:branch], connected_components=[:gen, :load])
 
+pmd= PowerModelsDataFrame(data)
 
+powerplot(data, connected_components=[:gen,:load,:storage])
+
+p = powerplot(data,
+bus_data=:index, bus_data_type=:quantitative,
+branch_data=:index, branch_data_type=:quantitative,
+gen_data=:index, gen_data_type=:quantitative,
+height=250, width=250, bus_size=100, gen_size=50, load_size=50,
+)
+
+
+powerplot(data; bus=(:color=>"orange"),
+                gen=(:color=>:purple),
+                branch=(:color=>"#AFAFAF"),
+                load=(:color=>:black),
+                width=500, height=300)
+
+
+p = powerplot(data,
+    # gen=[:data=>"pmax", :size=>200, :data_type=>"quantitative", :color=>["#232323","#AAFAFA"]],
+    # load=[:data=>"pd", :size=>500, :data_type=>"quantitative", :color=>["red","orange"]],
+    branch=[:show_flow=>true, :show_flow_legend=>true, :data=>"rate_a", :size=>3, :data_type=>"quantitative", :color=>["black","blue"]],
+    # bus=[:data=>"vmax", :size=>1000, :data_type=>"quantitative", :color=>["yellow","green"]],
+    width=300, height=300, parallel_edge_offset=0.05
+)
+
+
+
+typeof([:a=>1,:b=>2])::Type{<:Vector{T}} where {T<:Pair}
 
 ################################################
\ No newline at end of file