From ef3aa40faa465c2f52884d45e4a95be375bd28c7 Mon Sep 17 00:00:00 2001
From: Chris Bennett <chrisbennett@Chriss-MacBook-Air.local>
Date: Mon, 19 Aug 2024 21:37:05 -0600
Subject: [PATCH 01/10] Consolidated code for review

---
 src/graphviz_visualization.jl | 524 ++++++++++++++++++++++++++++++++++
 1 file changed, 524 insertions(+)
 create mode 100644 src/graphviz_visualization.jl

diff --git a/src/graphviz_visualization.jl b/src/graphviz_visualization.jl
new file mode 100644
index 0000000..61afbf1
--- /dev/null
+++ b/src/graphviz_visualization.jl
@@ -0,0 +1,524 @@
+
+"""
+These abstract types are used as arguments in the respective generate_dot methods
+and are used by Julia's multiple dispatch system to decide which method of generate_dot to call. 
+
+"""
+abstract type TraversalStrategy end
+struct SimpleIteration <: TraversalStrategy end
+struct BFSTraversal <: TraversalStrategy end
+
+"""
+    get_node_properties(model::GraphPPL.Model, vertex)
+
+Get the properties of a node in a GraphPPL model.
+
+# Arguments
+- `model::GraphPPL.Model`: The GraphPPL model.
+- `vertex`: The vertex representing the node.
+
+# Returns
+A dictionary containing the properties of the node, including the label and field names.
+
+"""
+function get_node_properties(model::GraphPPL.Model, vertex)
+    # Set up return value
+    namespace_variables = Dict{Symbol, Any}()
+
+    # Get the properties of the node   
+    label = MetaGraphsNext.label_for(model.graph, vertex)
+    properties = model[label].properties
+
+    # Add label to the dictionary
+    namespace_variables[:label] = label
+    
+    # Get field names
+    field_names = fieldnames(typeof(properties))
+
+    # Add field names and values to the dictionary
+    for field_name in field_names
+        namespace_variables[field_name] = getproperty(properties, field_name)
+    end
+
+    return namespace_variables
+end
+
+function get_node_properties(properties::GraphPPL.FactorNodeProperties)
+    # Set up return value
+    namespace_variables = Dict{Symbol, Any}()
+    
+    # Get field names
+    field_names = fieldnames(typeof(properties))
+
+    # Add field names and values to the dictionary
+    for field_name in field_names
+        namespace_variables[field_name] = getproperty(properties, field_name)
+    end
+
+    return namespace_variables
+end
+
+function get_node_properties(properties::GraphPPL.VariableNodeProperties)
+    # Set up return value
+    namespace_variables = Dict{Symbol, Any}()
+    
+    # Get field names
+    field_names = fieldnames(typeof(properties))
+
+    # Add field names and values to the dictionary
+    for field_name in field_names
+        namespace_variables[field_name] = getproperty(properties, field_name)
+    end
+
+    return namespace_variables
+end
+
+"""
+Returns a dict of dicts where each key is the unique 
+GraphPPL.NodeLabel.global_counter value for each node.
+Each value is a dictionary containing the namespace for 
+the node with ID == Key. 
+
+"""
+function get_namespace_variables_dict(model::GraphPPL.Model)
+    
+    node_properties_dict = Dict{Int64, Dict{Symbol, Any}}()
+    
+    for vertex in MetaGraphsNext.vertices(model.graph)
+        
+        node_properties = get_node_properties(model, vertex)
+        
+        global_counter_id = node_properties[:label].global_counter
+        
+        node_properties_dict[global_counter_id] = node_properties
+    end
+    
+    return node_properties_dict
+end
+
+"""
+Input: the namespace dictionary for a particular variable node. 
+
+Return value: a string containing the variable node name, variable node ID
+and variable node value. These three fields are to be the default variable node
+"""
+function get_sanitized_variable_node_name(var_namespace_dict)
+    
+    san_str_name_var = string(var_namespace_dict[:label]) # was :name
+    
+    if var_namespace_dict[:value] == nothing
+        str_val_var = "nothing"
+    else
+        str_val_var = string(var_namespace_dict[:value])
+    end
+    
+    final_str = string(san_str_name_var, ":", str_val_var)
+
+    return final_str
+end
+
+"""
+Input: the namespace dictionary for a particular factor node. 
+
+Return value: a string containing only the name for the input factor node 
+namespace dictionary. 
+"""
+function get_sanitized_factor_node_name(fac_namespace_dict)
+
+    san_str_name_fac = string(fac_namespace_dict[:label]) # was :fform
+    
+    return san_str_name_fac
+end
+
+"""
+Input: a namespace dictionary for an arbitrary node (variable node or factor node).
+
+Return value: a string cotaining either the return value of 
+get_sanitized_variable_node_name or get_sanitized_factor_node_name.
+"""
+function get_sanitized_node_name(single_node_namespace_dict)
+    if haskey(single_node_namespace_dict, :name)
+        san_node_name_str = get_sanitized_variable_node_name(single_node_namespace_dict)
+    elseif haskey(single_node_namespace_dict, :fform)
+        san_node_name_str = get_sanitized_factor_node_name(single_node_namespace_dict)
+    else
+        error("Input single-node namespace dictionary has neither :name nor :fform as a key.")
+    end
+    
+    return san_node_name_str
+end
+
+"""
+Input: a string containing the DOT code corresponding to a GraphPPL.Model
+
+Return value: returns the input string, stripped of the leading and 
+trailing non-DOT syntax.
+
+"""
+function strip_dot_wrappers(dot_string::String)
+    stripped_string = replace(dot_string, r"^dot\"\"\"\n" => "")
+    stripped_string = replace(stripped_string, r"\n\"\"\"$" => "")
+    
+    return stripped_string
+end
+
+"""
+Writes the given DOT string to a file specified by file_path.
+
+# Arguments:
+- dot_string: The DOT format string to write to the file.
+- file_path: The path of the file where the DOT string should be written.
+
+# Returns:
+- Bool: Returns true if the file was written successfully, otherwise false.
+
+# Throws:
+- SystemError: If there is an error in opening/writing to the file.
+
+"""
+function write_to_dot_file(dot_string::String, file_path::String) :: Bool
+    try
+        open(file_path, "w") do file
+            write(file, dot_string)
+        end
+        return true
+    catch e
+        @error "Failed to write to file $file_path" exception = (e, catch_backtrace())
+        return false
+    end
+end
+
+"""
+Generate a PDF file from a DOT file using Graphviz's dot command.
+
+# Arguments
+- src_dot_file_path: The path to the source DOT file.
+- dst_pdf_file_path_name: The desired path and name for the output PDF file.
+
+# Returns
+- Bool: true if the PDF generation is successful, false otherwise.
+
+"""
+function generate_pdf_from_dot(src_dot_file_path::String, dst_pdf_file_path_name::String) :: Bool
+    try
+        run(`dot -Tpdf $src_dot_file_path -o $dst_pdf_file_path_name`)
+        return true
+    catch
+        return false
+    end
+end
+
+"""
+Convert a DOT string to a PDF file.
+
+This function encapsulates the process of stripping unnecessary wrappers from the DOT string,
+writing it to a temporary DOT file, converting it to a PDF using Graphviz, and cleaning up the 
+temporary file.
+
+# Arguments:
+- dot_string: The DOT format string to be converted.
+- dst_pdf_file: The desired path and name for the output PDF file.
+
+# Returns:
+- Bool: true if the PDF generation is successful, false otherwise.
+
+"""
+function dot_string_to_pdf(dot_string::String, dst_pdf_file::String) :: Bool
+    tmp_dot_file = "tmp.dot"
+    try
+        pure_dot_string = strip_dot_wrappers(dot_string)
+        write_to_dot_file(pure_dot_string, tmp_dot_file)
+        success = generate_pdf_from_dot(tmp_dot_file, dst_pdf_file)
+        return success
+    catch
+        return false
+    finally
+        if isfile(tmp_dot_file)
+            rm(tmp_dot_file)
+        end
+    end
+end
+
+"""
+Responsible for contructing the portion of the final DOT string which
+specifies the nodes in the eventual GraphViz visualization. 
+
+This method of add_nodes! simply iterates over the set of verticies from the constituent 
+MetaGraphsNext.MetaGraph contained in model_graph. 
+
+Raises an error if the type of any vertex is not recognized. 
+
+# Arguments:
+- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
+- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
+- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
+  Otherwise known as the global namespace dictionary. 
+- ::SimpleIteration: identifies the desired iteration strategy as SimpleIteration. 
+
+"""
+function add_nodes!(
+        io_buffer::IOBuffer, 
+        model_graph::GraphPPL.Model, 
+        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
+        ::SimpleIteration
+    )
+    
+    for vertex in MetaGraphsNext.vertices(model_graph.graph)
+        
+        # index the label of model_namespace_variables with "vertex"
+        san_label = get_sanitized_node_name(global_namespace_dict[vertex])
+        
+        label = MetaGraphsNext.label_for(model_graph.graph, vertex)
+        
+        properties = model_graph[label].properties
+        
+        if isa(properties, GraphPPL.FactorNodeProperties)
+            write(io_buffer, "    \"$(san_label)\" [shape=square, style=filled, fillcolor=lightgray];\n")
+        elseif isa(properties, GraphPPL.VariableNodeProperties)
+            write(io_buffer, "    \"$(san_label)\" [shape=circle];\n")
+        else
+            error("Unknown node type for label $(san_label)")
+        end
+    end
+end
+
+"""
+Responsible for contructing the portion of the final DOT string which
+specifies the nodes in the eventual GraphViz visualization. 
+
+This method of add_nodes! conducts a Breadth First Search (BFS) from the initially-created 
+node of the model_graph. 
+
+Raises an error if the type of any vertex is not recognized. 
+
+# Arguments:
+- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
+- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
+- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
+  Otherwise known as the global namespace dictionary. 
+- ::BFSTraversal: identifies the desired iteration strategy as BFSTraversal. 
+
+"""
+function add_nodes!(
+        io_buffer::IOBuffer, 
+        model_graph::GraphPPL.Model, 
+        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}, 
+        ::BFSTraversal
+    )
+    
+    n = nv(model_graph) # number of nodes in the 
+    visited = falses(n) # array of visited nodes
+    cur_level = Vector{Int}() # current level of nodes processed in BFS/current layer of the BFS iteration
+    next_level = Vector{Int}() # next level of nodes for BFS iteration
+    
+    s = 1 # always start at the initially created node of model_graph
+    if !visited[s]
+        visited[s] = true
+        push!(cur_level, s)
+    end
+    
+    while !isempty(cur_level)
+        
+        for v in cur_level # iterate over the verticies in the current level
+            
+            # we use the sanitized vertex label in the visualization
+            san_label = get_sanitized_node_name(global_namespace_dict[v])
+            
+            label = MetaGraphsNext.label_for(model_graph.graph, v)
+            properties = model_graph[label].properties
+            
+            if isa(properties, GraphPPL.FactorNodeProperties)
+                write(io_buffer, "    \"$(san_label)\" [shape=square, style=filled, fillcolor=lightgray];\n")
+            elseif isa(properties, GraphPPL.VariableNodeProperties)
+                write(io_buffer, "    \"$(san_label)\" [shape=circle];\n")
+            else
+                error("Unknown node type for label $(san_label)")
+            end
+            
+            for v_neighb in MetaGraphsNext.neighbors(model_graph.graph, v)
+                if !visited[v_neighb]
+                    visited[v_neighb] = true
+                    push!(next_level, v_neighb)
+                end
+            end
+        end
+        empty!(cur_level)
+        cur_level, next_level = next_level, cur_level
+        sort!(cur_level)
+    end
+end
+
+"""
+Responsible for contructing the portion of the final DOT string which
+specifies the edges between the included nodes in the eventual GraphViz visualization. 
+
+This method of add_edges! simply iterates over the set of edges from the constituent 
+MetaGraphsNext.MetaGraph contained in model_graph.
+
+# Arguments:
+- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
+- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
+- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
+  Otherwise known as the global namespace dictionary. 
+- ::SimpleIteration: identifies the desired iteration strategy as SimpleIteration. 
+- edge_length: a floating point value to control the length of the edges. 
+
+
+"""
+function add_edges!(
+        io_buffer::IOBuffer, 
+        model_graph::GraphPPL.Model, 
+        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
+        ::SimpleIteration, 
+        edge_length::Float64
+    )
+    
+    for edge in MetaGraphsNext.edges(model_graph.graph)
+        
+        source_vertex = MetaGraphsNext.label_for(model_graph.graph, edge.src)
+        dest_vertex = MetaGraphsNext.label_for(model_graph.graph, edge.dst)
+        
+        # we use the sanitized names of the vertices in the final visualization
+        source_san_name = get_sanitized_node_name(global_namespace_dict[source_vertex.global_counter])
+        dest_san_name = get_sanitized_node_name(global_namespace_dict[dest_vertex.global_counter])
+        
+        write(io_buffer, "    \"$(source_san_name)\" -- \"$(dest_san_name)\" [len=$(edge_length)];\n")
+    end
+end
+
+"""
+Responsible for contructing the portion of the final DOT string which
+specifies the edges between the included nodes in the eventual GraphViz visualization. 
+
+This method of add_edges! conducts a Breadth First Search (BFS) from the initially-created 
+node of the model_graph. 
+
+# Arguments:
+- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
+- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
+- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
+  Otherwise known as the global namespace dictionary. 
+- ::BFSTraversal: identifies the desired iteration strategy as BFSTraversal. 
+- edge_length: a floating point value to control the length of the edges. 
+
+"""
+function add_edges!(
+        io_buffer::IOBuffer, 
+        model_graph::GraphPPL.Model, 
+        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
+        ::BFSTraversal, 
+        edge_length::Float64
+    )
+    
+    edge_set = Set{Tuple{Int, Int}}()
+    
+    n = nv(model_graph)
+    visited = falses(n)
+    cur_level = Vector{Int}()
+    next_level = Vector{Int}()
+    
+    s = 1
+    if !visited[s]
+        visited[s] = true
+        push!(cur_level, s)
+    end
+    
+    while !isempty(cur_level)
+        for v in cur_level
+            for v_neighb in MetaGraphsNext.neighbors(model_graph.graph, v)
+                edge = (min(v, v_neighb), max(v, v_neighb))
+                if !(edge in edge_set)
+                    source_vertex = MetaGraphsNext.label_for(model_graph.graph, v)
+                    dest_vertex = MetaGraphsNext.label_for(model_graph.graph, v_neighb)
+                    
+                    source_san_name = get_sanitized_node_name(
+                        global_namespace_dict[source_vertex.global_counter]
+                    )
+
+                    dest_san_name = get_sanitized_node_name(
+                        global_namespace_dict[dest_vertex.global_counter]
+                    )
+                    
+                    write(io_buffer, "    \"$(source_san_name)\" -- \"$(dest_san_name)\" [len=$(edge_length)];\n")
+                    push!(edge_set, edge)
+                end
+                
+                if !visited[v_neighb]
+                    visited[v_neighb] = true
+                    push!(next_level, v_neighb)
+                end
+            end
+        end
+        empty!(cur_level)
+        cur_level, next_level = next_level, cur_level
+        sort!(cur_level)
+    end
+end
+
+"""
+Constructs the DOT string from an input GraphPPL.Model.
+
+# Arguments:
+- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
+- strategy: the abstract type which specifies the particular traversal strategy. 
+Either SimpleIteration() or BFSTraversal().
+- font_size: the font size of the node fields. 
+- edge_length: a floating point value to control the length of the edges. 
+- layout: layout engine for the eventual display. Default is "neato".  
+- width: width of the display window.
+- height: height of the display window.
+
+# Returns:
+- String: a string containing the DOT code which can then be executed 
+to yield a GraphViz visualization. 
+
+"""
+function generate_dot(;
+        model_graph::GraphPPL.Model, 
+        strategy::TraversalStrategy,
+        font_size::Int, 
+        edge_length::Float64 = 1.0, 
+        layout::String = "neato", 
+        overlap::Bool,
+        width::Float64 = 10.0, 
+        height::Float64 = 10.0
+    )
+    
+    # get the entire namespace dict
+    global_namespace_dict = get_namespace_variables_dict(model_graph)
+    
+    # use Base.IOBuffer instead of string concatenation
+    io_buffer = IOBuffer()
+    
+    write(io_buffer, "dot\"\"\"\ngraph G {\n")
+    write(io_buffer, "    layout=$(layout);\n")
+    write(io_buffer, "    overlap =$(string(overlap));\n") # control if allowing node overlaps
+    write(io_buffer, "    size=\"$(width),$(height)!\";\n")
+    write(io_buffer, "    node [shape=circle, fontsize=$(font_size)];\n")
+    
+    # Nodes
+    add_nodes!(io_buffer, model_graph, global_namespace_dict, strategy)
+    
+    # Edges
+    add_edges!(io_buffer, model_graph, global_namespace_dict, strategy, edge_length)
+    
+    write(io_buffer, "}\n\"\"\"")
+    
+    final_dot = String(take!(io_buffer))
+    
+    return final_dot
+end
+
+"""
+Executes the DOT string returned by generate_dot.
+
+# Arguments:
+- dot_code_graph: the DOT string returned by generate_dot. 
+"""
+function show_gv(dot_code_graph::String)
+    try
+        eval(Meta.parse(dot_code_graph))
+    catch e
+        error("Could not evaluate the input DOT string: ", e)
+    end
+end
\ No newline at end of file

From e80f95980d2a7f49cb7e70f4729e63691bc6b9cb Mon Sep 17 00:00:00 2001
From: FraserP <fraserp@pop-os.localdomain>
Date: Mon, 26 Aug 2024 15:13:27 +0800
Subject: [PATCH 02/10] added proper docstrings to the core functions and
 encapsulated these in a module.

---
 src/graphviz_visualization.jl | 390 ++++++++++++++++++++++++----------
 src/tests.jl                  |  96 +++++++++
 2 files changed, 373 insertions(+), 113 deletions(-)
 create mode 100644 src/tests.jl

diff --git a/src/graphviz_visualization.jl b/src/graphviz_visualization.jl
index 61afbf1..4fa3716 100644
--- a/src/graphviz_visualization.jl
+++ b/src/graphviz_visualization.jl
@@ -1,27 +1,43 @@
+module GPPLGViz
+
+export generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
+
+using GraphPPL
+using MetaGraphsNext
+using GraphViz
+
 
 """
-These abstract types are used as arguments in the respective generate_dot methods
-and are used by Julia's multiple dispatch system to decide which method of generate_dot to call. 
+This abstract type represents a node traversal strategy for use with the `generate_dot` function.
+
+This abstract type is used to define various strategies for traversing nodes in the graph when generating a DOT representation. 
+Each concrete subtype specifies a different traversal approach, which is selected by Julia's multiple dispatch system 
+when calling `generate_dot`.
+
+Concrete subtypes:
+- `SimpleIteration`: Represents a simple iteration of the graph's vertex/node set.
+- `BFSTraversal`: Represents a breadth-first search traversal strategy, from the initially created node.
 
+These types afford a trade-off between a relatively fast and a relatively 'principled' iteration strategy (respectfully).
 """
 abstract type TraversalStrategy end
 struct SimpleIteration <: TraversalStrategy end
 struct BFSTraversal <: TraversalStrategy end
 
 """
-    get_node_properties(model::GraphPPL.Model, vertex)
+    get_node_properties(model::GraphPPL.Model, vertex::Int64)
 
-Get the properties of a node in a GraphPPL model.
+Extracts the properties of a specific node in a `GraphPPL.Model` and returns them as a dictionary.
 
 # Arguments
-- `model::GraphPPL.Model`: The GraphPPL model.
-- `vertex`: The vertex representing the node.
+- `model::GraphPPL.Model`: The model from which the node's properties will be retrieved.
+- `vertex::Int64`: The integer index representing the node in the model's graph.
 
 # Returns
-A dictionary containing the properties of the node, including the label and field names.
-
+- A `Dict{Symbol, Any}` where each key is a symbol corresponding to the node's property names 
+(including the `label`), and the value is the corresponding property value.
 """
-function get_node_properties(model::GraphPPL.Model, vertex)
+function get_node_properties(model::GraphPPL.Model, vertex::Int64)
     # Set up return value
     namespace_variables = Dict{Symbol, Any}()
 
@@ -43,6 +59,20 @@ function get_node_properties(model::GraphPPL.Model, vertex)
     return namespace_variables
 end
 
+"""
+    get_node_properties(properties::GraphPPL.FactorNodeProperties)
+
+Extracts the properties of a factor node from a `GraphPPL.FactorNodeProperties` struct 
+and returns them as a dictionary.
+
+# Arguments
+- `properties::GraphPPL.FactorNodeProperties`: A struct containing the factor node properties 
+of a factor node in a probabilistic graphical model.
+
+# Returns
+- A `Dict{Symbol, Any}` where each key is the name of a field in the `properties` 
+object (as a symbol), and the corresponding value is the value of that field.
+"""
 function get_node_properties(properties::GraphPPL.FactorNodeProperties)
     # Set up return value
     namespace_variables = Dict{Symbol, Any}()
@@ -58,6 +88,19 @@ function get_node_properties(properties::GraphPPL.FactorNodeProperties)
     return namespace_variables
 end
 
+"""
+    get_node_properties(properties::GraphPPL.VariableNodeProperties)
+
+Extracts the properties of a variable node from a `GraphPPL.VariableNodeProperties` struct 
+and returns them as a dictionary.
+
+# Arguments
+- `properties::GraphPPL.VariableNodeProperties`: A struct containing the variable node properties.
+
+# Returns
+- A `Dict{Symbol, Any}` where each key is the name of a field in the `properties` 
+object (as a symbol), and the corresponding value is the value of that field.
+"""
 function get_node_properties(properties::GraphPPL.VariableNodeProperties)
     # Set up return value
     namespace_variables = Dict{Symbol, Any}()
@@ -74,11 +117,21 @@ function get_node_properties(properties::GraphPPL.VariableNodeProperties)
 end
 
 """
-Returns a dict of dicts where each key is the unique 
-GraphPPL.NodeLabel.global_counter value for each node.
-Each value is a dictionary containing the namespace for 
-the node with ID == Key. 
+    get_namespace_variables_dict(model::GraphPPL.Model)
+
+Creates a dictionary mapping each node's global counter ID to its corresponding 
+properties within a `GraphPPL.Model`.
+
+# Arguments
+- `model::GraphPPL.Model`: The probabilistic graphical model from which node 
+properties will be extracted.
 
+# Returns
+- A `Dict{Int64, Dict{Symbol, Any}}` where:
+  - The keys are the global counter IDs (`Int64`) of the nodes within the model. 
+    This is the GraphPPL.NodeLabel.global_counter value.
+  - The values are all dictionaries (`Dict{Symbol, Any}`), containing the properties 
+  of the corresponding nodes.
 """
 function get_namespace_variables_dict(model::GraphPPL.Model)
     
@@ -97,12 +150,26 @@ function get_namespace_variables_dict(model::GraphPPL.Model)
 end
 
 """
-Input: the namespace dictionary for a particular variable node. 
+    get_sanitized_variable_node_name(var_namespace_dict::Dict{Symbol, Any})
+
+Generates a sanitized string representation of a variable node's name, ID, and value.
+
+# Arguments
+- `var_namespace_dict::Dict{Symbol, Any}`: The namespace dictionary for a particular 
+   variable node. 
 
-Return value: a string containing the variable node name, variable node ID
-and variable node value. These three fields are to be the default variable node
+# Returns
+- A `String` that concatenates the variable node's name (label) and its value. 
+If the value is `nothing`, the string `"nothing"` is used instead. The format 
+of the returned string is `"<variable_name>:<variable_value>"`.
+
+# Details
+This function extracts the `label` (which serves as the variable node's name - for now) 
+and `value` from the input dictionary and constructs a string in the format 
+`"<label>:<value>"`. If the value is `nothing`, the string `"nothing"` is used 
+in place of the value.
 """
-function get_sanitized_variable_node_name(var_namespace_dict)
+function get_sanitized_variable_node_name(var_namespace_dict::Dict{Symbol, Any})
     
     san_str_name_var = string(var_namespace_dict[:label]) # was :name
     
@@ -118,12 +185,25 @@ function get_sanitized_variable_node_name(var_namespace_dict)
 end
 
 """
-Input: the namespace dictionary for a particular factor node. 
+    get_sanitized_factor_node_name(fac_namespace_dict::Dict{Symbol, Any})
+
+Generates a sanitized string representation of a factor node's name.
+
+# Arguments
+- `fac_namespace_dict::Dict{Symbol, Any}`: A dictionary containing the properties 
+of a factor node, specifically its label.
+
+# Returns
+- A `String` containing the sanitized name of the factor node, derived from the 
+`label` field in the input dictionary.
+
+# Details
+This function extracts the `label` from the input dictionary, which serves as 
+the name of the factor node. It then converts the label to a string and returns 
+it as the sanitized name of the factor node.
 
-Return value: a string containing only the name for the input factor node 
-namespace dictionary. 
 """
-function get_sanitized_factor_node_name(fac_namespace_dict)
+function get_sanitized_factor_node_name(fac_namespace_dict::Dict{Symbol, Any})
 
     san_str_name_fac = string(fac_namespace_dict[:label]) # was :fform
     
@@ -131,12 +211,32 @@ function get_sanitized_factor_node_name(fac_namespace_dict)
 end
 
 """
-Input: a namespace dictionary for an arbitrary node (variable node or factor node).
+    get_sanitized_node_name(single_node_namespace_dict::Dict{Symbol, Any})
 
-Return value: a string cotaining either the return value of 
-get_sanitized_variable_node_name or get_sanitized_factor_node_name.
-"""
-function get_sanitized_node_name(single_node_namespace_dict)
+Generates a sanitized name for a node (either a variable node or a factor node) 
+based on its properties.
+
+# Arguments
+- `single_node_namespace_dict::Dict{Symbol, Any}`: A dictionary containing the 
+properties of a node, which is either a variable node or a factor node.
+
+# Returns
+- A `String` representing the sanitized name of the node. This is determined 
+by calling either `get_sanitized_variable_node_name` for variable nodes, or 
+`get_sanitized_factor_node_name` for factor nodes.
+
+# Details
+This function determines whether the input dictionary represents a variable 
+node or a factor node by checking the presence of specific keys:
+- If the dictionary contains the `:name` key, the node is considered a variable 
+  node, and `get_sanitized_variable_node_name` is called.
+- If the dictionary contains the `:fform` key, the node is considered a factor 
+  node, and `get_sanitized_factor_node_name` is called.
+
+If neither key is found, the function throws an error indicating that the 
+dictionary is missing the necessary information to determine the node type.
+"""
+function get_sanitized_node_name(single_node_namespace_dict::Dict{Symbol, Any})
     if haskey(single_node_namespace_dict, :name)
         san_node_name_str = get_sanitized_variable_node_name(single_node_namespace_dict)
     elseif haskey(single_node_namespace_dict, :fform)
@@ -149,11 +249,26 @@ function get_sanitized_node_name(single_node_namespace_dict)
 end
 
 """
-Input: a string containing the DOT code corresponding to a GraphPPL.Model
+    strip_dot_wrappers(dot_string::String)
+
+Strips non-DOT syntax from the beginning and end of a GraphViz.jl DOT code string.
+
+# Arguments
+- `dot_string::String`: A string containing the DOT code generated for a 
+`GraphPPL.Model`, including the GraphViz.jl wrapper code (non-DOT syntax) at the 
+beginning and end.
+
+# Returns
+- A `String` with the leading and trailing non-DOT syntax removed, leaving 
+only the valid DOT code.
 
-Return value: returns the input string, stripped of the leading and 
-trailing non-DOT syntax.
+# Details
+This function is designed to clean up GraphViz.jl DOT code strings by removing the specific 
+wrapper syntax that may is present at the beginning and end of such a string. It removes:
+- The leading 'dot...' sequence at the start.
+- The trailing '...n' sequence at the end.
 
+The resulting string is ready for use in DOT-compatible tools.
 """
 function strip_dot_wrappers(dot_string::String)
     stripped_string = replace(dot_string, r"^dot\"\"\"\n" => "")
@@ -163,18 +278,24 @@ function strip_dot_wrappers(dot_string::String)
 end
 
 """
-Writes the given DOT string to a file specified by file_path.
+    write_to_dot_file(dot_string::String, file_path::String) :: Bool
 
-# Arguments:
-- dot_string: The DOT format string to write to the file.
-- file_path: The path of the file where the DOT string should be written.
+Writes the given DOT format string to a file specified by `file_path`.
 
-# Returns:
-- Bool: Returns true if the file was written successfully, otherwise false.
+# Arguments
+- `dot_string::String`: The DOT format string to be written to the file.
+- `file_path::String`: The path of the file where the DOT string will be written.
 
-# Throws:
-- SystemError: If there is an error in opening/writing to the file.
+# Returns
+- `Bool`: Returns `true` if the file was written successfully; otherwise, returns `false`.
 
+# Throws
+- `SystemError`: If there is an error in opening or writing to the file.
+
+# Details
+Attempts to write a DOT string to the specified file path. 
+If the operation is successful, it returns `true`. If an error occurs, it logs 
+the error and returns `false`.
 """
 function write_to_dot_file(dot_string::String, file_path::String) :: Bool
     try
@@ -189,15 +310,22 @@ function write_to_dot_file(dot_string::String, file_path::String) :: Bool
 end
 
 """
-Generate a PDF file from a DOT file using Graphviz's dot command.
+    generate_pdf_from_dot(src_dot_file_path::String, dst_pdf_file_path_name::String) :: Bool
+
+Generates a PDF file from a DOT file using Graphviz's `dot` command.
 
 # Arguments
-- src_dot_file_path: The path to the source DOT file.
-- dst_pdf_file_path_name: The desired path and name for the output PDF file.
+- `src_dot_file_path::String`: The path to the source DOT file.
+- `dst_pdf_file_path_name::String`: The desired path and name for the output PDF file.
 
 # Returns
-- Bool: true if the PDF generation is successful, false otherwise.
+- `Bool`: Returns `true` if the PDF generation is successful; otherwise, returns `false`.
 
+# Details
+This function takes a DOT file specified by `src_dot_file_path` and converts it to a PDF 
+file using the Graphviz `dot` command. The resulting PDF is saved to the path 
+specified by `dst_pdf_file_path_name`. The function returns `true` upon successful generation 
+of the PDF, and `false` if any error occurs during the process.
 """
 function generate_pdf_from_dot(src_dot_file_path::String, dst_pdf_file_path_name::String) :: Bool
     try
@@ -209,19 +337,27 @@ function generate_pdf_from_dot(src_dot_file_path::String, dst_pdf_file_path_name
 end
 
 """
-Convert a DOT string to a PDF file.
+    dot_string_to_pdf(dot_string::String, dst_pdf_file::String) :: Bool
 
-This function encapsulates the process of stripping unnecessary wrappers from the DOT string,
-writing it to a temporary DOT file, converting it to a PDF using Graphviz, and cleaning up the 
-temporary file.
+Converts a DOT string to a PDF file via the following steps:
+1. Strips unnecessary wrappers from the DOT string.
+2. Writes the cleaned DOT string to a temporary DOT file.
+3. Converts the temporary DOT file to a PDF using Graphviz's `dot` command.
+4. Cleans up the temporary DOT file.
 
-# Arguments:
-- dot_string: The DOT format string to be converted.
-- dst_pdf_file: The desired path and name for the output PDF file.
+# Arguments
+- `dot_string::String`: The DOT format string to be converted into a PDF.
+- `dst_pdf_file::String`: The path and filename where the output PDF should be saved.
 
-# Returns:
-- Bool: true if the PDF generation is successful, false otherwise.
+# Returns
+- `Bool`: Returns `true` if the PDF generation is successful, `false` otherwise.
 
+# Details
+The function first processes the input DOT string to remove any non-DOT syntax wrappers. 
+It then writes the cleaned string to a temporary file named `"tmp.dot"`. 
+After generating the PDF using Graphviz, the temporary file is removed. 
+The function returns `true` if all operations complete successfully, and `false` 
+if an error occurs during any step.
 """
 function dot_string_to_pdf(dot_string::String, dst_pdf_file::String) :: Bool
     tmp_dot_file = "tmp.dot"
@@ -240,21 +376,26 @@ function dot_string_to_pdf(dot_string::String, dst_pdf_file::String) :: Bool
 end
 
 """
-Responsible for contructing the portion of the final DOT string which
-specifies the nodes in the eventual GraphViz visualization. 
-
-This method of add_nodes! simply iterates over the set of verticies from the constituent 
-MetaGraphsNext.MetaGraph contained in model_graph. 
+Constructs the portion of the DOT string that specifies the nodes in the GraphViz visualization.
+Specifically, by means of the simple iteration strategy specified by the `SimpleIteration` subtype. 
 
-Raises an error if the type of any vertex is not recognized. 
+This function iterates over the vertices of the graph contained in the `model_graph`, 
+which is an instance of `GraphPPL.Model`. It writes the appropriate DOT notation for each 
+node to the provided `io_buffer`. The function handles two types of nodes:
+- `GraphPPL.FactorNodeProperties`: Represented as squares with a light gray fill color.
+- `GraphPPL.VariableNodeProperties`: Represented as circles.
 
 # Arguments:
-- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
-- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
-- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
-  Otherwise known as the global namespace dictionary. 
-- ::SimpleIteration: identifies the desired iteration strategy as SimpleIteration. 
+- `io_buffer::IOBuffer`: The buffer to which DOT string segments are written. 
+  Used for efficient iterative writes rather than string concatenation.
+- `model_graph::GraphPPL.Model`: The GraphPPL model containing the factor graph. 
+  This provides the raw graph structure from which nodes are extracted.
+- `global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}`: A dictionary mapping vertex IDs to their 
+  namespace dictionaries. This global namespace dictionary provides node-specific metadata.
+- `::SimpleIteration`: Specifies the iteration strategy to use, here set to `SimpleIteration`.
 
+# Raises:
+- `Error`: If a vertex's properties are of an unrecognized type.
 """
 function add_nodes!(
         io_buffer::IOBuffer, 
@@ -283,21 +424,27 @@ function add_nodes!(
 end
 
 """
-Responsible for contructing the portion of the final DOT string which
-specifies the nodes in the eventual GraphViz visualization. 
+Constructs the portion of the DOT string that specifies the nodes in the GraphViz visualization.
+Specifically, by means of a Breadth First Search (BFS) from the initially-created 
+node of the 'model_graph'.
 
-This method of add_nodes! conducts a Breadth First Search (BFS) from the initially-created 
-node of the model_graph. 
-
-Raises an error if the type of any vertex is not recognized. 
+This function iterates over the vertices of the graph contained in the `model_graph`, 
+which is an instance of `GraphPPL.Model`. It writes the appropriate DOT notation for each 
+node to the provided `io_buffer`. The function handles two types of nodes:
+- `GraphPPL.FactorNodeProperties`: Represented as squares with a light gray fill color.
+- `GraphPPL.VariableNodeProperties`: Represented as circles.
 
 # Arguments:
-- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
-- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
-- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
-  Otherwise known as the global namespace dictionary. 
-- ::BFSTraversal: identifies the desired iteration strategy as BFSTraversal. 
+- `io_buffer::IOBuffer`: The buffer to which DOT string segments are written. 
+  Used for efficient iterative writes rather than string concatenation.
+- `model_graph::GraphPPL.Model`: The GraphPPL model containing the factor graph. 
+  This provides the raw graph structure from which nodes are extracted.
+- `global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}`: A dictionary mapping vertex IDs to their 
+  namespace dictionaries. This global namespace dictionary provides node-specific metadata.
+- `::BFSTraversal`: Specifies the BFS iteration strategy. The search is carried out from the initially created node.
 
+# Raises:
+- `Error`: If a vertex's properties are of an unrecognized type.
 """
 function add_nodes!(
         io_buffer::IOBuffer, 
@@ -306,7 +453,7 @@ function add_nodes!(
         ::BFSTraversal
     )
     
-    n = nv(model_graph) # number of nodes in the 
+    n = nv(model_graph) # number of nodes in the model_graph
     visited = falses(n) # array of visited nodes
     cur_level = Vector{Int}() # current level of nodes processed in BFS/current layer of the BFS iteration
     next_level = Vector{Int}() # next level of nodes for BFS iteration
@@ -349,21 +496,21 @@ function add_nodes!(
 end
 
 """
-Responsible for contructing the portion of the final DOT string which
-specifies the edges between the included nodes in the eventual GraphViz visualization. 
-
-This method of add_edges! simply iterates over the set of edges from the constituent 
-MetaGraphsNext.MetaGraph contained in model_graph.
+Constructs the portion of the DOT string that specifies the edges between nodes in a 
+GraphViz visualization. This function iterates over the edges in the `model_graph`  via 
+the `SimpleIteration` strategy and generates the corresponding DOT syntax to represent these 
+edges. Each edge connects two nodes, and the `edge_length` parameter controls the visual 
+length of these edges in the final graph.
 
 # Arguments:
-- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
-- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
-- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
-  Otherwise known as the global namespace dictionary. 
-- ::SimpleIteration: identifies the desired iteration strategy as SimpleIteration. 
-- edge_length: a floating point value to control the length of the edges. 
-
-
+- `io_buffer::IOBuffer`: An IOBuffer used for efficient iterative writing of the DOT string. 
+- `model_graph::GraphPPL.Model`: The GraphPPL model containing the raw factor graph from 
+   which edges are extracted.
+- `global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}`: A dictionary mapping vertex IDs 
+   to their namespace dictionaries. This global namespace provides metadata for each node.
+- `::SimpleIteration`: Specifies the iteration strategy, here set to `SimpleIteration`.
+- `edge_length::Float64`: A floating-point value that specifies the length of the edges in 
+   the visualization.
 """
 function add_edges!(
         io_buffer::IOBuffer, 
@@ -387,20 +534,21 @@ function add_edges!(
 end
 
 """
-Responsible for contructing the portion of the final DOT string which
-specifies the edges between the included nodes in the eventual GraphViz visualization. 
-
-This method of add_edges! conducts a Breadth First Search (BFS) from the initially-created 
-node of the model_graph. 
+Constructs the portion of the DOT string that specifies the edges between nodes in a 
+GraphViz visualization. This function iterates over the edges in the `model_graph`  via 
+the `BFSTraversal` strategy and generates the corresponding DOT syntax to represent these 
+edges. Each edge connects two nodes, and the `edge_length` parameter controls the visual 
+length of these edges in the final graph.
 
 # Arguments:
-- io_buffer: an IOBuffer is used to perform iterative writes as opposed to string concatenation. 
-- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
-- global_namespace_dict: the namespace dictionary for all nodes in the model_graph. 
-  Otherwise known as the global namespace dictionary. 
-- ::BFSTraversal: identifies the desired iteration strategy as BFSTraversal. 
-- edge_length: a floating point value to control the length of the edges. 
-
+- `io_buffer::IOBuffer`: An IOBuffer used for efficient iterative writing of the DOT string. 
+- `model_graph::GraphPPL.Model`: The GraphPPL model containing the raw factor graph from 
+   which edges are extracted.
+- `global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}`: A dictionary mapping vertex IDs 
+   to their namespace dictionaries. This global namespace provides metadata for each node.
+- `::BFSTraversal`: Specifies the iteration strategy, here set to `BFSTraversal`.
+- `edge_length::Float64`: A floating-point value that specifies the length of the edges in 
+   the visualization.
 """
 function add_edges!(
         io_buffer::IOBuffer, 
@@ -456,22 +604,24 @@ function add_edges!(
 end
 
 """
-Constructs the DOT string from an input GraphPPL.Model.
+Constructs a DOT string from an input `GraphPPL.Model` for visualization with GraphViz.jl. 
+The DOT string includes configuration options for node appearance, edge length, layout, and more.
 
 # Arguments:
-- model_graph: the GraphPPL.Model structure containing the raw factor graph. 
-- strategy: the abstract type which specifies the particular traversal strategy. 
-Either SimpleIteration() or BFSTraversal().
-- font_size: the font size of the node fields. 
-- edge_length: a floating point value to control the length of the edges. 
-- layout: layout engine for the eventual display. Default is "neato".  
-- width: width of the display window.
-- height: height of the display window.
+- `model_graph::GraphPPL.Model`: The `GraphPPL.Model` structure containing the raw factor 
+   graph to be visualized.
+- `strategy::TraversalStrategy`: Specifies the traversal strategy for graph traversal. 
+   Either `SimpleIteration()` or `BFSTraversal()`.
+- `font_size::Int`: The font size of the node labels.
+- `edge_length::Float64` (default is `1.0`): Controls the visual length of edges in the graph.
+- `layout::String` (default is `"neato"`): The layout engine to be used by GraphViz for 
+   arranging the nodes.
+- `overlap::Bool`: Controls whether node overlap is allowed in the visualization.
+- `width::Float64` (default is `10.0`): The width of the display window in inches.
+- `height::Float64` (default is `10.0`): The height of the display window in inches.
 
 # Returns:
-- String: a string containing the DOT code which can then be executed 
-to yield a GraphViz visualization. 
-
+- `String`: A DOT format string that can be used to generate a GraphViz visualization.
 """
 function generate_dot(;
         model_graph::GraphPPL.Model, 
@@ -510,10 +660,22 @@ function generate_dot(;
 end
 
 """
-Executes the DOT string returned by generate_dot.
+    show_gv(dot_code_graph::String)
+
+Executes the DOT string to display the graph using Graphviz.
+
+This function evaluates the DOT string generated by the `generate_dot` 
+function, and displays the graph visualization. It uses  Julia's `eval` 
+and `Meta.parse` functions to interpret and execute the DOT code.
 
 # Arguments:
-- dot_code_graph: the DOT string returned by generate_dot. 
+- `dot_code_graph::String`: The DOT format string representing the graph to be 
+visualized. This string is expected to be valid DOT code generated by the 
+`generate_dot` function, as per the convention used in GraphViz.jl.
+
+# Throws:
+- `ErrorException`: If there is an error while evaluating the DOT string, an 
+exception will be raised with a message indicating the problem.
 """
 function show_gv(dot_code_graph::String)
     try
@@ -521,4 +683,6 @@ function show_gv(dot_code_graph::String)
     catch e
         error("Could not evaluate the input DOT string: ", e)
     end
-end
\ No newline at end of file
+end
+
+end
diff --git a/src/tests.jl b/src/tests.jl
new file mode 100644
index 0000000..30fff2d
--- /dev/null
+++ b/src/tests.jl
@@ -0,0 +1,96 @@
+
+include("graphviz_visualization.jl")
+
+using .GPPLGViz
+
+using RxInfer
+using Distributions
+using Random
+using Graphs
+using MetaGraphsNext
+# using GraphViz
+using Dictionaries
+using Cairo # necessary for draw PDF...
+using Fontconfig # necessary for draw PDF...
+using Compose # necessary for draw PDF...
+
+using GraphPlot
+
+
+# GraphPPL.jl export `@model` macro for model specification
+# It accepts a regular Julia function and builds an FFG under the hood
+@model function coin_model(y, a, b)
+    # We endow θ parameter of our model with some prior
+    θ ~ Beta(a, b)
+    # or, in this particular case, the `Uniform(0.0, 1.0)` prior also works:
+    # θ ~ Uniform(0.0, 1.0)
+
+    # We assume that outcome of each coin flip is governed by the Bernoulli distribution
+    for i in eachindex(y)
+        y[i] ~ Bernoulli(θ)
+    end
+end
+
+# condition the model on some observed data
+conditioned = coin_model(a = 2.0, b = 7.0) | (y = [ true, false, true ], )
+
+# `Create` the actual graph of the model conditioned on the data
+rxi_model = RxInfer.create_model(conditioned)
+
+gppl_model = RxInfer.getmodel(rxi_model)
+
+# Extract the MetaGraphsNext graph
+meta_graph = gppl_model.graph
+
+# for vertex in MetaGraphsNext.vertices(meta_graph)
+# 	println(typeof(vertex))
+# end
+
+
+global_namespace_dicterino = get_namespace_variables_dict(gppl_model)
+
+# println(global_namespace_dicterino)
+
+for (key, val) in global_namespace_dicterino
+	san_name = get_sanitized_node_name(val)
+	# println("san_name: $(san_name)")
+	println("val: $(val)")
+end
+
+
+## GPLOT
+
+# layout=(args...)->spring_layout(args...; C=2)
+
+# draw(
+#     PDF(
+#         "coin_toss_gplot.pdf", 30cm, 30cm
+#     ), GraphPlot.gplot(
+#         meta_graph,
+#         layout=layout,
+#         nodelabel=collect(labels(meta_graph)),
+#         nodelabelsize=0.5,
+#         NODESIZE=0.05, # diameter of the nodes,
+#         nodelabelc="green",
+#         nodelabeldist=2.0,
+#         nodefillc="blue",
+#         edgestrokec="red",
+#         EDGELINEWIDTH = 0.8
+#     )
+# )
+
+## GRAPHVIZ 
+
+# # create the DOT code string
+# coin_toss_dot_simple = generate_dot(
+#     model_graph = gppl_model, 
+#     strategy = SimpleIteration(),
+#     font_size = 7,
+#     edge_length = 1.0,
+#     layout = "neato",
+#     overlap = true,
+#     width = 6.0,
+#     height = 6.0
+# )
+
+# dot_string_to_pdf(coin_toss_dot_simple, "test_coin_dot_figure.pdf")
\ No newline at end of file

From 82d6dde7fd9c13fcb0612255c763ed65f75449b7 Mon Sep 17 00:00:00 2001
From: FraserP <fraserp@pop-os.localdomain>
Date: Mon, 2 Sep 2024 09:40:39 +0800
Subject: [PATCH 03/10] added first tests for generate_dot and show_gv

---
 src/tests.jl                    | 96 ---------------------------------
 test/visualization_tests_233.jl | 95 ++++++++++++++++++++++++++++++++
 2 files changed, 95 insertions(+), 96 deletions(-)
 delete mode 100644 src/tests.jl
 create mode 100644 test/visualization_tests_233.jl

diff --git a/src/tests.jl b/src/tests.jl
deleted file mode 100644
index 30fff2d..0000000
--- a/src/tests.jl
+++ /dev/null
@@ -1,96 +0,0 @@
-
-include("graphviz_visualization.jl")
-
-using .GPPLGViz
-
-using RxInfer
-using Distributions
-using Random
-using Graphs
-using MetaGraphsNext
-# using GraphViz
-using Dictionaries
-using Cairo # necessary for draw PDF...
-using Fontconfig # necessary for draw PDF...
-using Compose # necessary for draw PDF...
-
-using GraphPlot
-
-
-# GraphPPL.jl export `@model` macro for model specification
-# It accepts a regular Julia function and builds an FFG under the hood
-@model function coin_model(y, a, b)
-    # We endow θ parameter of our model with some prior
-    θ ~ Beta(a, b)
-    # or, in this particular case, the `Uniform(0.0, 1.0)` prior also works:
-    # θ ~ Uniform(0.0, 1.0)
-
-    # We assume that outcome of each coin flip is governed by the Bernoulli distribution
-    for i in eachindex(y)
-        y[i] ~ Bernoulli(θ)
-    end
-end
-
-# condition the model on some observed data
-conditioned = coin_model(a = 2.0, b = 7.0) | (y = [ true, false, true ], )
-
-# `Create` the actual graph of the model conditioned on the data
-rxi_model = RxInfer.create_model(conditioned)
-
-gppl_model = RxInfer.getmodel(rxi_model)
-
-# Extract the MetaGraphsNext graph
-meta_graph = gppl_model.graph
-
-# for vertex in MetaGraphsNext.vertices(meta_graph)
-# 	println(typeof(vertex))
-# end
-
-
-global_namespace_dicterino = get_namespace_variables_dict(gppl_model)
-
-# println(global_namespace_dicterino)
-
-for (key, val) in global_namespace_dicterino
-	san_name = get_sanitized_node_name(val)
-	# println("san_name: $(san_name)")
-	println("val: $(val)")
-end
-
-
-## GPLOT
-
-# layout=(args...)->spring_layout(args...; C=2)
-
-# draw(
-#     PDF(
-#         "coin_toss_gplot.pdf", 30cm, 30cm
-#     ), GraphPlot.gplot(
-#         meta_graph,
-#         layout=layout,
-#         nodelabel=collect(labels(meta_graph)),
-#         nodelabelsize=0.5,
-#         NODESIZE=0.05, # diameter of the nodes,
-#         nodelabelc="green",
-#         nodelabeldist=2.0,
-#         nodefillc="blue",
-#         edgestrokec="red",
-#         EDGELINEWIDTH = 0.8
-#     )
-# )
-
-## GRAPHVIZ 
-
-# # create the DOT code string
-# coin_toss_dot_simple = generate_dot(
-#     model_graph = gppl_model, 
-#     strategy = SimpleIteration(),
-#     font_size = 7,
-#     edge_length = 1.0,
-#     layout = "neato",
-#     overlap = true,
-#     width = 6.0,
-#     height = 6.0
-# )
-
-# dot_string_to_pdf(coin_toss_dot_simple, "test_coin_dot_figure.pdf")
\ No newline at end of file
diff --git a/test/visualization_tests_233.jl b/test/visualization_tests_233.jl
new file mode 100644
index 0000000..e7a7c31
--- /dev/null
+++ b/test/visualization_tests_233.jl
@@ -0,0 +1,95 @@
+using Test
+
+using RxInfer
+using Distributions
+using Random
+using Graphs
+using MetaGraphsNext
+# using GraphViz
+using Dictionaries
+using Cairo # necessary for draw PDF...
+using Fontconfig # necessary for draw PDF...
+using Compose # necessary for draw PDF...
+
+using GraphPlot
+
+include("../src/graphviz_visualization.jl")  # Include your module
+
+using .GPPLGViz: generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
+
+## CREATE AN RXINFER.JL MODEL:
+# GraphPPL.jl export `@model` macro for model specification
+# It accepts a regular Julia function and builds an FFG under the hood
+@model function coin_model(y, a, b)
+    # We endow θ parameter of our model with some prior
+    θ ~ Beta(a, b)
+    # or, in this particular case, the `Uniform(0.0, 1.0)` prior also works:
+    # θ ~ Uniform(0.0, 1.0)
+
+    # We assume that outcome of each coin flip is governed by the Bernoulli distribution
+    for i in eachindex(y)
+        y[i] ~ Bernoulli(θ)
+    end
+end
+
+# condition the model on some observed data
+conditioned = coin_model(a = 2.0, b = 7.0) | (y = [ true, false, true ], )
+
+# `Create` the actual graph of the model conditioned on the data
+rxi_model = RxInfer.create_model(conditioned)
+
+gppl_model = RxInfer.getmodel(rxi_model)
+
+# Extract the MetaGraphsNext graph
+meta_graph = gppl_model.graph
+
+# println("typeof(gppl_model): $(typeof(gppl_model))")
+
+@testset "GPPLGViz Tests" begin
+
+    @testset "generate_dot/show_gv" begin
+
+        ## GENERATE DOT
+        gen_dot_result = generate_dot(
+            model_graph = gppl_model,
+            strategy = SimpleIteration(),
+            font_size = 12,
+            edge_length = 1.0,
+            layout = "neato",
+            overlap = false,
+            width = 10.0, 
+            height = 10.0 
+        )
+
+        @test !isempty(gen_dot_result)
+
+        # Check if the result is a string
+        @test typeof(gen_dot_result) == String
+
+        # Test for specific content in the DOT string
+        @test occursin("dot\"\"\"\n", gen_dot_result)
+        @test occursin("\n\"\"\"", gen_dot_result)
+
+
+        ## SHOW GV
+        result = show_gv(gen_dot_result)
+
+        # Check that `show_gv` does not return nothing
+        @test result !== nothing
+
+    end
+
+    # TEST FOR SHOW GV WAS HERE - ADD MORE TESTS BELOW
+    # @testset "show_gv" begin
+    #     # Ensure `gen_dot_result` is valid for `show_gv`
+    #     @test !isempty(gen_dot_result)
+
+    #     # Test the `show_gv` function
+    #     result = show_gv(gen_dot_result)
+
+    #     # Check that `show_gv` does not return nothing
+    #     @test result !== nothing
+
+    # end
+
+end
\ No newline at end of file

From da0fdfda575f5476331e291da62158fa699fc881 Mon Sep 17 00:00:00 2001
From: Chris Bennett <chrisbennett@Chriss-MacBook-Air.local>
Date: Wed, 4 Sep 2024 20:56:25 -0600
Subject: [PATCH 04/10] Move GraphViz to ext

---
 src/graphviz_visualization.jl => ext/GraphvizVisualization.jl | 0
 test/visualization_tests_233.jl                               | 2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/graphviz_visualization.jl => ext/GraphvizVisualization.jl (100%)

diff --git a/src/graphviz_visualization.jl b/ext/GraphvizVisualization.jl
similarity index 100%
rename from src/graphviz_visualization.jl
rename to ext/GraphvizVisualization.jl
diff --git a/test/visualization_tests_233.jl b/test/visualization_tests_233.jl
index e7a7c31..4adcfd7 100644
--- a/test/visualization_tests_233.jl
+++ b/test/visualization_tests_233.jl
@@ -13,7 +13,7 @@ using Compose # necessary for draw PDF...
 
 using GraphPlot
 
-include("../src/graphviz_visualization.jl")  # Include your module
+include("../ext/GraphvizVisualization.jl")  # Include your module
 
 using .GPPLGViz: generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
 

From d590fbf55941bb6fac19854159ccf2d1605af68e Mon Sep 17 00:00:00 2001
From: FraserP <fraserp@pop-os.localdomain>
Date: Thu, 5 Sep 2024 22:52:33 +0800
Subject: [PATCH 05/10] added minimal tests for most functions.

---
 src/graphviz_visualization.jl   |   2 +
 test/visualization_tests_233.jl | 153 +++++++++++++++++++++++++++-----
 2 files changed, 134 insertions(+), 21 deletions(-)

diff --git a/src/graphviz_visualization.jl b/src/graphviz_visualization.jl
index 4fa3716..878145f 100644
--- a/src/graphviz_visualization.jl
+++ b/src/graphviz_visualization.jl
@@ -53,6 +53,8 @@ function get_node_properties(model::GraphPPL.Model, vertex::Int64)
 
     # Add field names and values to the dictionary
     for field_name in field_names
+
+        # It might be wise to add GraphPPL.NodeData to this also. 
         namespace_variables[field_name] = getproperty(properties, field_name)
     end
 
diff --git a/test/visualization_tests_233.jl b/test/visualization_tests_233.jl
index e7a7c31..781beb2 100644
--- a/test/visualization_tests_233.jl
+++ b/test/visualization_tests_233.jl
@@ -7,13 +7,14 @@ using Graphs
 using MetaGraphsNext
 # using GraphViz
 using Dictionaries
-using Cairo # necessary for draw PDF...
-using Fontconfig # necessary for draw PDF...
-using Compose # necessary for draw PDF...
+
+using Cairo
+using Fontconfig
+using Compose
 
 using GraphPlot
 
-include("../src/graphviz_visualization.jl")  # Include your module
+include("../src/graphviz_visualization.jl")
 
 using .GPPLGViz: generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
 
@@ -43,13 +44,12 @@ gppl_model = RxInfer.getmodel(rxi_model)
 # Extract the MetaGraphsNext graph
 meta_graph = gppl_model.graph
 
-# println("typeof(gppl_model): $(typeof(gppl_model))")
+
 
 @testset "GPPLGViz Tests" begin
 
-    @testset "generate_dot/show_gv" begin
+    @testset "generate_dot/show_gv Function" begin
 
-        ## GENERATE DOT
         gen_dot_result = generate_dot(
             model_graph = gppl_model,
             strategy = SimpleIteration(),
@@ -63,33 +63,144 @@ meta_graph = gppl_model.graph
 
         @test !isempty(gen_dot_result)
 
-        # Check if the result is a string
         @test typeof(gen_dot_result) == String
 
-        # Test for specific content in the DOT string
         @test occursin("dot\"\"\"\n", gen_dot_result)
         @test occursin("\n\"\"\"", gen_dot_result)
 
-
-        ## SHOW GV
         result = show_gv(gen_dot_result)
 
-        # Check that `show_gv` does not return nothing
         @test result !== nothing
 
     end
 
-    # TEST FOR SHOW GV WAS HERE - ADD MORE TESTS BELOW
-    # @testset "show_gv" begin
-    #     # Ensure `gen_dot_result` is valid for `show_gv`
-    #     @test !isempty(gen_dot_result)
+    @testset "get_node_properties Functions" begin
+
+        vertex_labels = collect(labels(meta_graph))
+
+        for (vindex, vlabel) in enumerate(vertex_labels)
+            vcode = code_for(meta_graph, vlabel)
+            vprops = GPPLGViz.get_node_properties(gppl_model, vcode)
+
+            @test typeof(vprops) == Dict{Symbol, Any}
+        end
+
+    end
+
+    @testset "get_namespace_variables_dict Function" begin
+        gppl_model_namespace_dict = GPPLGViz.get_namespace_variables_dict(gppl_model)
+
+        @test length(gppl_model_namespace_dict) == nv(meta_graph)
+    end
+
+    @testset "get_sanitized_variable_node_name Function" begin
+
+        model_namespace_dict = GPPLGViz.get_namespace_variables_dict(gppl_model)
+
+        # match any string - including those with Greek letters - followed by an underscore 
+        # and then an integer (excluding 0) followed by a colon and then terminated with 
+        # either "nothing" or any floating point value
+        var_regex = r"^[a-zA-Z_α-ωΑ-Ω]+_\d{1,}:(nothing|-?\d+\.?\d*([eE][+-]?\d+)?)$"
+
+        for (key, val) in model_namespace_dict
+            if haskey(val, :name)
+                san_node_name_str = GPPLGViz.get_sanitized_variable_node_name(val)
+                # println("VAR: $(san_node_name_str)")
+                @test occursin(var_regex, san_node_name_str)
+            end
+        end
+    end
+
+    @testset "get_sanitized_factor_node_name Function" begin
+
+        model_namespace_dict = GPPLGViz.get_namespace_variables_dict(gppl_model)
+
+        # match any string - including those with Greek letters - followed by an underscore 
+        # and then an integer (excluding 0) followed by a colon and then terminated with 
+        # either "nothing" or any floating point value
+        fac_regex = r"^[a-zA-Z_α-ωΑ-Ω]+_[1-9]\d*$"
+
+        for (key, val) in model_namespace_dict
+            if haskey(val, :fform)
+                san_node_name_str = GPPLGViz.get_sanitized_factor_node_name(val)
+                # println("VAR: $(san_node_name_str)")
+                @test san_node_name_str == string(val[:label])
+                @test occursin(fac_regex, san_node_name_str)
+            end
+        end
+    end
+
+    @testset "get_sanitized_node_name Function" begin
+
+        model_namespace_dict = GPPLGViz.get_namespace_variables_dict(gppl_model)
+
+        fac_regex = r"^[a-zA-Z_α-ωΑ-Ω]+_[1-9]\d*$"
+        var_regex = r"^[a-zA-Z_α-ωΑ-Ω]+_\d{1,}:(nothing|-?\d+\.?\d*([eE][+-]?\d+)?)$"
+
+        for (key, val) in model_namespace_dict
+            san_node_name_str = GPPLGViz.get_sanitized_node_name(val)
+
+            if haskey(val, :fform)
+                san_node_name_str = GPPLGViz.get_sanitized_factor_node_name(val)
+                # println("VAR: $(san_node_name_str)")
+                @test san_node_name_str == string(val[:label])
+                @test occursin(fac_regex, san_node_name_str)
+            end
+
+            if haskey(val, :name)
+                san_node_name_str = GPPLGViz.get_sanitized_variable_node_name(val)
+                # println("VAR: $(san_node_name_str)")
+                @test occursin(var_regex, san_node_name_str)
+            end
+
+        end
+    end
+
+    @testset "strip_dot_wrappers Function" begin
 
-    #     # Test the `show_gv` function
-    #     result = show_gv(gen_dot_result)
+        model_namespace_dict = GPPLGViz.get_namespace_variables_dict(gppl_model)
 
-    #     # Check that `show_gv` does not return nothing
-    #     @test result !== nothing
+        gen_dot_result = generate_dot(
+            model_graph = gppl_model,
+            strategy = SimpleIteration(),
+            font_size = 12,
+            edge_length = 1.0,
+            layout = "neato",
+            overlap = false,
+            width = 10.0, 
+            height = 10.0 
+        )
+
+        gen_dot_result_stripped = GPPLGViz.strip_dot_wrappers(gen_dot_result)
+
+        @test !occursin(r"^dot\"\"\"\n" , gen_dot_result_stripped)
+        @test !occursin(r"\n\"\"\"$", gen_dot_result_stripped)
+
+    end
+
+    @testset "write_to_dot_file Function" begin
 
-    # end
+        gen_dot_result = generate_dot(
+            model_graph = gppl_model,
+            strategy = SimpleIteration(),
+            font_size = 12,
+            edge_length = 1.0,
+            layout = "neato",
+            overlap = false,
+            width = 10.0, 
+            height = 10.0 
+        )
+
+        success = GPPLGViz.write_to_dot_file(gen_dot_result, "test_output.txt")
+
+        if success
+            if isfile("test_output.txt")
+                rm("test_output.txt")
+            end
+        end
+
+        @test success == true
+
+    end
 
 end
\ No newline at end of file

From f6a192c2f5b21091c9bac5542b6894d3ba218bc5 Mon Sep 17 00:00:00 2001
From: Chris Bennett <chrisbennett@Chriss-MacBook-Air.local>
Date: Thu, 5 Sep 2024 20:57:00 -0600
Subject: [PATCH 06/10] Update Project.toml file

---
 Project.toml                 | 3 +++
 ext/GraphvizVisualization.jl | 7 ++-----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Project.toml b/Project.toml
index 95b0ff9..76e4566 100644
--- a/Project.toml
+++ b/Project.toml
@@ -19,10 +19,12 @@ Unrolled = "9602ed7d-8fef-5bc8-8597-8f21381861e8"
 Cairo = "159f3aea-2a34-519c-b102-8c37f9878175"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 GraphPlot = "a2cc645c-3eea-5389-862e-a155d0052231"
+GraphViz = "f526b714-d49f-11e8-06ff-31ed36ee7ee0"
 
 [extensions]
 GraphPPLDistributionsExt = "Distributions"
 GraphPPLPlottingExt = ["Cairo", "GraphPlot"]
+GraphvizVisualization = ["GraphViz", "MetaGraphsNext"]
 
 [compat]
 BitSetTuples = "1.1"
@@ -40,6 +42,7 @@ StaticArrays = "1.6"
 TupleTools = "1.4"
 Unrolled = "0.1"
 julia = "1.10"
+GraphViz = "0.2"
 
 [extras]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
diff --git a/ext/GraphvizVisualization.jl b/ext/GraphvizVisualization.jl
index 4fa3716..63cae24 100644
--- a/ext/GraphvizVisualization.jl
+++ b/ext/GraphvizVisualization.jl
@@ -1,11 +1,8 @@
-module GPPLGViz
+module GraphvizVisualization
 
 export generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
 
-using GraphPPL
-using MetaGraphsNext
-using GraphViz
-
+using GraphPPL, MetaGraphsNext, GraphViz
 
 """
 This abstract type represents a node traversal strategy for use with the `generate_dot` function.

From 7671c6e5b6510731b3d1c16ce0abd9ff23b27f39 Mon Sep 17 00:00:00 2001
From: Wouter Nuijten <wouternuijten@gmail.com>
Date: Mon, 9 Sep 2024 11:48:22 +0100
Subject: [PATCH 07/10] Remove `MetaGraphsNext` from extension dependencies

---
 Project.toml                 |   2 +-
 ext/GraphvizVisualization.jl | 160 +++++++++++++++--------------------
 2 files changed, 71 insertions(+), 91 deletions(-)

diff --git a/Project.toml b/Project.toml
index 76e4566..dd14e18 100644
--- a/Project.toml
+++ b/Project.toml
@@ -24,7 +24,7 @@ GraphViz = "f526b714-d49f-11e8-06ff-31ed36ee7ee0"
 [extensions]
 GraphPPLDistributionsExt = "Distributions"
 GraphPPLPlottingExt = ["Cairo", "GraphPlot"]
-GraphvizVisualization = ["GraphViz", "MetaGraphsNext"]
+GraphvizVisualization = "GraphViz"
 
 [compat]
 BitSetTuples = "1.1"
diff --git a/ext/GraphvizVisualization.jl b/ext/GraphvizVisualization.jl
index f7eb420..f092692 100644
--- a/ext/GraphvizVisualization.jl
+++ b/ext/GraphvizVisualization.jl
@@ -3,6 +3,8 @@ module GraphvizVisualization
 export generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
 
 using GraphPPL, MetaGraphsNext, GraphViz
+using GraphPPL.MetaGraphsNext
+import MetaGraphsNext: nv
 
 """
 This abstract type represents a node traversal strategy for use with the `generate_dot` function.
@@ -44,7 +46,7 @@ function get_node_properties(model::GraphPPL.Model, vertex::Int64)
 
     # Add label to the dictionary
     namespace_variables[:label] = label
-    
+
     # Get field names
     field_names = fieldnames(typeof(properties))
 
@@ -75,7 +77,7 @@ object (as a symbol), and the corresponding value is the value of that field.
 function get_node_properties(properties::GraphPPL.FactorNodeProperties)
     # Set up return value
     namespace_variables = Dict{Symbol, Any}()
-    
+
     # Get field names
     field_names = fieldnames(typeof(properties))
 
@@ -103,7 +105,7 @@ object (as a symbol), and the corresponding value is the value of that field.
 function get_node_properties(properties::GraphPPL.VariableNodeProperties)
     # Set up return value
     namespace_variables = Dict{Symbol, Any}()
-    
+
     # Get field names
     field_names = fieldnames(typeof(properties))
 
@@ -133,18 +135,16 @@ properties will be extracted.
   of the corresponding nodes.
 """
 function get_namespace_variables_dict(model::GraphPPL.Model)
-    
     node_properties_dict = Dict{Int64, Dict{Symbol, Any}}()
-    
+
     for vertex in MetaGraphsNext.vertices(model.graph)
-        
         node_properties = get_node_properties(model, vertex)
-        
+
         global_counter_id = node_properties[:label].global_counter
-        
+
         node_properties_dict[global_counter_id] = node_properties
     end
-    
+
     return node_properties_dict
 end
 
@@ -169,15 +169,14 @@ and `value` from the input dictionary and constructs a string in the format
 in place of the value.
 """
 function get_sanitized_variable_node_name(var_namespace_dict::Dict{Symbol, Any})
-    
     san_str_name_var = string(var_namespace_dict[:label]) # was :name
-    
+
     if var_namespace_dict[:value] == nothing
         str_val_var = "nothing"
     else
         str_val_var = string(var_namespace_dict[:value])
     end
-    
+
     final_str = string(san_str_name_var, ":", str_val_var)
 
     return final_str
@@ -203,9 +202,8 @@ it as the sanitized name of the factor node.
 
 """
 function get_sanitized_factor_node_name(fac_namespace_dict::Dict{Symbol, Any})
-
     san_str_name_fac = string(fac_namespace_dict[:label]) # was :fform
-    
+
     return san_str_name_fac
 end
 
@@ -243,7 +241,7 @@ function get_sanitized_node_name(single_node_namespace_dict::Dict{Symbol, Any})
     else
         error("Input single-node namespace dictionary has neither :name nor :fform as a key.")
     end
-    
+
     return san_node_name_str
 end
 
@@ -272,7 +270,7 @@ The resulting string is ready for use in DOT-compatible tools.
 function strip_dot_wrappers(dot_string::String)
     stripped_string = replace(dot_string, r"^dot\"\"\"\n" => "")
     stripped_string = replace(stripped_string, r"\n\"\"\"$" => "")
-    
+
     return stripped_string
 end
 
@@ -296,7 +294,7 @@ Attempts to write a DOT string to the specified file path.
 If the operation is successful, it returns `true`. If an error occurs, it logs 
 the error and returns `false`.
 """
-function write_to_dot_file(dot_string::String, file_path::String) :: Bool
+function write_to_dot_file(dot_string::String, file_path::String)::Bool
     try
         open(file_path, "w") do file
             write(file, dot_string)
@@ -326,7 +324,7 @@ file using the Graphviz `dot` command. The resulting PDF is saved to the path
 specified by `dst_pdf_file_path_name`. The function returns `true` upon successful generation 
 of the PDF, and `false` if any error occurs during the process.
 """
-function generate_pdf_from_dot(src_dot_file_path::String, dst_pdf_file_path_name::String) :: Bool
+function generate_pdf_from_dot(src_dot_file_path::String, dst_pdf_file_path_name::String)::Bool
     try
         run(`dot -Tpdf $src_dot_file_path -o $dst_pdf_file_path_name`)
         return true
@@ -358,7 +356,7 @@ After generating the PDF using Graphviz, the temporary file is removed.
 The function returns `true` if all operations complete successfully, and `false` 
 if an error occurs during any step.
 """
-function dot_string_to_pdf(dot_string::String, dst_pdf_file::String) :: Bool
+function dot_string_to_pdf(dot_string::String, dst_pdf_file::String)::Bool
     tmp_dot_file = "tmp.dot"
     try
         pure_dot_string = strip_dot_wrappers(dot_string)
@@ -397,21 +395,17 @@ node to the provided `io_buffer`. The function handles two types of nodes:
 - `Error`: If a vertex's properties are of an unrecognized type.
 """
 function add_nodes!(
-        io_buffer::IOBuffer, 
-        model_graph::GraphPPL.Model, 
-        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
-        ::SimpleIteration
-    )
-    
+    io_buffer::IOBuffer, model_graph::GraphPPL.Model, global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}, ::SimpleIteration
+)
     for vertex in MetaGraphsNext.vertices(model_graph.graph)
-        
+
         # index the label of model_namespace_variables with "vertex"
         san_label = get_sanitized_node_name(global_namespace_dict[vertex])
-        
+
         label = MetaGraphsNext.label_for(model_graph.graph, vertex)
-        
+
         properties = model_graph[label].properties
-        
+
         if isa(properties, GraphPPL.FactorNodeProperties)
             write(io_buffer, "    \"$(san_label)\" [shape=square, style=filled, fillcolor=lightgray];\n")
         elseif isa(properties, GraphPPL.VariableNodeProperties)
@@ -445,34 +439,27 @@ node to the provided `io_buffer`. The function handles two types of nodes:
 # Raises:
 - `Error`: If a vertex's properties are of an unrecognized type.
 """
-function add_nodes!(
-        io_buffer::IOBuffer, 
-        model_graph::GraphPPL.Model, 
-        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}, 
-        ::BFSTraversal
-    )
-    
+function add_nodes!(io_buffer::IOBuffer, model_graph::GraphPPL.Model, global_namespace_dict::Dict{Int64, Dict{Symbol, Any}}, ::BFSTraversal)
     n = nv(model_graph) # number of nodes in the model_graph
     visited = falses(n) # array of visited nodes
     cur_level = Vector{Int}() # current level of nodes processed in BFS/current layer of the BFS iteration
     next_level = Vector{Int}() # next level of nodes for BFS iteration
-    
+
     s = 1 # always start at the initially created node of model_graph
     if !visited[s]
         visited[s] = true
         push!(cur_level, s)
     end
-    
+
     while !isempty(cur_level)
-        
         for v in cur_level # iterate over the verticies in the current level
-            
+
             # we use the sanitized vertex label in the visualization
             san_label = get_sanitized_node_name(global_namespace_dict[v])
-            
+
             label = MetaGraphsNext.label_for(model_graph.graph, v)
             properties = model_graph[label].properties
-            
+
             if isa(properties, GraphPPL.FactorNodeProperties)
                 write(io_buffer, "    \"$(san_label)\" [shape=square, style=filled, fillcolor=lightgray];\n")
             elseif isa(properties, GraphPPL.VariableNodeProperties)
@@ -480,7 +467,7 @@ function add_nodes!(
             else
                 error("Unknown node type for label $(san_label)")
             end
-            
+
             for v_neighb in MetaGraphsNext.neighbors(model_graph.graph, v)
                 if !visited[v_neighb]
                     visited[v_neighb] = true
@@ -512,22 +499,20 @@ length of these edges in the final graph.
    the visualization.
 """
 function add_edges!(
-        io_buffer::IOBuffer, 
-        model_graph::GraphPPL.Model, 
-        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
-        ::SimpleIteration, 
-        edge_length::Float64
-    )
-    
+    io_buffer::IOBuffer,
+    model_graph::GraphPPL.Model,
+    global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
+    ::SimpleIteration,
+    edge_length::Float64
+)
     for edge in MetaGraphsNext.edges(model_graph.graph)
-        
         source_vertex = MetaGraphsNext.label_for(model_graph.graph, edge.src)
         dest_vertex = MetaGraphsNext.label_for(model_graph.graph, edge.dst)
-        
+
         # we use the sanitized names of the vertices in the final visualization
         source_san_name = get_sanitized_node_name(global_namespace_dict[source_vertex.global_counter])
         dest_san_name = get_sanitized_node_name(global_namespace_dict[dest_vertex.global_counter])
-        
+
         write(io_buffer, "    \"$(source_san_name)\" -- \"$(dest_san_name)\" [len=$(edge_length)];\n")
     end
 end
@@ -550,26 +535,25 @@ length of these edges in the final graph.
    the visualization.
 """
 function add_edges!(
-        io_buffer::IOBuffer, 
-        model_graph::GraphPPL.Model, 
-        global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
-        ::BFSTraversal, 
-        edge_length::Float64
-    )
-    
+    io_buffer::IOBuffer,
+    model_graph::GraphPPL.Model,
+    global_namespace_dict::Dict{Int64, Dict{Symbol, Any}},
+    ::BFSTraversal,
+    edge_length::Float64
+)
     edge_set = Set{Tuple{Int, Int}}()
-    
+
     n = nv(model_graph)
     visited = falses(n)
     cur_level = Vector{Int}()
     next_level = Vector{Int}()
-    
+
     s = 1
     if !visited[s]
         visited[s] = true
         push!(cur_level, s)
     end
-    
+
     while !isempty(cur_level)
         for v in cur_level
             for v_neighb in MetaGraphsNext.neighbors(model_graph.graph, v)
@@ -577,19 +561,15 @@ function add_edges!(
                 if !(edge in edge_set)
                     source_vertex = MetaGraphsNext.label_for(model_graph.graph, v)
                     dest_vertex = MetaGraphsNext.label_for(model_graph.graph, v_neighb)
-                    
-                    source_san_name = get_sanitized_node_name(
-                        global_namespace_dict[source_vertex.global_counter]
-                    )
-
-                    dest_san_name = get_sanitized_node_name(
-                        global_namespace_dict[dest_vertex.global_counter]
-                    )
-                    
+
+                    source_san_name = get_sanitized_node_name(global_namespace_dict[source_vertex.global_counter])
+
+                    dest_san_name = get_sanitized_node_name(global_namespace_dict[dest_vertex.global_counter])
+
                     write(io_buffer, "    \"$(source_san_name)\" -- \"$(dest_san_name)\" [len=$(edge_length)];\n")
                     push!(edge_set, edge)
                 end
-                
+
                 if !visited[v_neighb]
                     visited[v_neighb] = true
                     push!(next_level, v_neighb)
@@ -623,38 +603,38 @@ The DOT string includes configuration options for node appearance, edge length,
 - `String`: A DOT format string that can be used to generate a GraphViz visualization.
 """
 function generate_dot(;
-        model_graph::GraphPPL.Model, 
-        strategy::TraversalStrategy,
-        font_size::Int, 
-        edge_length::Float64 = 1.0, 
-        layout::String = "neato", 
-        overlap::Bool,
-        width::Float64 = 10.0, 
-        height::Float64 = 10.0
-    )
-    
+    model_graph::GraphPPL.Model,
+    strategy::TraversalStrategy,
+    font_size::Int,
+    edge_length::Float64 = 1.0,
+    layout::String = "neato",
+    overlap::Bool,
+    width::Float64 = 10.0,
+    height::Float64 = 10.0
+)
+
     # get the entire namespace dict
     global_namespace_dict = get_namespace_variables_dict(model_graph)
-    
+
     # use Base.IOBuffer instead of string concatenation
     io_buffer = IOBuffer()
-    
+
     write(io_buffer, "dot\"\"\"\ngraph G {\n")
     write(io_buffer, "    layout=$(layout);\n")
     write(io_buffer, "    overlap =$(string(overlap));\n") # control if allowing node overlaps
     write(io_buffer, "    size=\"$(width),$(height)!\";\n")
     write(io_buffer, "    node [shape=circle, fontsize=$(font_size)];\n")
-    
+
     # Nodes
     add_nodes!(io_buffer, model_graph, global_namespace_dict, strategy)
-    
+
     # Edges
     add_edges!(io_buffer, model_graph, global_namespace_dict, strategy, edge_length)
-    
+
     write(io_buffer, "}\n\"\"\"")
-    
+
     final_dot = String(take!(io_buffer))
-    
+
     return final_dot
 end
 

From 36c125ba560330e0dc2dd55429982416f0a4d2d1 Mon Sep 17 00:00:00 2001
From: Chris Bennett <chrisbennett@Chriss-MacBook-Air.local>
Date: Mon, 9 Sep 2024 20:58:08 -0600
Subject: [PATCH 08/10] Changed Name of module to GraphPPLGraphVizExt

---
 ...isualization.jl => GraphPPLGraphVizExt.jl} |  2 +-
 test/visualization_tests_233.jl               | 32 +++++++++----------
 2 files changed, 17 insertions(+), 17 deletions(-)
 rename ext/{GraphvizVisualization.jl => GraphPPLGraphVizExt.jl} (99%)

diff --git a/ext/GraphvizVisualization.jl b/ext/GraphPPLGraphVizExt.jl
similarity index 99%
rename from ext/GraphvizVisualization.jl
rename to ext/GraphPPLGraphVizExt.jl
index f7eb420..4d939f3 100644
--- a/ext/GraphvizVisualization.jl
+++ b/ext/GraphPPLGraphVizExt.jl
@@ -1,4 +1,4 @@
-module GraphvizVisualization
+module GraphPPLGraphVizExt
 
 export generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
 
diff --git a/test/visualization_tests_233.jl b/test/visualization_tests_233.jl
index e44004c..7170545 100644
--- a/test/visualization_tests_233.jl
+++ b/test/visualization_tests_233.jl
@@ -14,9 +14,9 @@ using Compose
 
 using GraphPlot
 
-include("../ext/GraphvizVisualization.jl")  # Include your module
+include("../ext/GraphPPLGraphVizExt.jl")  # Include your module
 
-using .GraphvizVisualization: generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
+using .GraphPPLGraphVizExt: generate_dot, show_gv, dot_string_to_pdf, SimpleIteration, BFSTraversal
 
 ## CREATE AN RXINFER.JL MODEL:
 # GraphPPL.jl export `@model` macro for model specification
@@ -46,7 +46,7 @@ meta_graph = gppl_model.graph
 
 
 
-@testset "GraphvizVisualization Tests" begin
+@testset "GraphPPLGraphVizExt Tests" begin
 
     @testset "generate_dot/show_gv Function" begin
 
@@ -80,7 +80,7 @@ meta_graph = gppl_model.graph
 
         for (vindex, vlabel) in enumerate(vertex_labels)
             vcode = code_for(meta_graph, vlabel)
-            vprops = GraphvizVisualization.get_node_properties(gppl_model, vcode)
+            vprops = GraphPPLGraphVizExt.get_node_properties(gppl_model, vcode)
 
             @test typeof(vprops) == Dict{Symbol, Any}
         end
@@ -88,14 +88,14 @@ meta_graph = gppl_model.graph
     end
 
     @testset "get_namespace_variables_dict Function" begin
-        gppl_model_namespace_dict = GraphvizVisualization.get_namespace_variables_dict(gppl_model)
+        gppl_model_namespace_dict = GraphPPLGraphVizExt.get_namespace_variables_dict(gppl_model)
 
         @test length(gppl_model_namespace_dict) == nv(meta_graph)
     end
 
     @testset "get_sanitized_variable_node_name Function" begin
 
-        model_namespace_dict = GraphvizVisualization.get_namespace_variables_dict(gppl_model)
+        model_namespace_dict = GraphPPLGraphVizExt.get_namespace_variables_dict(gppl_model)
 
         # match any string - including those with Greek letters - followed by an underscore 
         # and then an integer (excluding 0) followed by a colon and then terminated with 
@@ -104,7 +104,7 @@ meta_graph = gppl_model.graph
 
         for (key, val) in model_namespace_dict
             if haskey(val, :name)
-                san_node_name_str = GraphvizVisualization.get_sanitized_variable_node_name(val)
+                san_node_name_str = GraphPPLGraphVizExt.get_sanitized_variable_node_name(val)
                 # println("VAR: $(san_node_name_str)")
                 @test occursin(var_regex, san_node_name_str)
             end
@@ -113,7 +113,7 @@ meta_graph = gppl_model.graph
 
     @testset "get_sanitized_factor_node_name Function" begin
 
-        model_namespace_dict = GraphvizVisualization.get_namespace_variables_dict(gppl_model)
+        model_namespace_dict = GraphPPLGraphVizExt.get_namespace_variables_dict(gppl_model)
 
         # match any string - including those with Greek letters - followed by an underscore 
         # and then an integer (excluding 0) followed by a colon and then terminated with 
@@ -122,7 +122,7 @@ meta_graph = gppl_model.graph
 
         for (key, val) in model_namespace_dict
             if haskey(val, :fform)
-                san_node_name_str = GraphvizVisualization.get_sanitized_factor_node_name(val)
+                san_node_name_str = GraphPPLGraphVizExt.get_sanitized_factor_node_name(val)
                 # println("VAR: $(san_node_name_str)")
                 @test san_node_name_str == string(val[:label])
                 @test occursin(fac_regex, san_node_name_str)
@@ -132,23 +132,23 @@ meta_graph = gppl_model.graph
 
     @testset "get_sanitized_node_name Function" begin
 
-        model_namespace_dict = GraphvizVisualization.get_namespace_variables_dict(gppl_model)
+        model_namespace_dict = GraphPPLGraphVizExt.get_namespace_variables_dict(gppl_model)
 
         fac_regex = r"^[a-zA-Z_α-ωΑ-Ω]+_[1-9]\d*$"
         var_regex = r"^[a-zA-Z_α-ωΑ-Ω]+_\d{1,}:(nothing|-?\d+\.?\d*([eE][+-]?\d+)?)$"
 
         for (key, val) in model_namespace_dict
-            san_node_name_str = GraphvizVisualization.get_sanitized_node_name(val)
+            san_node_name_str = GraphPPLGraphVizExt.get_sanitized_node_name(val)
 
             if haskey(val, :fform)
-                san_node_name_str = GraphvizVisualization.get_sanitized_factor_node_name(val)
+                san_node_name_str = GraphPPLGraphVizExt.get_sanitized_factor_node_name(val)
                 # println("VAR: $(san_node_name_str)")
                 @test san_node_name_str == string(val[:label])
                 @test occursin(fac_regex, san_node_name_str)
             end
 
             if haskey(val, :name)
-                san_node_name_str = GraphvizVisualization.get_sanitized_variable_node_name(val)
+                san_node_name_str = GraphPPLGraphVizExt.get_sanitized_variable_node_name(val)
                 # println("VAR: $(san_node_name_str)")
                 @test occursin(var_regex, san_node_name_str)
             end
@@ -158,7 +158,7 @@ meta_graph = gppl_model.graph
 
     @testset "strip_dot_wrappers Function" begin
 
-        model_namespace_dict = GraphvizVisualization.get_namespace_variables_dict(gppl_model)
+        model_namespace_dict = GraphPPLGraphVizExt.get_namespace_variables_dict(gppl_model)
 
         gen_dot_result = generate_dot(
             model_graph = gppl_model,
@@ -171,7 +171,7 @@ meta_graph = gppl_model.graph
             height = 10.0 
         )
 
-        gen_dot_result_stripped = GraphvizVisualization.strip_dot_wrappers(gen_dot_result)
+        gen_dot_result_stripped = GraphPPLGraphVizExt.strip_dot_wrappers(gen_dot_result)
 
         @test !occursin(r"^dot\"\"\"\n" , gen_dot_result_stripped)
         @test !occursin(r"\n\"\"\"$", gen_dot_result_stripped)
@@ -191,7 +191,7 @@ meta_graph = gppl_model.graph
             height = 10.0 
         )
 
-        success = GraphvizVisualization.write_to_dot_file(gen_dot_result, "test_output.txt")
+        success = GraphPPLGraphVizExt.write_to_dot_file(gen_dot_result, "test_output.txt")
 
         if success
             if isfile("test_output.txt")

From 37e42e176c0365475ca58c589a506cff470bcbc1 Mon Sep 17 00:00:00 2001
From: Wouter Nuijten <wouternuijten@gmail.com>
Date: Fri, 27 Sep 2024 12:55:03 +0200
Subject: [PATCH 09/10] Change name of extension in Project.toml

---
 Project.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Project.toml b/Project.toml
index dd14e18..c814eb7 100644
--- a/Project.toml
+++ b/Project.toml
@@ -24,7 +24,7 @@ GraphViz = "f526b714-d49f-11e8-06ff-31ed36ee7ee0"
 [extensions]
 GraphPPLDistributionsExt = "Distributions"
 GraphPPLPlottingExt = ["Cairo", "GraphPlot"]
-GraphvizVisualization = "GraphViz"
+GraphPPLGraphVizExt = "GraphViz"
 
 [compat]
 BitSetTuples = "1.1"

From 71aa0289ee28c4df0665b420ab002511fd4c4b02 Mon Sep 17 00:00:00 2001
From: FraserP <fraserp@pop-os.localdomain>
Date: Mon, 30 Sep 2024 22:24:20 +0800
Subject: [PATCH 10/10] wrapped abstract types arround symbolic expressions to
 keep the types exclusive to the extension.

---
 ext/GraphPPLGraphVizExt.jl               | 124 ++++++++++++++++++++++-
 test/test_imgs/coin_model_bfs_itr.pdf    | Bin 0 -> 25798 bytes
 test/test_imgs/coin_model_simple_itr.pdf | Bin 0 -> 25795 bytes
 test/visualization_tests_233.jl          |   7 +-
 test/visualization_tests_233_v2.jl       |  74 ++++++++++++++
 5 files changed, 200 insertions(+), 5 deletions(-)
 create mode 100644 test/test_imgs/coin_model_bfs_itr.pdf
 create mode 100644 test/test_imgs/coin_model_simple_itr.pdf
 create mode 100644 test/visualization_tests_233_v2.jl

diff --git a/ext/GraphPPLGraphVizExt.jl b/ext/GraphPPLGraphVizExt.jl
index f847868..18f486a 100644
--- a/ext/GraphPPLGraphVizExt.jl
+++ b/ext/GraphPPLGraphVizExt.jl
@@ -582,6 +582,20 @@ function add_edges!(
     end
 end
 
+"""
+A 'wrapper' arround a user-specified Symbolic expression which returns 
+the associated traversal type. 
+"""
+function convert_strategy(strategy::Symbol)
+    if strategy == :simple
+        return SimpleIteration()
+    elseif strategy == :bfs
+        return BFSTraversal()
+    else
+        error("Unknown traversal strategy: $strategy")
+    end
+end
+
 """
 Constructs a DOT string from an input `GraphPPL.Model` for visualization with GraphViz.jl. 
 The DOT string includes configuration options for node appearance, edge length, layout, and more.
@@ -604,7 +618,7 @@ The DOT string includes configuration options for node appearance, edge length,
 """
 function generate_dot(;
     model_graph::GraphPPL.Model,
-    strategy::TraversalStrategy,
+    strategy::Symbol,
     font_size::Int,
     edge_length::Float64 = 1.0,
     layout::String = "neato",
@@ -612,7 +626,55 @@ function generate_dot(;
     width::Float64 = 10.0,
     height::Float64 = 10.0
 )
+    # convert user-specified symbolic expression to the associated type for eventual dispatch 
+    traversal_strategy = convert_strategy(strategy)
+
+    # dispatch on the type of traversal strategy
+    _generate_dot(
+        model_graph = model_graph,
+        strategy = traversal_strategy,
+        font_size = font_size,
+        edge_length = edge_length,
+        layout = layout,
+        overlap = overlap,
+        width = width,
+        height = height
+    )
+
+end
+
+
+
+"""
+# Constructs a DOT string from an input `GraphPPL.Model` for visualization with GraphViz.jl. 
+# The DOT string includes configuration options for node appearance, edge length, layout, and more.
+
+# # Arguments:
+# - `model_graph::GraphPPL.Model`: The `GraphPPL.Model` structure containing the raw factor 
+#    graph to be visualized.
+# - `strategy::TraversalStrategy`: Specifies the traversal strategy for graph traversal.
+     Either `SimpleIteration()` or `BFSTraversal()`
+# - `font_size::Int`: The font size of the node labels.
+# - `edge_length::Float64` (default is `1.0`): Controls the visual length of edges in the graph.
+# - `layout::String` (default is `"neato"`): The layout engine to be used by GraphViz for 
+#    arranging the nodes.
+# - `overlap::Bool`: Controls whether node overlap is allowed in the visualization.
+# - `width::Float64` (default is `10.0`): The width of the display window in inches.
+# - `height::Float64` (default is `10.0`): The height of the display window in inches.
 
+# # Returns:
+# - `String`: A DOT format string that can be used to generate a GraphViz visualization.
+# """
+function _generate_dot(;
+    model_graph::GraphPPL.Model,
+    strategy::TraversalStrategy,
+    font_size::Int,
+    edge_length::Float64 = 1.0,
+    layout::String = "neato",
+    overlap::Bool,
+    width::Float64 = 10.0,
+    height::Float64 = 10.0
+)
     # get the entire namespace dict
     global_namespace_dict = get_namespace_variables_dict(model_graph)
 
@@ -638,6 +700,64 @@ function generate_dot(;
     return final_dot
 end
 
+
+# # OG VERSION
+# """
+# Constructs a DOT string from an input `GraphPPL.Model` for visualization with GraphViz.jl. 
+# The DOT string includes configuration options for node appearance, edge length, layout, and more.
+
+# # Arguments:
+# - `model_graph::GraphPPL.Model`: The `GraphPPL.Model` structure containing the raw factor 
+#    graph to be visualized.
+# - `strategy::TraversalStrategy`: Specifies the traversal strategy for graph traversal. 
+#    Either `SimpleIteration()` or `BFSTraversal()`.
+# - `font_size::Int`: The font size of the node labels.
+# - `edge_length::Float64` (default is `1.0`): Controls the visual length of edges in the graph.
+# - `layout::String` (default is `"neato"`): The layout engine to be used by GraphViz for 
+#    arranging the nodes.
+# - `overlap::Bool`: Controls whether node overlap is allowed in the visualization.
+# - `width::Float64` (default is `10.0`): The width of the display window in inches.
+# - `height::Float64` (default is `10.0`): The height of the display window in inches.
+
+# # Returns:
+# - `String`: A DOT format string that can be used to generate a GraphViz visualization.
+# """
+# function generate_dot(;
+#     model_graph::GraphPPL.Model,
+#     strategy::TraversalStrategy,
+#     font_size::Int,
+#     edge_length::Float64 = 1.0,
+#     layout::String = "neato",
+#     overlap::Bool,
+#     width::Float64 = 10.0,
+#     height::Float64 = 10.0
+# )
+
+#     # get the entire namespace dict
+#     global_namespace_dict = get_namespace_variables_dict(model_graph)
+
+#     # use Base.IOBuffer instead of string concatenation
+#     io_buffer = IOBuffer()
+
+#     write(io_buffer, "dot\"\"\"\ngraph G {\n")
+#     write(io_buffer, "    layout=$(layout);\n")
+#     write(io_buffer, "    overlap =$(string(overlap));\n") # control if allowing node overlaps
+#     write(io_buffer, "    size=\"$(width),$(height)!\";\n")
+#     write(io_buffer, "    node [shape=circle, fontsize=$(font_size)];\n")
+
+#     # Nodes
+#     add_nodes!(io_buffer, model_graph, global_namespace_dict, strategy)
+
+#     # Edges
+#     add_edges!(io_buffer, model_graph, global_namespace_dict, strategy, edge_length)
+
+#     write(io_buffer, "}\n\"\"\"")
+
+#     final_dot = String(take!(io_buffer))
+
+#     return final_dot
+# end
+
 """
     show_gv(dot_code_graph::String)
 
@@ -664,4 +784,4 @@ function show_gv(dot_code_graph::String)
     end
 end
 
-end
+end
\ No newline at end of file
diff --git a/test/test_imgs/coin_model_bfs_itr.pdf b/test/test_imgs/coin_model_bfs_itr.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..844b6f9ab278af48eb6b4d8b402508f6f3eac9e5
GIT binary patch
literal 25798
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
Z*BfUSh?C33Ort7=Lf5x$$*Rc_{1<d5W?29L

literal 0
HcmV?d00001

diff --git a/test/test_imgs/coin_model_simple_itr.pdf b/test/test_imgs/coin_model_simple_itr.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..497e012fa6fd044b2ae89afa22c64b35571f2fe6
GIT binary patch
literal 25795
zcmZs>b98U9^EO)Bc0aXko2Pb9-JaUEZQHi(_SCj*+rH=f!@J&l*WD{C+4Jm4W|BXi
z*-3^>K~$WMiJlFHtof?u1BMmA2(UG@fZ^o@Fvu9&m^zsO*#1FEFaQ96LEPNR$=Kmv
zYh~bMENX0I`^OlDpC882$-&sb8pbWFSbfX}j{~XuMg5l35ozjo8@LbxNB|IogIz(U
z0hI8Dnw2Ost*OvAf9)#i$gD{;oX|prQlrL`uC)mL?n%&XJWc15#amZU$;TDu%RX`2
z1Ou#ljHbqB@9WC1PakdFUi*H?7nl59ALm^BW|9pGtFk|}<=n>i6>~c6<>C9`4a&s1
zG&$|B+7*c?y!P4m=c17-X{iG=lWxQ2hT~re&K5-~xsC+nS)@;B`^>gyFnHKLa8tLA
zX>Isp=RU5r+`=5G*N;~Dry^ryr7?$SVnd}xL`-rL3>9dD**bI#+qqx>x$DcXdm|`+
zAMTGfs(})(?u}f=tLd{)zSOO!(%#Fvkx;&qt*4{!skMotlSZ=FznUbBy$_IhnRwfK
zA?Wc%ry7N^89Ih~^In@>j-~SOaU^e}P>q}rb>Prw7jSmN4(kE#tuvh%BSZXG)6U{|
zdAT4z7C=#Jbs{j(fhd3S{eCF(!f5r&A`#c@WpzQgpob*(g%(+a<`cY8gtV79osxeW
zK8-K|%!7-iE#f7costS-{hb<5fTn-G7y2v+2`>+Ly>Xe7cgcu<D%}hQWE6q1PbHBF
zkyw?mZGk$YNc{*gDEgAY;>TYC$klB2i3>_ccR(|6!jsB7!v0oCzuirGKsDWi%}Odl
zf|xmY>NZ<c!!f|DOAYxVsnd#+p)i85R`(Q8h-Ou>c~e;6#Z3cbqgka9QUS#y2W1|l
ztayK^928N{nF>^L0&#*Vl1lv(fFYDZleN4}W~z%D5v%!|`-?`q3&4}9a#(h&Zm|Sy
z>$cdU?oFD|V0H^z{u1J-0{);g=o*AI5Ic#-lixBAp+`dxNSSeU_4l*9-_|i6`HXP0
zt-WKx!(t(B?4GJy8D_F(!s;;bUY6R1+6~SECGlIraEkq5`<<}4K(EF+C%>Zij8<KK
zyd{7cIPGX70*dC9De_19S387q6Vp^XyI&cG<yBlG1vmjEv>_Zk>w&eChQC1Ht|&fL
zLO}8Gq6UM&ECASk1zH(%1>t}h4gb)`O>*m%8{OXu3?2bWQ<8Mxl^Ok_%cqCA>jJ~(
z!xzjOx>?(>IUI_(nS99!&2xTrLf&9zQ-VggW<AG%(g+L%23~nJP<41*iFy!?0|7Wm
zg?E8{fk2-DmNLeqr75D#K{?PM%q30asaU@Ra0#}H`pi<oeY8a8L|BC}v4_sCv|q<K
z<TK<k%P6;O02BqLS5Es7Q)9-};LgOlFgEq~iZW&oi8J4M{n|fKka^H<=JxG|m%k&2
zZ&XV-SJWRgYW4jn`B&Ma1r4^iV8j@a-i8TkT_TY@Nd$AqJVwqySGy%<B{eiVSEEvO
zMkx8ldwS7UpwAUE2FJy$$tuKVocd(6p>q$O?jGG(NH|gKujN1p4e;p!F!~W;4EOX_
zr{ManFRY9+cMf}=1d`DKuoq&hZk{EzH$8?ez4+8zi5z$}8uE!*iwR*-xFIENFwY3!
z6t4!_f^}wY6n5IjLNq&lAOAM3NvsHHJqr|z)|B~*cFQ_}{4Qu!%ag{nMuLdrKMPKy
zW|nP4Yjrr(mxt&Bg}7Ksz53ZOmop}|Jn#Z*6s++!zUdLp9gKR|1TL_x!khtY4bvM5
z5b$WK_&}?CSxYDO;${R9HxA-btK7xWj!wZr5z?>xW;G+)NZ8FFhk4OQ8fz&t1ml%Q
zzDK<XJ}|~MfBuII|GoW(M*qW||7riRClfO#^M4fnBeMJ-mi;eY6?1cvP<HyqsQ_Ny
z{{a6U1_Q=_0)Rn82*3njFf#a8|6|&JAO5>$5Vy5)`oFYI=osmk0PO$E)c+aaKM*5;
z<A0%l{r;8zvCsT}>;o87-0h433<?IO#sD$^(|`G+VBlc<Z+NEv?aLr*{Kwot*wzi8
z^$+?tC<h0CgNqrU^IzH`|6KW}?g;o#?D+3MA>m-_Z1;b;_un@D3;o~uDgU$VU|{2D
z_a9qE?*9u*0h}D1jsI5?`KKjn>|$<YtRx})AMk%>uVn0K>+E1;><IYJN-F(dGvoXx
z|9|2a*Z*<r|1W<1XQ}=>&@lm+nHZUv|6dVptIOR>W$BI4XS)4mx<}q5cXD%$C4G#W
zMT#8mFoaeRgcL>?WEjpsf>ufc3=Eo@IFj61f-YQjbC#Jj0J!y3-MYF(AG2~9rlqY}
zcA{0R6Kd>+%N6AB$JxhM_sz}Bj&{yN)>V$<wPViHCN7dV6qN#^AyV&ah*);7x5E!_
zko0#rl4hOT0QdJzBma7gf)~B;JV%N%eQ&<kSE3kHaTS!kWoqqqQ&r`Y`Y-(;)4iN@
zniTrq_X`h&3rH2)u+GLbd4I9g@PqGh6`pI`47P@EzI31Ql6r&ghnFld7=#ZoL7`-2
zMcgOgBiUV~TQ2mg$_Yi%Z!UG$-y)6U9ToUv<CY_!bZ8+ltJES)@X24r?qL!DRPN45
z_Lq$ANA3_*MXZisB$+aQyJ4=tm^h;jUp>6=8^oP<is*|>E~bl3bR_esM=z#Dl$0*#
zJRgB284c&$bFjG>>`t`?8%Y?+2!1X!_$;wJ!<5djh-D-dNazB`IRjD~7fJ@o^h)(5
zRoH$jMe#u+TE0HJR@qh&jE2l<YSaX2`A?n#6G_ySRD&)rs9|V=)2#W~NQf$157OAP
zRoMZ#8&tD01a=|Xd{fNtCy&ChLH)?i>Q|?XLLVP8qZ`cHe<Ggpi!hq8{uaumT(((w
zHivAgS~lU5`+SAtrQ<czB4zu<;UO-O+d^H;L0Zor-b26_+Z!V)9ifPOZNUOz_>R}O
zW_V9p5*Nfz00ZHzd#1U$%T!W>PjUv+D2!7FS<)cj^SF_{g-(wG6}Oo%b$H<U;GT-B
z0d71zv&&B&m^2ztLSSMwzzI04NKJiOgRl}M29!%PQZ@&KBOl)JFZhM0>HY=&Bi8GO
zU+g*WVxz(VbBGGPiqT(eq8u}L0#CkgJUnr~s;r@-1BFCakt5BNh#U!o8KvCVUY>MJ
zo%be?CPEovENm=1DnE*1?yRM0U%(YF=S2RFq757g&a?wsEF+vCl_e7=15%oANZNlm
zK53BZk_P<OW56J_x1R>KlNG*avu=W8(kw_=Pl~d)V^vk@LbPW-ZIOUXsduJy$pQ_d
zQE#1M02_OGoZI-T0hL*eT}BrJZ%?B}U<cm@p>!bIpoL-+b2<ncZ8=!V&CN?R?j-GC
z&*?MVItdWpQe!ioh1r1hEC-2+L|H6PPT>-Jtv5y9uiwms!me*bD>o@sm9-U4qLCUQ
z+G0Cmt#ga`+{S~_Z(Og`IAk?{qA_`lW#wGeRMiFNl6n1fl-v}t91Oy=`Fgq)UFqH^
zuF33dm7o|#wR*0}VWVInjWa@iw3uqP<zgxs=}7$N@oCt-oX#loxYJs$R{(91eGj+Q
zWs5mw!(`g|^=lzzw;i%%qxoA7iDEak<BnyLX_b&}e27jsJAWi7mz9vMH+(0hH~u4E
z+wfJ`zjWea@<Ep8R`-qmDionyi&D1k8fSILhr?&$u_YVIhF7En7En$GP{z@a9tacC
zTms{n*iU4&Hd(Nu*cdU<fc`KY4^R!L&=XT(tH}^o<m@166yNY0j31WS&Kj0^P=!UP
z)Mi2GT*FppFmuN)AC^FZ-6bF_FDo;vHg|_!OIMmj;*vR2@2JH~MfdmBqQJs>E`mG3
z0m%SBa|TBEk(R9--`*Cv5M&<3HA)kis$95T>I0al=y)6K<7WAW;(zsCwc!q|6W4{e
zm59yOQe2Q_qGz&Y!sAX|R9|E_v@EkPsySLm0$k4@r6B#x-99f3j1yuOBYx4TI0?E4
ztGJER>V^*{8Rcog5zEbvW!CQ48E%A6O|<s#P}qMhersWDbvfWTn*B_RaAe<b)t$6w
z{x};sFMZPqV1NAC?VY}oRc;^0{;^Fk)DuB?{AMa5_)#iTBipd&AyRGsc>J)c&Cq2-
z+~{eN`f$9X=dn>@E8kGPI<KwnOC`4)9Z!>0%gpX)9kYkiA6A(}Fbdrrlwl&$D3Bg4
z_+9)Kbe42hOFrDhI&w#^gm54LtEd~S8Z6eHuALCcXreityI?iQCmt2WZ8Xej$ZO7P
zorJY89oQ-Aosdl6(VT4=*bU4FCG4~ZH;SB;cLuktl>pTj2S&FFZc*0>?<`TrZ*uR?
zT=W;Yum~0c)kCiUPP7=0qwB|qc7{ca@cwBLqvg=I*UQ?UY_f;_dEy;bz#<!E`a%QG
zQcp(BZIY%GGF7S5e=#rgdwMH)e6}~Z0A^Ms0;VFg3D~->w4gR%N+n7qt4g03Wm7x8
z=Cnvv82s3Hx$al4DnGb^dRc!ZRHqX>zx*otBz3N6SsnMa^r9iZN{E6@QgXob@`W=@
z<`Tn=@@^D}C3<#*&k!_tW!^Z2f*<d<u&a=xP)A;)-xbv<4ImvP3dRYX1e^kPHNeST
z?XKzT-;N5eGci#LBqlGhk*i+CB=uNVg-_+h$vJS}`~oCqIrYod8Ikhe1_6igx7Kf6
zm-OfU#^p^VzRm@MMaqcadMfgKmHsx%$X{w~X$en8$%)=vYO?|*#PIBPt~#fy+8j5(
z_tNWAj~~<&LC;JM)<0@#A~>SCYH6H4zQo0bcunpROE#Q)<P;%`0r7vgDf`dA)#{$!
z?ALeBZXOU{XWqHCcP=SFWIyxNL!^Hl5Z9DV?g#ACK7)(WqOD)rud)~gs^hz0>z4|*
zSZp7atFEaG^FybQBHvdOi3b+Q#~evP*kD&lDUg~~qD($fC$E=0YXwWrOJ7_XC*SeY
z*tG07H7~3~A`EEKnBqUe^RxGF#E(*Lr8xR^iZ$x8t;472xQ<nsCPOI@s{Ei2KcbY2
zNr%!WaAygaEBW|X%ulr>oY!Y$2#0E)H}E{La)x$BvKQSyP(-`a-##P=YI&aHbe;B4
z+7_N?2_=r4r|$&N=LVVNsokgBMfPug3fk#mgHATbS&i;6hUR%m<sY8&@oK4VH`&R)
zz3ZR+)on@bTyn^4=BW1^uXgT^ZspiAZJ+6=HBaLk=CgI*es}r28jcU9z|7HgbIBi=
z&NS>0l}q;|dMT>PuNwEClu0k`_qSq$=$5NgtW1Jw-!z+ypYQ-#Mat7kEUYNdPzYGQ
zLBxaU!qEpAaO=%84}Wy4%inPveW(b%lW{_4dVHLv59xu}1PEG#vSGtdadDbrO~j0&
zBzUv6nWRx6tF%Cf#lv%KcvuZSGrxgz<~x{RNDCzj6F2Jw*G7mpH|iQhC^9(+Wr#MW
z8TMDu3|mHcMt(%5?~69Xoux;fKy12m#@4W`7{<OF@0D~-cg1%lx?62~_!!&?8|(og
z`D;mfrX^Rr3d`PnJ+<`&aTry%FL?c(Oe=T8eNo-3NH8o(Cz^s2kBT8m>I|`Jw~vVZ
zn>{%W4jX$AJsOA}DkLG^6RtpL)PxJ>-SiPfKMx*-enxOLpUt(hEXzjzG}2K??^T0q
zeNizV?Q$^<+$UQI#6~xhdz*D1*Rp)=SZEy&MF%MdZkApF+uff4<|7laO|Jh+VG%VI
z{Xlc^32j<46w$7q*F>s@!eBtU)L)`+01)70U|b2$PSloLOiLRoEN_dDNNlI3u%J&n
z5>=NtzHeLpeKWWcbj)+t_12z@aC)5<WRk*q+g4AcNFIkn&~%N)el*w^S>sT^wO8q;
zVp?ubJl7InQ83Y&rfp+M67Qw(`!Td1Nx{>vquf{(?c5I%g<GT{E<<e~$Q)kDJR<pb
zg9n`iOv&F=^hPAM1_ddGdNNC&iE?n{o4>lJ`b_d^2DI&6U`K<S-~za9Y+oLtpo*Y{
z(VH4~!~W~$imj!qYi|!@)|P5~_g9uYILYrpO?(7WhROp8>uwK|F&(R`0+A6ksa>C+
z{TiS7@^_cFeATX9M0P0cLp8gk3p}1N$6$$E9=hYqS=w9f&MW(!C#fl#)&Ax8L)R#+
zH{1=51IJ$vr7pJDdW=t>&l<n-Rt1bV9^2L?rIDiBx}fTF9a-XG#T3BJ(IYVPz-x3)
z5mste`9BbaXV!D!y^Vj2P9up`!PoKD(LBqX^e+8=(pMp$5rqj4saD4g?uX)B+%?IJ
zWlA~Z>Te+v$p}z+6(y}|+{$++0te%9YoAsiT-F2zZ$1PfyfNY$eDD-f&#@8*4QA}q
zzm9p8?G4Pcdx`i7TURlHt|>h5=T&tBF<%#wvy=IfL6ez1>${t<MTIP0I`6H-s)88l
zBP*#~LVt*ULYb)as8rb1>B%G0SyNMriqH1p6Pll!W8_x2f7WM@yEaH$d2C#thCQf#
ze?KbD<$nG=Z~Qj?-70c@cfN_xID+{=5)xe?I(TK;wHIL)MfG@0hT`DJIb+C__?I_b
zhW-L}AF%YC42>*XTxMEU!7Udl!uCXr;gIKJ(uqo=JtVi^6%yS>Q$W@vq@KzMbqVwf
ziL_Kx+{ppm!W*wX&6J5#{suqV!+HH{Y&`YWb2JdcfCfw@ehq0SCg4wC*h&+g2$@X3
zIs$TZ3&>7spOaryq_+H3s7(?Gl*L>bWgC!+4c!>Dh@KAG%aNvzhK1`Yo+vT&J18j<
z?6GDblQt<`xIr!rmeGD2>2MHWynjgB01n)to9U3+7=<YcdGz<W!w$P18f%zbM`x#^
z>k8QjroTYs6sir4GwOJw$@s}HH)%2V1h7dJ4Z+`oZDcf@nj8VxU5!49Gvzb%kApSP
z8V(|jhDCdKLoYWw4tphnp7+<DCcQphQV$(9B(;;C-LBG+fxI^v9#=8NBQ?-TZyo7N
z9G(Thl|R9_seBd5(v>#p&IiiJwkw<j8>>z)+9`$Ke`Ufnj|HPL10AHI^;w#<HmuB(
zrrmS*th!jtff-?^i?lWiGD6y9;MC0QDH#~()fgrjqIgKz-6QX~9XpNvo%3}fu-ipp
z?s!czh}OiOrClmqE?f@z#SwnTV)=^kFZvYmNPJIY!AnN`;Vzehh@!qodX{t@(@Xpo
z^;D}ctXJ{IH8>m@ktZ2@HP0`R(UmV5%iMGv({_hEBkzprwEBpOogh?)n}``@i6Bg5
z7&Tww5{tPkLL)hoqS`C=o(DD;AD3=z;3`|SDzIe3NeFRSU{@C4Jg6Ewd?hn(y-N(_
zk`mNIz@d5<OtX<}Ad^07M!1AJEuMEZKIWBBvK+RY+?edv&ze3ud>pl_uaXy!Fz#+p
zW)`PF{c{V|5OvukL+mMTWH?8kcg={34mX4&v`}RbCtkY8HmM1}9Olo2r0hubC(_B;
zb*5vM%%jZOua8@d+zS2Z)W*93YI0#02i3+hT0#C9FRh)FPfZXVU8O#-IsqUfsZQfu
zG?-g<9!o^!jOitntPrOHI$Ab(OjfK(nm-y($JJnsN+#A)G@5c~C^b8pNS;k+e()s4
z22}7FP0ztmEgoL>JVD1g2?*x|Gci%_Lq*GG9+PkzOUQ<GL2Hv0@V@QK{r)%=vDH}(
z&)s)w88UXXAxqrWX|=f<&eF*>{M^f}d(1Ya*7`*M>oQlH&BQ-`3F2FYCQH5oWtlX+
z#blVK90K3Pv!?u%^jQ|bBnqcBx4e2~7V97{oM6eQeqP~Gq0#P0&Y`R{vf^&42BX^P
zU<?zTB(aU%rpP41MKY(MtITC|?{(yGgz#n^v5~aieylY$sI#OiHs631Q3^8veur5P
zT5h)MrIMp^M3qQAmtQS&sxn1QESR9i)D^~FrlC46olaRL!>+keZCND~@0^*eVe4{H
zN57kZQ5u9MCAKylkOQI=2PF|1n(iSqLk%kdV<*JzXK0a3O%U51mP#T3qaaoxRp7@n
zi+T!MC%kLr=f{KP7Qg8Cn5J*Li9~pC6fmKfL>mv2LCRnap$LNNKO=45i1y2}WYLSk
z(*i;pBc08|hLu=cI6iXj56q`6RK&Cn=RyhYRRzjcX&67%`(ZqBg~$_TcD8xAlpLWc
zZ7pRb0Hs}qhy*1z^#w&rIQ=l5f8|sZqHwv|#jw^ECDo|_Ml)+9ylsAWk*j_fR;rlv
zs7NLe#XGrb24!q!2D2OOR-t1M0Nd6*4zwAw(Gd0N1<i}&_U}L1nV7pmD&^s}PQ^+U
zEgK_gyeL^cU|NYhdv_Vi#aIbAQ#D7T9;6PW4zG^a9ehElN6Z>HoE2AIuuCmRbr2=-
z$S?|6SCM_WFajrw0JR$NY>(g^Ye;&miRa5Wal_Ujc<1fmlS|bfKm`L4!TgnJD(`@U
zhEXkNEbUBBQ$C0&nrU&OI@xsv(S4Po%0||Vd-CQ=_ux^O99(=C;O=ekvN#%3-)ftk
zM50<seO=oP*;;Hh=j7nw`5YAvS$c%k3PJ^d`H7A*RWqWiP=@_2KD+OQ&Mw6i@ArH}
znx;y%6sB6P87^H-Ff7*(NIsG*X2u?nCZoo7sH}e%`-I|rlip+~<AU3uiXY`vD>l>{
zWa;Bb*fS1LqF-Td%jFXFw*5rxkEra!Y$l<TvxICaZH`hS28vw!w=vSuM-gKO{aS*E
zakW_Hsu<^Ane*$U)+A+KFS{1z0NW~{lDnpjs?&0|ovl)<q@xnwVr{t|CePh2eId1j
zLo$iM=d;^$Zus_u9R7UW)G<QbGv=G5J9$ZvU<hMHo*@~9&BMK)J@|{0bGxpjRDm9r
z*BzV;^VY^k*f~INIa-O>N!$7%Ow_}D3bRBU%&eC?aKUJKm48<$7pz(h7g(egS)daD
z4rK?s^~Onf_GQzWIl|{fi1@g2hwT$2Fy`pR{W(ZhFFh4dy6BvHHZER+q!HC}Mz_WZ
ztb@_-vf%g&m5*~&yf$g9ho`hC%K1&Rf3i7qymaKN=Z!qDJa4ruhufG|>86>Avw7wk
zfvPT?>+vCXMO4JtnQQN2*klrp>(i%K^JIbJU<foZdo55Z3TpKgcCwq&j~@etQ*_4S
zRe^gEdpu~htzlDVOx{)ggsXFM73|Nwdxo}uoIJ+gC8gA=6m<v(<AF9gMrs9sexoK?
zyJEC>z6xbBLC!fo{J4JAP<9((ZXYeij4>R0=Z?M^`!lu_A}KbBh<wv)I161k6TX-C
zMsg8oH0U}d8Nq2}PUa|Wl2>XN<hsO(oyC(}^;Wo(M<_k!A{1ZRT2FS)nCNYg-EU64
z{e2?LIHinR89Z+xsw903OFk1<NtWl-0C=r)6KApPqXm0sOVz`W;X{z)ZP?!H+~dWM
z4&9sd^^R7^n@W1;-M-*Z&x{EZl(S0*6d(^d2%iN9S0Yr8*I@pMu%oKrdWF!k3VykI
zh4d`6krbh)ga#8>4BDxbrs9QpQ*6H&CDm0j>)ZXhUnuuSL5oY`>T=c4MCGFXb$Znq
zSmc&^D2e;t)SFd*%~eY)<k|ALEB93bk0%gh8ca1+%WtsYgn4DM<z|c2b0V}4%QLO+
z%#Bo4gI%IGEM^vr_*_?7mma7chES2j-Q3m(6;VzzQtlYi2l6bd0Gfru-yUxeL(v&p
zhlCJ4Fp{Kj+v8Ry9GR{ft4Xwo0o=KCGvo%ZF4zz*<y_+;QAmsX23{v|==Ob72}IR6
zg$Ejf{8i|1(mdms_u+B5(}be}*)zu*F$YwmLYWO+N>*ro&Ja;bg>+tco#aUqZ!Mab
z(~~9d;Fnn59IDAU;F!JEO&j`S9WTU%qS?UhL@Q?wDB=8h2oQ%o2$#!T+;I}1T)o7r
z{@D;cpzf-1dB5bmdPb#p<<eQBSZRva6x0bhUMCDWaluTx9qmlhK5RYj>o2~%cXl4G
z@9A!?H6O>fG(Ki77`iOe)Ce<~d{^+b0w3DZft?o+eY-60&L&wrbK6~@P6&n;Mt;*T
zUS}nKJ6X&fAQF6XsGga@&U$dnu7?CrhH$`+XfdUXY}S9yW~`dn#x_VS8Qs`#qMSls
z$M9M6>H9J>7I|!c3*QdSW=3!%_bO%<OZt;p7^a3!T14{YA(-LZ>3UUqgdUq0r3X>l
zlUNM0+^^sLoo%jHHAB~xN`X`lRvWbWt0jzEpk?@YSs}4b(kbQ}na@$W@(J+lz102s
z3JIN(2g`-!!^Aa-9q&>4R(wi6uAEgbHYop1P$4R%tvJ3k9yd;4I3#MCuf<2X2SdqR
z;aGX3pMO|)ffhkj3tCwq0!<`zT3O*gcm|ev+YJT}cj?Q2*;}wm?AOMKq4ml64f}1e
zA5HkAb=nh~!<Fh?F3y1~f9YyoG<vj@sfqoXkyQ)YUfhn)nUT2T4+B4hzdCV`ze*NJ
zYDj-7DE1z3StD=NiPh>n2a2-jeTNi8ZD!7Hmg%;HlomE4O3o;^`gLhPQX{dk?frh2
zTg9IyHT`*dYgu_>{g(_k7=9w<iBx+0n03c};9M(UVYGh(;&|)%T>oYAYh{PYQ&ath
zCljMu$L{rONh?!ryDgupr@-to@*VW-3eh%4fUh0quol>DAAA=Y|J8p45_3#++#xHR
zxOtsl##qcoLWoE*NS~V%i5LG*pvUiOa|z2?_QgmDq);pWo59codtr|r&srAL4{x8^
zTuCUCKJPe)tQhUkiGIl_A!|YGrgd8O+j|YZI90=&J}#Wmbk(>Aqr9@fgrz(dXFw)M
z!Y`F6OyEs!qfG_+clmcb;`s*c)M(`K$NfE|X8$6Cn-1_Zi56b35e6RJ9iIVQ=dqdw
z=bFEUzRcR1nP~(RAH9RJ>gq4OTrQ_GMiMt4m(9LW-tMnGVp}u&hpC9Qbk8z5EYD$P
z7w7%UY<>*8{jIzVM)my?Y-j7A0i5@9eM<#7Gsva(^gN-NB<VEP_D!6{6YcQYi05~_
zH*Tnx@8*x#6bvH^x4ai@(=K}J87?+;E<CQd*UZmnA64?ZBV$B6NIvjC8t+CM>J2Q@
z0{16%=mdR?J9Q)7p*MHgPf}03KG4MK1by%XG~;56BMi&#cIyiVM5Bcdw>c*A>kDUR
z4{&bGImk0oGv+gzvFnYrFG(1dzE%jM#qCJqf`6pr6$~VgQy8UZI&IKxl%6WWDkMWA
z;{E2!P@nSQaD+<Zv(%6tCx3rbyUbgSe7V4B7ofnIl3__Xq39~nB9mqn4Qn|@c?nD)
zZRz|w{q5+acWU;35KbpXDaXOTLXmyIe#a><C;(AcI5QjAg0ez*8j7FJaPo`vUQ9c5
z>L4v4Dv06UBMEgLgT^oe|HX<7RuK7(AnL#Ng<%ZYg<nE++g}~)6@K@?<Ew&_eK=3!
z-9z<@T<__$CT8u(-s>v<=Wl{Cp}y=*mA>L^Q~#C4soUe7ttAY{T(>T>Psk_Eb4O4-
ztbzL?1{s7%ex8hY|6c2HQw0VX;qunS37XRF_rRHkX%z+e+;9jJ!zGxSo5WYlG5im%
z|IX|7i!at!*4O4s`%h)ryaKv)q))BBWfSI0f^Nx(=#x#Xqq>l7J`Q^bC04uizKW>t
zzV`-&Bl9s{;6j!qEKkA5;RhPx!^`XS9SuCPvu+d7I+|syHJokKc8&YEE9EoUL%TA1
zN^;xm#9;7N8x(3?OuW#e!yaP`?7LUx#B;-dvFk?t^z=q}Hv76R`+|6F|L#k9auqu%
z@pQ0n6inp(FQk2tH>HoM-4sQL2`0>T5C}5&6~B6a0^^_L9$0+`Fk_0R6`p4A-CD#0
z=6;NZ4VW$c^1?478NU7;q=C=~5mG0-hcdK>P+W!%(?;>mnegj1aGZo_PXOsJ3}8gK
z7^6|85H80U53BvoOqPx+wGt`W$h_MRFP~;+iE6d$MKp2N-HX=W@z*maeg}03kM8UY
zCStOOldzrc_@b&d-6P>-2I;7HHmRsm51bSj^0*BhI4Q)Vy~#d>AL2jO1h7Je9Onf@
zh58pGUq!iR>ik95EKh46c;3_A+mK#g;1w-uw@96$5H`q3Vm-t^Ii~~Pp@rI7G<?V_
zCwDDHyfZ0-0mM>3cxwxYJWGV^Vhu<Y1;nF?)Y%gX#e3!;%#5d!5u+)Orm=Benqd5!
zsQ^O7N+zBZBA%3GAZ09l7!l@i+*3YN@M??>^Ta4Q_=mDHAXD%_oMS~1LZC|BpdU7~
z?)%UoN{kEd{;KEzx2J?Bkobo)qhsiqA;J!<IVC!ociw*7+Uneq&W#(NlcOg`bx#?L
z=8=QV9Yqe`xm5~qaKs%IcAAnEY?aCU`rOUNiu^oc25nC3JH*y&N2*J=_3h3Y>1CZ2
z_4KTrr#!LBdJ`jNzSBL$FfKPGs!@1HG`i(r_F-}K4CcLJCyhVShpP^k{O#&{a}N-`
z$*p(K((X!%=90frTckY$twOrg6iurer|N2x_=q<se*C|PBzj-WACoTqK0{jw*K-}Z
zh<S(wDmX2?`&~A_3ycOoEH5}BY^!$GVc(BdX?pf$M#S)_#thXtBTHo`_7x~2y?bbv
zFT`k}*iE%Bwm_~0InEASZa3QT-*s!dlrYo>g`T>}u<yL|Q@8V1jknB=#^D#L2hFDJ
zvEu_>i2{XhnBih~=tYlQaBZ8{B90>P+O_xUHohFN5C14Zk2EmPf{24kQYWlhOJ6Wf
zqr+XnR4Kore?=5V=uvSFskH}+Yj6uGu>yF=KiZ?>t&=yFH_q(QVh`(dtBL4y-N?l6
z^vwebFjb&Q3FA@!U3)*3O-FimX<7&}M8sM|+arDz^_4`5c67`%D?Zoj)%n<fhPUQ4
z#wu-E<4=V&7y`t5X;#ydceAzgRVPISlO*bG4)2r10oIRCuY<^>(Gvg+U}&C#-KleG
zY^Whvzat+qZyGP0Ls6kv8?@n~C`ch-q-;pihQ>Lg@rH&u%6Cm6y}w2Yf`d`sX}=TV
z2nZcQ{+8(V+Qw6L+vA0wyk;3Ogp9<bKWx4$9d8T9y`aZRg>?|CldMpK0;}Cr2>f7%
z(9q0}87IjX?s^e|5l#eO1Zx$k8P6L!%f)DcOIoqcbxa=Dv65vIdH<$Heht0^SreWB
zxp-=Des>O$ND`R6To9=AQhQ*3X*r@;Mx-PBE&uRi_+!kJZbxr<fJdIWW-`_+eS}f0
znvUBl+j!ORc&}6$jTE_6(jc`M6>W!7`Pwlx`tPJ1Mu@)D*8D7ekP#JCg?oD2a^R~)
zgx!#5dazHn#}NuO8J3tvD4Mj_mbnFY1*;WX^MEl0MqG$DXAit5)O7w6NZxHD@>LJX
zpsXHn*p$fj2ltGuHUaez?TscLIrF0-F|$R}R7vxv&N}5a7`hI~`yipBV-}r@<qkxJ
zcM-rXYf&1r@g8yvzv}p&E`>XNje8&kNODdp?rDe=N=lOCLkde_f!vtM9gbw|{qg+u
z9tgY<9*X!`)3z7xE8CA>d9t#>#PMtmBtL}6-~AQ-q%*SpuDWx7B*4q;(ju&`1UOH=
ziOub|oV}0?Ck{Y`Mj;~^4IU5DE|YGWu<!juvim|<s+eLG#SoxE63~Ow{%*&oMj5=h
z(4FxyRwtdcKk=*OLwwCco8b*X>r1O3O(rEOmR6g%KzkY&XYdq`8Q6=cLy{knACw>Y
z$&V}GtVywbu%`DK_MP<Yy1n|V+@tKjgYiB0p(@BGf<Z9s8G3*3WR{kN&8->r@6_WJ
zIb<Q73G3;bq+Pg(G6%N)K28pQ+7r1}kV{hT8$g+9a3h)9=Gq4=f{m^Qf52Z>N-^vW
z4hmibbROIEs})!^bj&nBIPAdxRWfUEjxpyxK;LUgGO7j3`J=b1seZpEro}nCa4h{Y
zG#mNdCqEiu7FEv;9iu$}hK}aW!;7GoV%LC7TM!kFx^IZV5Ec+JFFaic=d2&xr2rD2
ztd;%C`}<dI_K>Uozw|P4E)=Gea2E(pz{mQk;~C?U*V=`_JGm9iSWbIQ8L!ud(L*W0
z&iaD;%WAF*9sT|4<$H9B;CBP0my7G+_nMdT&*RlusCpfI=e5>S)9&^cnS|}Qm2U-m
z5^l1+D$3FKl58}3yZaLTkaH^=-OjV<GQr%7He_3RAIA*7$mQ!9QK1ox1e-h<GduQi
zn%A2OY1zU#@RR)A#v$k@FjuwOI<lH!5ym1Ma57)i4e}-2m;u&bW(&ErlwF@#GC$JZ
zQoU7#18)h)Bn@+A`;oEKFd{uD>cMl3_pxoDiF$_knRp9gw1s}%EM$&jyyW^Y8&;)c
zkR_b8@-+{|f)4+pJP@HZ_fsZ=)00CEqjEW~oz<M0{q}lo8<X3e+B#cqn1%66mWtu?
zbVq&1Uw0OJd09PsE27u1s7770T}78_HlabIM_EE9iEBskc%BN^9IsdXlHl|#q<9N(
zG>0^3G}aTBk@z$PxW<`inN}R@D_rd2u2e2-1fq!JgmpWF?#S6uzT|iQ(2=4AZ*MTP
zI83<BUUT!%6PQVN?48}5dhww61@U2K55#YFzj}10ssAYUu?K6DKgeqI#=V+AtKm}L
zlQ}lq!<r2n(4yjX!+1&Cs|n3V$PMYCM;TfscS&v2n;vQz4``4aif^ynYfQWZW<9n@
z*ef<sOBb|ge3~PEozpPmMy*z{^j%<1H)n$uIvKcZ&9BcWE>*#r5^Hw4%&BfsWindh
zFj}KR&j0kc87r5|r6d$LNLVlSiG4RFqf8|oHnc)6u27FGT7ZjCd(EmS>~cM^bgLXk
z?|usAsM_FeD7&0iNU=;r@{REZTW0inT!L4Rlr#?Z#RNNuI2#qe?(FdfYL`Rsm^_(P
zO#9l7;5W~GrfKpNH|N5&!+KL^!@TB!I<1lKIwRhiOdTMBwRWg=wAgQuZaBO&xE@QR
zlJ2#Kw1?#0v~RcjZyat)xoo)d5E|tqAim0dG(CFBm2zOonncn{$YO=`@XkKu;N=*&
z$8PQYDN;)bT>mD@dBKVebgpL>7b;de*de+1jD-{>@=W2ll8kloJE#0)JEbJV@G>X7
z^S}RCQN+i-)knk^je7{N5tMLZzp?k)8ML2CZ_(^f)WP-E15{MAP<}*{1eK_08hGFD
z_t@9zQF>leK$I`0tLx6xFwxpOJ7l-xc?Sj+6HsM(|Il|gk)$Hr>kBY8nm?~bsL}em
zjeKs@{O&Y=$PmuuQ(5G+{M!5Sv~h!O+?+Ix33=XO^7@*~QFzNzG8H`uC){>fsHK4|
z68$wJT?_JckG6^k3nSEr-%0gI^n!a6O5_6G8NNZiLEEd?tk^x~M$#+cQi+__%OOKP
z))u#f+TajH(??9@ipL<XM$1cBP<z=&4Rv48mjMI~78gnIYQ`Cc@xpIg4`@zST8U|9
z00d6=;bILi>QZAVXh6LLVH0H`AO^{Yt}&LFRui0(Q|hWB1=HQYcrs?NL18u|RcCOD
zE@e;jTxGgB6X67Vh3b{4gF6G8&SE-M^5Ije|3dWr6L*kYgK#-3vY!k|FCaDLLks<3
zAeEGiJ<iahIe`NT(&@+Gv&VRsKYOkv*Ngex-?HtRy7jo6$g%x3rWM;GY#36WY0|vC
z{d-H-t&v4=+2|*~xYyIbZf2nq(dXl%UUox0-l%m__wj7l|EsslUKh={84!3%sN%Oz
z)(G4ghhV{KhKn=e*mtuUW;^Vf*g87m6~}N)^JdDoeP{pfifsm@7rijs<6N)>bv5?u
z>gR(ngo}R|aZlpbrwxL<rgirn`g`ohjY61JgBj#SBM!bi9`&r>nI%tK<1SfX=x2iS
zXW^WZ4yg?TN|A-AG*>%}jvFZDdky-Nbu@@nGIG*z?C!_C<%jU6trN(En8Od%igwoQ
zQ`wINNH2yhD)*#DqNiT<pcI?L$;So+2`2ADQQ*F?u??(i8F|q!M{ubOdn>XeAN3ST
z!3Wg`^0`0MVosUTZ>tafX*7VV3DG;OMr`Yp#R=yqU;Gi8y^qtm4Aq5->l?i&`ZVUw
zX!e)C#cZtLQO&TU0`g&LB4te9WcL9{pQihP0PYWvw18l)!OyD!E51W6Xlbw@c@N@d
z3(S|(CvVkaEca}p8!V+hqI4mjRn``t4_`)5OrG9>_~?{yW*g$6#H>Zz1(Q`j$wBFG
zuV8H*7F}?>jgV_!1mqkP)gOyC;J8viMwCgR*sKTYI})xvG)YwGaB0j<;5x<Jj$}~R
zkfZ@VGAn3vA<tZ)VD!rz_9L5{HuNW`7gEj3tzH|VzIC)2-+GjX{*ioN_e_CN8(1n5
zY<*Y*s`!ea76UiX17dz+8*=MD@+Z!#=a7-=0oOsv9fM%VgCcBI9bq?wW7fdXEToBk
z*ChAyP|blfgH<Snb^w78#hhndjJ)5qUZL;4R~tVWN22w?!$>a958N`bh>ePWjWFyi
zP80A}m=9FvJGTeu7sq$XX#NTGv#bq^tIMZNo;8wea5IO{4Hx4x!D_J(E8NP*ZIZ|2
zfU?T&TApjlfv%Up=?mgrsHiY+QRHX*7~>5iVWTk~hb}Zpy3j<M|F7dh^g2)u(B_+v
z6K|OA@a<u8yg~3=(VKy<oj9o?jG7TZ-$&3||6{{R`^Jb|?3elF#@!a+qq)zOPH@W9
z55{-ML_-9t_OIm~q5hHgp}Y9NDHdU(enon_42>hCBf|sg@rf0OXWUm<W<T9Nf;48d
zx9w&3-SFK8(h@z2hB{QiDJM1Lw<g4<6JJ#=YK=`3xV1#*oK7EuYay@`QqG6!Bl|ns
zJN`S%CD302jR)zpFNoa^e59c5;FmqqJIhzuPxfy#UlE4=V4B#Zcxok)^D&18&>GJ%
zseAsn1bgPlbZZ$z?T_@r$xvEDO_wa1U`y`SP*0`%7*=_1opmD5m(SDSPuOZqeryq=
z=lWoym)LIh=b_iGJK4H#AZo$jy7}z7aqqrB$XyQz&O1sE*zQOllA0&mG<^ilZI~Q4
z{+Pcts(a>c5ZaBms&+b{D_&hdHDYa`wSJbk*Zr-#T6fm3a(3pYPXOKx;7?Y5m=#$4
z^w<Nv1Lar8Pl-<s5E&V)-D4o=c;bX0ifW<-Nz`_nnj@sTTB7WtOe;Tpj|8}QqeJiE
zQLr=+6Xb=VOCz7buIbN+H_TtFlv;x&tL~Q$&uY(L9|Rx3A9N?j=WXblKG)9SA}Fca
zB${OI3J#L@#fQ9YrBm|=XBcO-MF$N)W|f2kj)d*PN9a;=yUp4No$*;9?RCuAn{r<8
z3NpgS%$4b#X?k`Ox0)d%gnL_)(#P+2BWWJ@@+R;(61qdW!&9ov6SKN?oseUthj?!R
zY<um8G+84)guQ~xjBKLB=SzAG<j-o?zw8Qp0;$K;c!jtB*cjX3`(mp)eB4pl2)HBO
zU78z;mI_w5CP40%<R&KnL9{S9*laZ;oBcAkA({1rX$L)F={0;QoWUY|<Kd6Ifvmn`
z+3b5Cb0!T(3>fbA(=kJHC4wr9^V1vb9T<Q*C{3fdlPL(;8b@NIhb(+!84mOvqEw*K
zAwfVvwIMehW1IYykSGIEkdk<cX~tq=$8<YAw1f3dAlcVV3dUWH&@{$iPo?n+DY%o1
z>ltogbq#8Rc)M08gQgSxFGbcJQZ>NJ3ql>X13$UopfAuh&+s0w&b%F%>bIQ>{+=lK
zryT~}fXwU{Y?U?cDlE%g0DTc*-zVzhkG#+Y$9``fE)!w`Tfn`>dP8b8=u{HKS0`i*
zSsA=^Y+fgsM4Mg#xfSrkOzagT{STH7B>M>>V=sQOzBlY_p%t3iRG`Uq01p9nW(-)H
zjl_+9K+E5ZQok&Y#s#5=ZGj$`96PervUGja9dViwLP54VSM}H(?jFeISOIPyy5BL!
zQ3Bxat^=<CY7w4xHRjmJI{Vpr+XIe1f-j64;BG#AZ?Jbtzv|OiyDum;)?iQMD-&PP
zjz$Zwo7dWYi7^q~JOxONIhIq1N6fqpClj!tVUxsxgC`jZjWXrkZ~?CCVVEXEFE+F7
z)LCFE$c|FT_BPM}fQoE-R)$J?6(!^gi`s7`Z50h5U~^6eG`Lr9UBnxgBW`?`%q7EV
zCZ88|to?905ypt+xAO%r^0etXp`FJw@TN;GF!V_JN=Z|<vWngY`4IWYtydaPm|4fQ
zpLylcXEge!L2mwFC2+-_=@C;OwTpw$yMW5y0AJJU+T@w2h&N5c9{I^iqMN%uc&}_{
zF}mD-^B#KTUW1|Q4ktP|SB>(ryCqsxG|@SOV3Y>wQDfSk>48;d@JMXK@=D%+NyPAx
z<E!4y&e)l?DK&rruyYK$F;=}LCH0G2x8JY@*xHS&EAc`-<=EDumjM=o=FABh|1ugw
z^rUhjuJ#ZmBwTLrm-AzsM4Ja&|I9VhVVfw@WQ!2`yIZoPOqo{gpc~kU$WBa8XyH#@
zb6-g3V7T6FkC{T$ShRO7i7YIuVUdV{Je_SlG2ZC{3=Z%Jj){4GYcab)%8V|Y<jo{`
zcNF(<|4!5$GCk}m??LbUcc)-<*~xNxE}J9Nsl&<cgR^$=y5*?ll_Qfpu+mYs?9K^!
z)#I@cC%bE{-hw8Ic=4#&K(K5^!A$*hlwO>=KA5$deT-AvBdRW=ewYb-8MlY|P?vx~
z$g2!4o1&Jt6-kqa`}vz`Gg%Ylqn??hR_bP1Rk%B5J9iI+o3Qu8671s!_v;~<Et1@V
z6nJYT%!Ddc+mO|)H*H3gIQ`RW959cws;F^*R-Z)~W`jkJtydZY33ezlCAcA0oh&Bk
z6&q@ElVbqvEJ(EAsQRmAvJhbefD%Dmjh#?JM}ny(vof2K6G@k9BmdzSn~QmXr7Vuo
z^(bG-f_tH+Vp8|!Yo?oFZJTvq*<~RFtJliIC$ur#uAbCzg`T=j?!dVL1U6F#oVN%^
zShu|d``Zls^8n<jrz8373}8_=993TuY#+C56~l>TPr18e$q+3AOGnL(fg2b0+51O>
z8WaM<l2I>ruDH~6K`nUX!Pjl!_Epm(HLR!8dOw{xIi6-Bv4&Ewo_EOx0%H<F>R=PR
z)0L*itP;|=+0(T<wst3byW7mIt8`%G!mBfuiB4wXdb;Cr=!%d)pl2k$d}jj&u^vPn
z;}40#{dVrgH~V{`i}kr>IvuXh_bp<3t+Lmjd!%=lt>Eqs>2!#>SF}jiuoo#lBWJT7
zg!Pe{WmUOF-xo)zgw?TvyWR$<Y%-}N;3|-^KraM+wq3N{u}$7X<7-hCU=zV~iWvZ#
zKFC!fa4V1%u$kYp2RSC4e-{Bj8tI*XmkWr6V)z=U&BE|I8fa!fm@p{+9?1}}e&T_Y
z@CP871|93bKnvUjitjfU8^;w9C+3$Y5FH2qzPiV+!SA4n>>%PR4-RI~D@+OYH89Ho
zN8s`Yn%0P0ICyF|rd#Mo045%W{*j|@(GuW6f%GpIs#<(=rb%rO;9%ty^yXAnQ=@_f
zfk%aQr?1<lVujVj^GnZ!pKK;z;W{KjInX3@^?q!3u^ctMA;QXpvN!Khr8(dY><itG
zF_*El4=B<V{s=uKr&>(}+{8xw_igB=nco}!I1mykBO&}-VDVQi^NsL_e0ppDOI~X?
zU)gf%Uq1m8UB9qlc>a(0@Dvge9B--$U07VdIjABEU^&n%aQ!))W2q+iJj`7rpvb1U
z4&Vr&3^RDgI4-CQUZ59CB03Na&{^2Ng7!%k1z$ed^wKodUD3AmZlu9Xpc{j0<hujE
zD?eYTCnO7|SmE^j@9_HpKl2X})TfU;D~QisFdv|Ee7_q^M99raZ`33BNsqf8XH+*o
zO`cPSiwd3DX;3s!#<)&QhZm5u>*7#>I77Pt^+*<c2yK|x5LyTaYy8L8LB4hFKlRB7
zKvJzBXRRPdE&s}V@3m=*_GKg4MycN#h<A%%F5RpttU_^`ChS9XFuX|IIglF=#Ay%4
zsoVuiTntba+J$Xk6QaIfN*b<zjDf}yy~&b(4sM#&n}QN$wFk1758MDfZo^T^vyXZL
z4J8T4vW!06Ri}!T4mYX#+<LLd^CoSG?uxo)+R!OEP=EvA33L$H0$9W3F0XggJ1aff
zCXPtxU|YO}X=BwIPfI%zzLvST3_B?b7ds6kDFDI1)e|PQ^eFqDfU7X^;oh(vV4LD-
z3Gli!#^O*ORAG{p;Tf27J)IxN@+M)DRl>edMxbOFM?R7wOO20`l#`bGH7(tCX{s`n
z&{U*6PjZ$BCwb_dz)vMb!;{P>Ena$<JR~i&R&}_k#H-L9c$Oy&TaJ*2nuq8Ij?*f_
zH=_+Xi_kfTP}GKSj$8yK&Fz;MCjg%on1Jzao}Y_h(X3F3{xgGBy*dvU2XUHZmaJ{j
z?uK~fo6-Ull&1>XjFWd|E;%!gCkUFfsGuYw1>Y@~@K7g=U&JfO0z|T$4FOc+|7fUn
zC+dkKNZgW({-JG!dfI*1RY%E+GMvsx0CmvAh@qsqR2+bb64*a`ZHd@)(oCqo^12MR
zd|1uZ$NrW9BI_;-xk|04nnzuG4y1KR1A}&ij<3JP@7kAr!r%8i&CB|*lulvNaK*AR
zxyhbLRl36kCm!)j>=ItV>(8tS1Ko<6JbCD@{W{SVBqw+ufUd~KkJyjej|~Wqi*%VE
zvUx`6%CQVO58p4aGpCRmLg_^mxB3Qi!z`vHk!Bs+?bQ^L#z=OFMd+#p^bwSi@wsvK
zyK0pulZSNK6u?Kf%pv<oh;(7jz|lAKQHG)osOSU-gup7G3-Sn30ENmiKFm=8Vc{!r
z2vYPB0i|dHt$3O6yCc+?jy1}tD5R!sj>^dU!h59G{FYGZgSGffO5>+2=^Sj5miY=O
z5&Du1d{2gWx`IDP`qTHVDl*V*c#fR3bbeB~B)fEO*Nh|H2tdR#N=%bBi})ceX&hpu
zK6G3Bxi9;<R{Uv|_yUdXm?+G-%zxn$3RxnRkV$3@_RA@OH^f0pvU$?7dGc!Q*sQKm
zJNUvfkx(95Br8G4*ze`5tzII2i+r^$!w~-)SYGFu20-4s>sMjRtM6ZA6~u&4{s8{+
zWOR=GAp2yX&0znW%KM4xTo0Pr!=|PC@do+f$N|nT#?1xq!n;MK3<mWhB$Tl({UQwf
zAPl%ij8_-`5P%V48TxVy(fA1r{~*AQa_Or=L=@-fuR_c(<GcV3oMTb&oY8l}%<F_K
ztOR~SfH(zFhcCI`TJm_OFbsOui2@0#`ExuNwP0|#<X38JTZ0=l-)V6MHqd4=s}4db
zs{V%ZoNr>!{gNl|HL87x8fr(J+hzs{6Q&W^yuZIRN@KW|XUh{s?9OjD{1v+x`Pe_V
zqQTR)^A(!9`*tjJ_u@9ZEA-+yLfH<nMNu%oX}9?0xD$EJ@ipMKo##o)O&b`ZUN`_o
zXio@1Y?{Z=FR>L`FtIiBHn<GRZx&pAEsx$t_)KSa11so0+s*fmq65(Zoa08o+A3b!
zW?F*KaREAjl@W~gwUdE%E&VTILocBZxDC$=xrY0u(HCP4bGj{NBeFnv?<>_%3CN*H
zMy$Xpo^hLpI^{f4pOKo&{01Bqw=0#hN|?l*{lQ6>E{PlagMv*%!c01W+zUYZLBtN1
z<3%twACGXyNB(&wzZgfMB?0hYlPpN$oX8Aei;!4k@vtcqnB%3y=w+9Ov6}pug4IGW
z@=~WsVm^#9h&pZo3Y@RNN5Fw16v4v0YFiMxOTl+-Y1tp195q~A?Kka72c5|W3e9<t
zZ6<yQp|(smh~U@M`yfns6!lme30$V(Cu=%3xwg$(NN^`_WmA@BIcTqrPB&)_;ur52
z&FEM+DoQL^PBC(0IjiW*SU#9)u1@VBVmJ%3p%g>DVh`$S!oA-os^5^Q$E_=Gt$D6n
z$-H{x&Jp4P{^+82`JID5fvDW4F@+|?u`ldnPb*+QXVZtc*58zhSR$-JgHWPMWY0)(
z<;02PM?VL2<<Q0pgpU9@K6D(o!}bBPcGOhh$0-l=|1@{rQB5uH-lqsi6{JcH7C?#+
zNT|{~NblVMAtchPG-(0~Qba&N1w?u;(xgiV0qG@Dl_pJkhnwKhqn`77?_KZx=O&Ag
z{p^`NGtbQ4YbBq2zq=xI>+Z2ha*YksbiiXV8C;*!Hg3?Fy{~fSshLZwbeNcFNj#%v
znvbh8W`BYxovuEgD8p^v`yFlMtn`g8ZL^dV+=ht<qZM!YOPlq&m`va9i-Wi`y2HH7
zLi%RkRdIz-6Dr@sqs9;W>K%qK3P~E(9k}0OTz#usr*u`Es63oRS9-xSbweB^&_B<*
zXdLcRASXOR{+@i+I9yMyCA^y}1ZvHGqN&#`Et8Gmp&)WQU#t6F&&^baJDaFqh0?>w
z;<=z{;5VBp-C3B{T9U4kU|X!EG!<G;ZE&Autw(g5BfU7dFD(#JYtJ4ExHr)`u6#CJ
zU{W3N{&0s(VI;pI)OA_HTGW}AZwFMQ3e|MI!fb+Mufs4C-^hiNxfEuornM&ymTTMR
zh`X}2<eN<q3<c}eveu+cRJT@lBbQhA7&n!yo65N4gS6}S3Qes<9mq}b>faeU_U!o0
zFmV+a)yJKZ-YKF2h?rRVq-CU!hfxKNgf&WYOUPj`Nf6y7!3a4e>^H+Y#++Wq;Cx5f
z?}fpLO_K_~gQ=wsGcizx*@Ua7TR@dULdnx9oBXJ`x@Lt4ODgT$s4{bu^ZoF0%|j7f
zg3~k%A={Z4Oqj=H(^DAqTAeYWfrY(Jw#$ZZ`2!#a+g<*yAOkuB)>9Rsj4!4Y{Ffyu
z*aDkK9{G;B-I%&o<0guw*$|8oplZHq=!x_U<vu-SGUFH2`KJUNEkFJt0SAMCz#kfH
zAX-WNhg2E(x8(ZYw8|*;^G~l0ljv@{CIC^}`fZ%HHT4_Bw)*L8{evb>qakstm~8R4
z`lUz}FL@k|RenulxO~RrOGl^m^4-EMqA<?M0ZT9aG^PM$9<>om$)p+H3&pu<bSq9q
zbM*`=6gaqh%QX$7IO2~pp0?oG^(Y(8&3CB4?vrYE&T<JUNLRLZk7UF2e8V^J<SvGB
z$|9BU7zb+O_YrbYvLuskBzqyy3G>n9S?6#-Zq1~lqMH+syajWD17=?gl!I>F2($47
znHxdxw7ZME-ba61sq1pM_24Z&TFWMzsC(^Ca1(aGOFLqGwA<n(XHWOry{`{{p!G0=
z$_1WcA6;tpwtLk(_cGK8F?_H8-tcl>MP5Z(p@A8>GjS+F{f4umXN#w-N4%?5#E?*2
zucnJ`%Zct_p?U4q+F4VIozyCM6;bvA6%E_a6YIrI`-(djDSJ-Ig|!(E-*iW^_r_!h
zU8t<D7L*O`oZ`msD-r(ZWS&pZU$e;v7W_Gv{}j}t1^O~jXA38|gNwZrTDyL(*;j?w
zqSW?Mijq=#8XVeiTd1=t)Lqlw7GkHarK0__m>k3wZsP%9J1+r16#<-=x%s_-4FrZ#
zzVrSpE%jZR&jsce1aR^3@B?^xcm)AK9@M+<5`9G%hz;CA(hg<=1@N3#lXSK~OZ)|e
zzAOIGJw<PG@dEkJ_e(<@6rgaJHOd75b(r&zmJ8HY7a;h(K6*pp#|C<=sPziv1)$~k
zzsm8^_5(lG_;(WkblLBRb2WE4w;s?&3I5Uh&ZANgXDGVJf0rY;le3GoHN@#h8ty>;
z+6MA|AJOmmN4YPY_Y6G^vUVur8n_({z^w<jleBY&{|KCSKo4%|V(t8w(E<7t{kJDC
z7##)k{LlV)QFaNxABCSEZPoDq_e8hK0|0^0&IiA~{^-q**1rG$5k=SG<KqMH2?_zw
zdwz|h-=D7&lqG|`jvXBB>w}thRE=M!68N`i#Sg~>0Pt_ihkv_Xp|kzNTR}hw#PgfA
zLcRgveeIz#Q?GSrE0#z_7XOD5etgfK`8S}x-c<)gSVn(%*amnQ67?Fvf<JQu)OcN+
zizY9XMm<Z@Oh<xC3a6_>#zBIkPuFWhqeu+(G4y^5BLD5+NExNmTD=-p=gIM!`}*EQ
zY3cCza`B#_*Q(F1n3vR(N1E1L_)g#ggtPC1gK7b?4XLX~_S9vZrocKM7(S60i>47Z
zcl`s6y_v$TzFEnu<qs6KPToK7d6{@8#^Z+Nb58%e4O!cG4fdF3m6ozd*X%1cIQ!S{
zw{6b1dTxg!tS+e^h8`{(+NczWPMcw_+f|ik&s_@hHuF29h>|zP%}fOdi<nHdj13$c
zlstXKq!g8N{h(BhK&h;&Q%o+9fq#c|`{e~X*_$i0Zs55CV>6syTv%n@MbiiT3UgW2
zJs9CPcPu?hY9yXe2!Ey$g-NmdNZZNEu~^4>Xy$1NXwp`(J>OmL!cT`q&_#j7*KoV<
zB-%gJRChe|Uy1ILl#S)T6KXYI8}B11|Ao==;EVZz+PoEXj5nH7T+$rS{=mr4vw(v`
z;3gJx{Y4X9G1Z5iovl?e+0*jPj*Tx`Sc>)NFL$~%DhxiV)aRgJF8P>pWKE!a)4&5^
z)1jl6Z|srZ>)uJ}0=b*nsRmW!#7`0hXT+GyEqmz$M7mmbu#)CFt!~u<IND-G`FZ?&
zHo79ucEUpHk6%u>t$ZO4i*$Ciu=iTG_hec(X%QZ!;E$bfcf+k;TRBv$#q+$hMW<Lx
zUdr<d)SzA*#B(-(<oC=k(kn9oHh52A-NY)16g#S#_0YdvdG8}Xd)j~vk*Jy|D4g*P
zLC$L~P(s8<)6SITv99(yRmixkX$E9I2TrQB^uRNuAno3gw6LTsMY;ti-HA*Vjx(_D
zn9w0+_yykGSS6ip4&nB=QX%btLy9$+*!@Y%-H!lvUNi6%?jEU6J3;rY#DMYSn_+UA
zcqcI>@GG^JNl!UqX{}j}x=*DTLkDo7FZ<!9($D+FJfF#GRKG0Hn^GN<@9O)i!T)F{
zzO6fQ(I7~J-187WU%nat>kRc{c2|)q_yrR=zAVOZrU4Nf47zJl^9rT?HB9}lwy*4M
zPzNzM?pw1D^)YPolx$GFO5--5t&SIMc6(FPdYVxeKAJkHDlmQGeQ^w_=(UJJ*VOt=
z(wnpd{79~k@}q4k!?!6Fd4rf1{Yze|E9%N#UETgx5eHA<{nk0M50Q&P`}+a0?{OJr
z{H?WuIcyQrD=IWIQZ)neOW<ZlB9F7^I;%GtlM4cyB+hkJUB~KmjcI)s5@iXq5_J0_
z7s)<+-P$%f#5)SkY}kCX8Q>Y{IbK6p#UL5`$cH6wA!VI7KK;TCjmh_HrSWuc;v1}r
z#%zGd<~4}oE{RtNvNELbOY%kO8qP_rTN*m0M51&34*NrJF|J0UPmgS-f;QGtsTX;=
zAlLMPa@$nnzAfBykQn&`vIlqa$X~?pea)|B^*kFt3LkrXa_xz$UYLzo1n2RqxvRk%
zHdpRJnE;#J$BIvxjisom!w7(S&CQ<0vd1s>Yn}2-j6C#S<qYRmukO@}ulRI7Nvr@+
z6CHhY$h$5c{$@j8Jgg|OK+>CwZKNOZ?y>NaYTol|YmwE~%1eC^Pn1kA*&O$g2kDmP
zeKUWZiinBFPU6U>Bn$4MrWK#vSk4-Z^hajzyF4fh=fe(!W4Mmle8YS>gG1%|{7oSF
zqwKq3?i897E!x;@T7$%2Rgqo0SC1&X0zb#{W%fjf(TRBFJ@*XRK26z6nq2S{=Uqq`
zx%PmYazOUcHouIA`0zAIOk45gy@9Z8f|I_`9lq9tP|D;smpoi?tNfQLtt7x$lOC(r
z#{Rs?ToTzZVjFxVJfp4$@9nHAibO_x^PHGk%L7lMSLHoI8Du=3F~EGSl8br;sesh_
z-KJvE&%ZsUfm0@bfNhSkg?aEP5!S~Qz9(A!GI5OIt4u^{s=@iSMai*#KlZ+94fAQX
zLrY-{n<O-;M8C>FD77Y|Cg1xF0wH6PYNwN2F^6m&D=6YBoq!?l9gVuR+Lexs(yipK
z+K;M)P*)GF^Q`%7Ph>W`JuJ(?j$Ph&tfBTum8}go@qaS5Z(MBr>E>z5E%VHv7qwl&
zEt-zu2U%J3W?@$Rkxb?|Qd(WjSH~4tklj-YX5S)X==q<Y1ySA<hpIu`3upP4WPD6I
zH0*R8%QwX}ub4G??i0>hIhG#WW7n!E`TSM)lvXv3+#7?T&B%wYo;v(N@AFM!?c66?
z^{><0kGO}Hqt+F@Md`RE)yw-sq!yA(2UZwYXbVf=O3d|%YL?Z-pOc_XOB6<mTq`gN
zbG1_O;_JY2<rT{T4`HjWX;pqk*0tRCO_QYA6wiPqWVb_xz6~4`Y&==bs*DG&T=q?&
zi@%$$FS3widdNKK$K`!}_w7ZuXCnrFn~SC^duH2W*W7J(Y+bR3$C}=&m1f5j%yMg8
znGC<AfmqTd_$ZmzxTD><{$^<2u$=VhbZ%5!=*Ac?I|M$;g~wb@@{+o$2Ez-&Q1c-C
z<m|@Ep~kMjA(`{%?ys+}$|CsL$yV+-uGG`1Q}ydiGp3=$q=O@H7CM=<O0Np@*m`-r
z&mRsjPD9j5H@H$lD8*CVEMTUOsV?oRz9#L=-{$@N78j`Y-plmOoyH!o$SR_1#-V%&
z;hyHEw}Um$b9mfKyI*t@Ys18BOclf65mkgo>+F1z&p+BCp7d(@bPBE%hm6@fGM<Pa
z{d~L#YQs+2yEYfeW6YRS6~7J)W*?Jz!K$kIyq`HmMPgZIVP-BW8cO;~Pi8z~q(zDZ
zx+e^!;;;@ndY7$$z;Q~-ALd3ql3z2pQF`?n(iW^;43e6Ac8k!|kl*qBzVa<b0e+s0
zw_j4t>+QF*QlDO{3G(!B%O_^y2l=*7*GN`j<4rd)^ED+T#U;)bA+=?vl|L}`<$kua
zkolx8x2Tmtp=??hl5#2%P&pHvbtpyG#8C0!6SZOR-KxcUgWy9>=>@KYE{3$b#ZwG@
z6Ro+BiC30{Rzs-|<n<$~!nJfyoO0{Nazr%t?tg4x=rFqMM#s4pK{J#a=OQ-?aT$q?
zGfdY5r&AqebAXA5K!Z;tJ(a2HK#vV5#n?25TRLWB)LThK>4CV*kSqSoHBS$N<ht|5
z6$Ga~Kc+k))*Z?cph?rCO%UsPn8PU$oZnewWcNvV&e}S#x@&5n3b>RST*>Y8x~}N7
z(@=V_EiICh={PuCQsCu>qd3`xF`cpsAH5gc!q+^MC!$wZYPxN0l68(u^5tjsiF{~2
z88NKq1%D1#fVf1^)$PC2&u<)Vd~FmV9g%JCqT(r|G~4w_F4Q!ed&!upt(j;EWWBqS
z)Eve98haj}_OhdUPyUdooJSpF?xjnsv<k0E3)dOxoi5d>Yptw1L3h&2IIfk}N3R{*
zr7zX=<QUACP`&aIE4(9@rq<%b^C{d;Ml;vq4*7LNqQt9k^1H#Ttsgt}A06nU%p6-p
zOrTNKmR{03?_As$o<BSoQS<S9omOXNzV)u|x<PF2mt(2GQ{#zm2T%Im%wZMlLFC9j
zUk|IV9Ia>XAg*nh!<9VD!mY}WjEw~xFh;(dB<>&u`vHf0a#lZ24EhmDWHnRs-8V*f
z_Q0JAq7us%KnpM0T=PD&Dw+m35w$(q@=YlCg!%La6u0YyX;8)IaFJeA_?~3GNdJ}f
zUR#$n9OL8%?>$U>!*^~*IY@6@)zWh1tQ{jnq+|HzR2W8bhO0H^2GfLN>XcngZaYNW
zHq$qOoS1sl!8!&ry6PwjyA96>pSj^t72SZWA(|+Y`$H_U8GFx4H2QCI85w**TAf(%
zc6w89J~wSJBQ^ERlxXO@$oQ%{rIc?6%LL4y+tY)XFqycro~M?0kItn+dHps3A!`d$
zzW%`O@Y#GL@qye<D-CY(!&u5^VDNF7n(xVAHnVF&BR4}J!!YEa9j__rxyuxEVp|0{
z7GA(BAM8p9(<RJ(H8DW<`ry{07p%JTaBfQM6aQ0UO8eR6ck5NElWj-GeK5g}L`V31
zWp&&%=d~T3Pw6-t*jADE>qRc(Ka5VP3*$^=qopjOc+4z~T~D>XCAyzA1Q1MW@2&u~
zU5<@CiB)FV)_EsSjTfPp7HYBWjzQhl>`1S!o4b}8hLy?jl9b2s8g$l6^3Ce3nk9x{
zP;>P}&^0V1$z#0~Uq$-XG0qnZs)D6hi{IR5Z+fGC@{%zzQaCp9>M3PPsIDVk@Cddy
zg#(rYZHjv7s3L=(ieD{85U)R20{?DC%%cf&f!R;~y9o_9{Hz*S{G^;)K1Z2dD;~WO
zHxo6~ENATGEFtiyn(L78BXdfmL`3eR`!qFa$isu=K&2Dxlg*>Xg@DNswe_IeOxujh
zn|Y6uceZk6s)q{llkKSUAI~J_nhS2*N!*l3DaR?}QkbA}xbWfI)5=eqgE+JpCVlcx
z3&8l1cHMo6Ym$N3$fx~ag%es!J7V67V2Ui=<WhqPm=>pQlNHzo{ZgXIZa7n@bE=EI
zf>nu$<zX*7nf?i54U@j?O9h5KuFdn8`(&Gf1R4{!;%<b3I7?b4$ff-^GdEN|d|XXk
zYiz=LQ8%ZlIVW|YdoeSizr3TL-!(H$8LqV#1@WQK9nrRYBzFk(8<3cmY7ms5NqN*N
z19|MG{vm~ugaB&IP$TWa#*m{)Yc&=k<A?Zm84<%3dh=qShM`GRcx2|=v^*8E0t$B}
zxDs1Bi>z(y4&oVUA{*J9c}5mFqJKqkw5v7XAq%pz)lL<eWR<p)#-O4_Y!tbgwfb=N
zt%@sB$(GqDoXhTBaekR?xh+Z~U2a>xb>C2Vd>k~R<eV9s5!8?9*Y55q*UKX(-b}}F
z!!*Qrfl1(Gj8|o3Oq|tZGssM-C#~9Wp$A7W^blX2(wJq17xEk*&XSfeY;Tnimw`))
z_jdc9?E-jVT;XUy6PpI#7B}rm`zrqQKnZR<ZVx{CnfvCL=&B25H6|DX(xHk`gz)QK
zQaajk^y}_VF1P7fk}Ba6C(mIT;|sm=W^`A>W{ZuAAWrXs6pqB$*qE#5tBQgwyO91o
z0k0QfiSBHCI|-8svV87rbDmWdHCf&vnyJt4D~Bq%u_YFGlwGwADS;nOE`?+;B@_&*
z*e6W_O`fz3y0UtwV}?=PzcKNg=Js_SvC>)II_jou>`7cf64Ds_JWM5wIX^4E&OO6^
zR)7yyKdUuM3Q0=p5V=zr=J27bW?grGN8;cX;Wk#_)H60Zky3Nv@(JMvem{vRuaqeZ
zgT0|$LnrM0hc}YP?CU3@l{ttV3SND>K&_9Qz^Vx*%%WGvv&PJFk@=AM8DpCy50z&x
z%uszlUb7DiYAGu-UJu2;&_8>lVRuV4ZiO=>_kGJiG1W_(=RxbG-&Uz^RXCswO%u0r
z;XSZSA^TVJ^p6R+-=pLzMw~17={kbRc@8~!4iPyHsTGo6m|1&^i&V^a^$2^5io`)5
zKObkd9aOa)T#DRcj&x3M^GJ{{rwer-?Z7h>R53Tce<R6ihU_({`yh4xWuZ{py&eKq
zWasoNcCOo>-XB~p?M?bX1k>ysSm7gh!y0!nqCfg2=lc&bMObM9WG{)F_{lyIY!=FV
zvs=Bgt7gSuyOJw2qnLj+#HTTXJ^HLB`7}_aWk|V6)|>s7Kdsl3fDeR+VKU!X;Ad>(
z;uxo7><$V?A&%KGE_5#t9ZX;C_wK%*!YCA1+b;|m!E3kos1=wI$6uPjKU)R3-#G4)
z<iAnF+W>t$ZJmELj4MOxmMvXJ7xenTk*KO<Z<i$N9ysFqafyz;utG`BLor;-v?rTa
zGPJ_yRFxNp0U=NAT!Aqz9E;wYhM+*GVWUWPLu$ms2jrf`qD!LLC$MjDA&0|gC`&nl
z>2}~oH}(;e4Z^%)cN{aJ;GtV{vgPE-`1(#}88yK(8&j#}4ORwq`b}0LWTq=~2d<3}
zvT${WdpPMM*D48v;hmlGyT!ZCKK^d?)ZS9n9cNF70(I{;Z>2;Wu)+rdtIH7f(UJ@V
z?+w^=I0g!bSfp+<cVxJ&54TdVK-tn4E%qMRf^J8A%vUd<@r^RO<2KB=iA1gt?|SSS
z>?*HXthTsS_{95U`J`M!&Nx{L_A_LYgfz{o(|?kT@K@ZDX=kmU!yPvs?hOiU4%KmY
zeC#om$p|BfaBrglq}~?JjJ`6a5!#avYCTF-tQJDXPlwS)Br*-U0o`CkFB?Z#uXN|P
zV8y1o9&D!G_oLx3aF?%3%N>~@3oFj*8&K%Ot=Jf%e{zkIsV2uXLB1-tbE~tI6{?a)
z;(IA{&tj@VEor@4ZIb76(&9_Q&l?cnH2}wak^W#jXJI_vzS1N;KGQT;bTi^o5#4@g
zyUk6Qz(b3L?kvBGh9?2h3Z-`JQC8Xw@3=~r;;zKOC9i+dQU3_rzWstdyvRGL;tAE>
zj?P8u#ay||@f$PR);l`wA<BGtA$2{x^+*HZ;ybyeA6!a=>Da^H)tJWb*Y>B~tD(j<
zncRr;+^axLAgNWK)Wk7yhZ#JeIU3H$>c!1XnF<!U`}ye1JCXhDQfprIX>CyWW-8Oj
zH5I?gV#rYRZ428#<V4xG+EX(Oxn?@r=L&{XmNl6ILE%B3qZ2w)`=VdvvI|C<Oa^HZ
zjF3Y#2m;ox(mQ0eV)V-o^4_p}`WGU5k8-~5C-n$h!gTsaEc(_p<kJs<OC0Pzvgw6w
zQjrFAsihnSZ!^lfBx8Y}D7ePE2Q)XtnzuxYJB{_at}oA34nA|YIF$@?ut}eZdsU!E
ztLmpssYjuwKsl+J-5Di5x1GCbS2Os`H){2(UKOCHpQA(G<7xWLmT!K3zU}34q)&tG
zsz+QNF?T*pbucTAx;KUF3C-*Kf~{X%-tLL(lrfLIo_-3jCvm$VfK!39hdZ>pOVd0S
zLJ&dm?OnipKtzBF4w7J(YBX)ObNuA>ba_BM^&_`Dmf>L5%jMqXfwO8QwyXJ@%!1Z9
z+f`d-M>z-%f-Ew#S|YQ>77#`Xb}QCAhV~)xw`IRe7|GZa@2>3IHN5e&yGhoPDi~b>
z;uLN5b{gm)_h0J|!zTaY%d$+p(<elDXl*ISM67#ZQ-XZXLW_fU1G8rl@J-pz9Wxo@
z6h~cF;zC{z@<`V<FV@h9XoftV|FNNu?S~M8XG?bXb`BH*jHlx<;}1uJmXq}Fi7->f
zlakUH^y`l0ne;pN`eJ@1xv={$aN>t~JL-E^FbMS1Z5a5&h4>d!ci>O2;Q!Xu-6X0J
z(ZoX(y#9cI0V(a+Z{l{*zYhhPgi)Z0-bj@=%!Xnisv>zdn1rQB^6;$pIIhm6kRgcZ
zF!0SPF!0hBnuW?DSsDkTw6A=Xcef^Ek*X{=xg6?yu4G1dYpY-%YBdXO5rj}v<K1S*
z_^9XB?k^|kZFYE+Wu|%9h<{T$eVmHk(_^hW&7F^V5i41k)w6wBu}HjaB$2cyy>R`h
zjf)_w#Z%(&tVE@ppjPEFf{v2`cf_|{tIEoIj(TcM&W`I_;YhKAi%@E-4lRC-02?x_
z84H7(8R6^;)Us0!FaITx=;ZuGd3bsGe^Q=*ry2i|@+cWdX=v;J?<f!G97>>J#{V72
zb4~(&Lj%9MF8?RYBdsWd9tL{%cXIVN>iK^r3RO?b!x@E}6z#0+(b+(+VofLvjzXa*
zLMDka)P|mOF*I#ZbFzdwq1g_bq9uxF!CgFl?$UB~aIk^eqAAxo!urcf`cF>u(=eM`
z4`9TD;y`G#Ymk5tz{KPio9Q151l^baG+=c6J1qMjj`RnI0&xH6JeR`x^na&wmJk$W
zLuC*Rr-0|6?K|B2h1q<+Rm0yt-)NltJAOm^d^?{XR2goGKGHcC`wJ6F+q<H&1N>#2
zz#sG)Jy3NgdrMaf)D0lmEFf?vdjRkjkpC7BfX&*)#lcya8|6}tio%>A4%ToB=Uetp
zu$$j`r8MgH5H4_gI~laYIh%|yicW%fg!p)Pd3pHxfE+x6tUNq7e`%B#jh=q*wloAq
zFzsRI9X}t!U*_b05B0ti)QW%yW#LW0^Ya1V2ZQ;*04u=v7>e3~Q4kCL0NDK%;{k$s
zQCa&V#wUbY2EWI6P$mD20r><_m)zgV@qz>eQH$fZ7*LQ04a$Ct@c;$T1n;*PP=FVN
z%J-i!fq#}0K-0ND$_b$8-XAeR&_C*;GLL51ztu&>P+9sj#s~Vd4PFo*|DSE}g7`sy
zj*S-#M6b`^+W_<a+J=i01jUP;&TliK1^0xa=M8=SYTDbopy>5EdPHxd&w0T4B0Rs|
ZIJ-ccT+U~j7tAXtNO0qZtePCbe*qYuZ`S|-

literal 0
HcmV?d00001

diff --git a/test/visualization_tests_233.jl b/test/visualization_tests_233.jl
index 7170545..fd23a14 100644
--- a/test/visualization_tests_233.jl
+++ b/test/visualization_tests_233.jl
@@ -52,7 +52,8 @@ meta_graph = gppl_model.graph
 
         gen_dot_result = generate_dot(
             model_graph = gppl_model,
-            strategy = SimpleIteration(),
+            # strategy = SimpleIteration(),
+            strategy = :simple,
             font_size = 12,
             edge_length = 1.0,
             layout = "neato",
@@ -162,7 +163,7 @@ meta_graph = gppl_model.graph
 
         gen_dot_result = generate_dot(
             model_graph = gppl_model,
-            strategy = SimpleIteration(),
+            strategy = :simple,
             font_size = 12,
             edge_length = 1.0,
             layout = "neato",
@@ -182,7 +183,7 @@ meta_graph = gppl_model.graph
 
         gen_dot_result = generate_dot(
             model_graph = gppl_model,
-            strategy = SimpleIteration(),
+            strategy = :simple,
             font_size = 12,
             edge_length = 1.0,
             layout = "neato",
diff --git a/test/visualization_tests_233_v2.jl b/test/visualization_tests_233_v2.jl
new file mode 100644
index 0000000..0c76173
--- /dev/null
+++ b/test/visualization_tests_233_v2.jl
@@ -0,0 +1,74 @@
+using GraphPPL
+
+using Test
+
+using RxInfer
+using Distributions
+using Random
+using Graphs
+using MetaGraphsNext
+# using GraphViz
+using Dictionaries
+
+using Cairo
+using Fontconfig
+using Compose
+
+using GraphPlot
+
+include("../ext/GraphPPLGraphVizExt.jl")
+
+using .GraphPPLGraphVizExt: generate_dot, show_gv, dot_string_to_pdf
+
+
+## CREATE AN RXINFER.JL MODEL:
+# GraphPPL.jl export `@model` macro for model specification
+# It accepts a regular Julia function and builds an FFG under the hood
+@model function coin_model(y, a, b)
+    # We endow θ parameter of our model with some prior
+    θ ~ Beta(a, b)
+    # or, in this particular case, the `Uniform(0.0, 1.0)` prior also works:
+    # θ ~ Uniform(0.0, 1.0)
+
+    # We assume that outcome of each coin flip is governed by the Bernoulli distribution
+    for i in eachindex(y)
+        y[i] ~ Bernoulli(θ)
+    end
+end
+
+# condition the model on some observed data
+conditioned = coin_model(a = 2.0, b = 7.0) | (y = [ true, false, true ], )
+
+# `Create` the actual graph of the model conditioned on the data
+rxi_model = RxInfer.create_model(conditioned)
+
+gppl_model = RxInfer.getmodel(rxi_model)
+
+# Extract the MetaGraphsNext graph
+meta_graph = gppl_model.graph
+
+
+gen_dot_result_coin_simple = generate_dot(
+    model_graph = gppl_model,
+    strategy = :simple,
+    font_size = 12,
+    edge_length = 1.0,
+    layout = "neato",
+    overlap = false,
+    width = 10.0, 
+    height = 10.0 
+)
+
+gen_dot_result_coin_bfs = generate_dot(
+    model_graph = gppl_model,
+    strategy = :bfs,
+    font_size = 12,
+    edge_length = 1.0,
+    layout = "neato",
+    overlap = false,
+    width = 10.0, 
+    height = 10.0 
+)
+
+dot_string_to_pdf(gen_dot_result_coin_simple, "test_imgs/coin_model_simple_itr.pdf")
+dot_string_to_pdf(gen_dot_result_coin_bfs, "test_imgs/coin_model_bfs_itr.pdf")
\ No newline at end of file