urbanopt-cli 0.8.0 → 0.9.0

data/lib/uo_cli.rb

@@ -59,11 +59,14 @@ module URBANopt
     class UrbanOptCLI
       COMMAND_MAP = {
         'create' => 'Make new things - project directory or files',
+        'install_python' => 'Install python and other dependencies to run OpenDSS and DISCO analysis',
+        'update' => 'Update files in an existing URBANopt project',
         'run' => 'Use files in your directory to simulate district energy use',
         'process' => 'Post-process URBANopt simulations for additional insights',
         'visualize' => 'Visualize and compare results for features and scenarios',
         'validate' => 'Validate results with custom rules',
         'opendss' => 'Run OpenDSS simulation',
+        'disco' => 'Run DISCO analysis',
         'rnm' => 'Run RNM simulation',
         'delete' => 'Delete simulations for a specified scenario',
         'des_params' => 'Make a DES system parameters config file',
@@ -85,7 +88,7 @@ module URBANopt
           # opt :no_pager, "Disable paging"
           stop_on COMMAND_MAP.keys
           banner "\nCommands:"
-          COMMAND_MAP.each { |cmd, desc| banner format('  %-10s %s', cmd, desc) }
+          COMMAND_MAP.each { |cmd, desc| banner format('  %-14s %s', cmd, desc) }
           banner "\nFor help with a specific command: uo <command> --help"
           banner "\nAdditional config options can be set with the 'runner.conf' file inside your project folder"
           banner 'Fewer warnings are presented when using full paths and the user is not inside the project folder'
@@ -127,12 +130,25 @@ module URBANopt
           opt :electric, "\nCreate default project with FeatureFile containing electrical network, used for OpenDSS analysis\n" \
           'Example: uo create --project-folder urbanopt_example_project --electric', short: :l
 
-          opt :streets, "\nCreate default project wiht FeatureFile containing streets, used for RNM analysis\n" \
+          opt :disco, "\nCreate default project with FeatureFile containing electrical network, and scenarios for DISCO cost upgrade analysis\n"\
+          'Example: uo create --project-folder urbanopt_example_project --disco', short: :a
+
+          opt :streets, "\nCreate default project with FeatureFile containing streets, used for RNM analysis\n" \
           'Example: uo create --project-folder urbanopt_example_project --streets', short: :t
 
           opt :photovoltaic, "\nCreate default project with FeatureFile containing community photovoltaic for the district and ground-mount photovoltaic associated with buildings, used for REopt analysis \n" \
           'Example: uo create --project-folder urbanopt_example_project --photovoltaic', short: :v
 
+          opt :class_coincident, "\nCreate default class project with buildings that have coincident schedules \n" \
+          "Refer to https://docs.urbanopt.net/ for more details about the class project \n" \
+          "Used with --project-folder\n" \
+          "Example: uo create --project-folder urbanopt_example_project --class-coincident\n", short: :C
+
+          opt :class_diverse, "\nCreate default class project with buildings that have diverse schedules \n" \
+          "Refer to https://docs.urbanopt.net/ for more details about the class project \n" \
+          "Used with --project-folder\n" \
+          "Example: uo create --project-folder urbanopt_example_project --class-diverse\n", short: :D
+
           opt :empty, "\nUse with --project-folder argument to create an empty project folder\n" \
           "Then add your own Feature file in the project directory you created,\n" \
           "add Weather files in the weather folder and add OpenStudio models of Features\n" \
@@ -151,13 +167,33 @@ module URBANopt
           "Use the FeatureID from your FeatureFile\n" \
           "Requires 'scenario-file' also be specified, to say which FeatureFile will create the ScenarioFile\n" \
           "Example: uo create --single-feature 2 --scenario-file example_project.json\n", type: String, short: :i
-        
+
           opt :reopt_scenario_file, "\nCreate a ScenarioFile that includes a column defining the REopt assumptions file\n" \
           "Specify the existing ScenarioFile that you want to extend with REopt functionality\n" \
           "Example: uo create --reopt-scenario-file baseline_scenario.csv\n", type: String, short: :r
         end
       end
 
+      # Define commands to install python
+      def opt_install_python
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n \n"
+        end
+      end
+
+      # Update project
+      def opt_update
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n \n"
+
+          opt :existing_project_folder, "\Specify existing project folder name to update files \n" \
+          'Example: uo update --existing-project-folder urbanopt_example_project --new-project-directory location/to/new_urbanopt_example_project', type: String, short: :e
+
+          opt :new_project_directory, "\Specify location for updated URBANopt project. \n" \
+          'Example: uo update --existing-project-folder urbanopt_example_project --new-project-directory location/to/new_urbanopt_example_project', type: String, short: :n
+        end
+      end
+
       # Define running commands
       def opt_run
         @subopts = Optimist.options do
@@ -173,7 +209,7 @@ module URBANopt
 
           opt :num_parallel, "\nOPTIONAL: Run URBANopt simulations in parallel using <num_parallel> cores\n" \
           "Adjusts value of 'num_parallel' in the 'runner.conf' file\n" \
-          "Example: uo run --num-parallel 2\n", default: 2, short: :n
+          "Example: uo run --num-parallel 2\n", type: Integer, short: :n
         end
       end
 
@@ -220,11 +256,35 @@ module URBANopt
           opt :reopt, "\nRun with additional REopt functionality.\n" \
           'Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json --reopt', short: :r
 
+          opt :rnm, "\nUse RNM-generated DSS files in this analysis\n" \
+          'Example: uo opendss --scenario baseline_scenario.csv --feature example_project.json --rnm', short: :m
+
           opt :config, "\nRun OpenDSS using a json config file to specify the above settings.\n" \
           'Example: uo opendss --config path/to/config.json', type: String, short: :c
         end
       end
 
+      # Define DISCO commands
+      def opt_disco
+        @subopts = Optimist.options do
+          banner "\nURBANopt #{@command}:\n\n"
+
+          opt :scenario, "\nRun DISCO simulations for <scenario>\n" \
+          "Requires --feature also be specified\n" \
+          'Example: uo disco --scenario baseline_scenario-2.csv --feature example_project.json', default: 'baseline_scenario.csv', short: :s
+
+          opt :feature, "\nRun DISCO simulations according to <featurefile>\n" \
+          "Requires --scenario also be specified\n" \
+          'Example: uo disco --scenario baseline_scenario.csv --feature example_project.json', default: 'example_project_with_electric_network.json', short: :f
+
+          opt :cost_database, "\nSpecify cost database for electric equipment upgrade\n" \
+          'Example: uo disco --scenario baseline_scenario.csv --feature example_project.json --cost_database cost_database.xlsx', default: 'cost_database.xlsx', short: :c
+
+          opt :technical_catalog, "\nSpecify technical catalog for thermal upgrade\n" \
+          'Example: uo disco --scenario baseline_scenario.csv --feature example_project.json --technical_catalog technical_catalog.json', short: :t
+        end
+      end
+
       # Define RNM commands
       def opt_rnm
         @subopts = Optimist.options do
@@ -261,6 +321,8 @@ module URBANopt
 
           opt :opendss, "\nPost-process with OpenDSS"
 
+          opt :disco, "\nPost-process with DISCO"
+
           opt :reopt_scenario, "\nOptimize for entire scenario with REopt.  Used with the --reopt-scenario-assumptions-file to specify the assumptions to use.\n" \
           'Example: uo process --reopt-scenario'
 
@@ -414,31 +476,31 @@ module URBANopt
       end
 
       feature_file = URBANopt::GeoJSON::GeoFile.from_file(featurefile)
-      if @opthash.subopts[:reopt] == true || @opthash.subopts[:reopt_scenario] == true || @opthash.subopts[:reopt_feature] == true  
-        # TODO: Better way of grabbing assumptions file than the first file in the folder 
-        reopt_files_dir_contents_list = Dir.children(reopt_files_dir.to_s)  
-        reopt_assumptions_filename = File.basename(reopt_files_dir_contents_list[0])  
+      if @opthash.subopts[:reopt] == true || @opthash.subopts[:reopt_scenario] == true || @opthash.subopts[:reopt_feature] == true
+        # TODO: Better way of grabbing assumptions file than the first file in the folder
+        reopt_files_dir_contents_list = Dir.children(reopt_files_dir.to_s)
+        reopt_assumptions_filename = File.basename(reopt_files_dir_contents_list[0])
         scenario_output = URBANopt::Scenario::REoptScenarioCSV.new(
-          @scenario_name.downcase, 
-          @root_dir, 
-          run_dir, 
-          feature_file, 
-          mapper_files_dir, 
-          csv_file, 
-          num_header_rows, 
-          reopt_files_dir, 
+          @scenario_name.downcase,
+          @root_dir,
+          run_dir,
+          feature_file,
+          mapper_files_dir,
+          csv_file,
+          num_header_rows,
+          reopt_files_dir,
           reopt_assumptions_filename
-        ) 
-      else  
+        )
+      else
         scenario_output = URBANopt::Scenario::ScenarioCSV.new(
-          @scenario_name.downcase, 
-          @root_dir, 
-          run_dir, 
-          feature_file, 
-          mapper_files_dir, 
-          csv_file, 
+          @scenario_name.downcase,
+          @root_dir,
+          run_dir,
+          feature_file,
+          mapper_files_dir,
+          csv_file,
           num_header_rows
-        ) 
+        )
       end
       scenario_output
     end
@@ -487,12 +549,12 @@ module URBANopt
       end
     end
 
-    # Write new ScenarioFile with REopt column 
-    # params \  
-    # +existing_scenario_file+:: _string_ - Name of existing ScenarioFile 
-    def self.create_reopt_scenario_file(existing_scenario_file) 
-      existing_path, existing_name = File.split(File.expand_path(existing_scenario_file)) 
-      # make reopt folder (if it does not exist) 
+    # Write new ScenarioFile with REopt column
+    # params \
+    # +existing_scenario_file+:: _string_ - Name of existing ScenarioFile
+    def self.create_reopt_scenario_file(existing_scenario_file)
+      existing_path, existing_name = File.split(File.expand_path(existing_scenario_file))
+      # make reopt folder (if it does not exist)
       unless Dir.exist?(File.join(existing_path, 'reopt'))
         Dir.mkdir File.join(existing_path, 'reopt')
         # copy reopt files from cli examples
@@ -502,18 +564,18 @@ module URBANopt
             Pathname.new(reopt_files).children.each { |reopt_file| FileUtils.cp(reopt_file, File.join(existing_path, 'reopt')) }
           end
         end
-      end 
-     
-      table = CSV.read(existing_scenario_file, headers: true, col_sep: ',') 
-      # Add another column, row by row: 
-      table.each do |row| 
-        row['REopt Assumptions'] = 'multiPV_assumptions.json' 
-      end 
+      end
+
+      table = CSV.read(existing_scenario_file, headers: true, col_sep: ',')
+      # Add another column, row by row:
+      table.each do |row|
+        row['REopt Assumptions'] = 'multiPV_assumptions.json'
+      end
       # write new file (name it REopt + existing scenario name)
-      CSV.open(File.join(existing_path, 'REopt_' + existing_name), 'w') do |f|  
-        f << table.headers  
-        table.each { |row| f << row } 
-      end 
+      CSV.open(File.join(existing_path, "REopt_#{existing_name}"), 'w') do |f|
+        f << table.headers
+        table.each { |row| f << row }
+      end
     end
 
     # Create project folder
@@ -521,7 +583,7 @@ module URBANopt
     # +dir_name+:: _string_ Name of new project folder
     #
     # Includes weather for example location, a base workflow file, and mapper files to show a baseline and a high-efficiency option.
-    def self.create_project_folder(dir_name, empty_folder = false, overwrite_project = false)
+    def self.create_project_folder(dir_name, empty_folder: false, overwrite_project: false)
       case overwrite_project
       when true
         if Dir.exist?(dir_name)
@@ -544,12 +606,26 @@ module URBANopt
             Dir.mkdir File.join(dir_name, 'mappers')
             Dir.mkdir File.join(dir_name, 'osm_building')
             Dir.mkdir File.join(dir_name, 'visualization')
-            if @opthash.subopts[:electric] == true
+            if @opthash.subopts[:electric] == true || @opthash.subopts[:disco] == true
+              # make opendss folder
               Dir.mkdir File.join(dir_name, 'opendss')
+              if @opthash.subopts[:disco] == true
+                # make disco folder
+                Dir.mkdir File.join(dir_name, 'disco')
+              end
             end
 
             # copy config file
             FileUtils.cp(File.join(path_item, 'runner.conf'), dir_name)
+            # If the env var is set, change the num_parallel value to be what the env var is set to
+            if ENV['UO_NUM_PARALLEL']
+              runner_file_path = File.join(dir_name, 'runner.conf')
+              runner_conf_hash = JSON.parse(File.read(runner_file_path))
+              runner_conf_hash['num_parallel'] = ENV['UO_NUM_PARALLEL'].to_i
+              File.open(runner_file_path, 'w+') do |f|
+                f << runner_conf_hash.to_json
+              end
+            end
 
             # copy gemfile
             FileUtils.cp(File.join(path_item, 'Gemfile'), dir_name)
@@ -565,12 +641,18 @@ module URBANopt
             viz_files = File.join(path_item, 'visualization')
             Pathname.new(viz_files).children.each { |viz_file| FileUtils.cp(viz_file, File.join(dir_name, 'visualization')) }
 
-            if @opthash.subopts[:electric] == true
-              FileUtils.cp(File.join(path_item, 'example_project_with_electric_network.json'), dir_name)
-              # also create opendss folder
+            if @opthash.subopts[:electric] == true || @opthash.subopts[:disco] == true
+              # also copy opendss files
               dss_files = File.join(path_item, 'opendss')
               Pathname.new(dss_files).children.each { |file| FileUtils.cp(file, File.join(dir_name, 'opendss')) }
-
+              if @opthash.subopts[:electric] == true
+                FileUtils.cp(File.join(path_item, 'example_project_with_electric_network.json'), dir_name)
+              elsif @opthash.subopts[:disco] == true
+                # TODO: update this once there is a FeatureFile for Disco
+                FileUtils.cp(File.join(path_item, 'example_project_with_electric_network.json'), dir_name)
+                disco_files = File.join(path_item, 'disco')
+                Pathname.new(disco_files).children.each { |file| FileUtils.cp(file, File.join(dir_name, 'disco')) }
+              end
             elsif @opthash.subopts[:streets] == true
               FileUtils.cp(File.join(path_item, 'example_project_with_streets.json'), dir_name)
             elsif @opthash.subopts[:photovoltaic] == true
@@ -580,7 +662,7 @@ module URBANopt
             case @opthash.subopts[:floorspace]
             when false
 
-              if @opthash.subopts[:electric] != true && @opthash.subopts[:streets] != true && @opthash.subopts[:photovoltaic] != true
+              if @opthash.subopts[:electric] != true && @opthash.subopts[:streets] != true && @opthash.subopts[:photovoltaic] != true && @opthash.subopts[:disco] != true
                 # copy feature file
                 FileUtils.cp(File.join(path_item, 'example_project.json'), dir_name)
               end
@@ -633,6 +715,40 @@ module URBANopt
               FileUtils.cp(File.join(path_item, 'osm_building/9.osm'), File.join(dir_name, 'osm_building'))
             end
 
+            if @opthash.subopts[:class_coincident]
+              # copy residential files
+              FileUtils.cp_r(File.join(path_item, 'residential'), File.join(dir_name, 'mappers', 'residential'))
+              FileUtils.cp_r(File.join(path_item, 'measures'), File.join(dir_name, 'measures'))
+              FileUtils.cp_r(File.join(path_item, 'resources'), File.join(dir_name, 'resources'))
+              FileUtils.cp_r(File.join(path_item, 'xml_building'), File.join(dir_name, 'xml_building'))
+              # copy class project files
+              FileUtils.cp(File.join(path_item, 'class_project_coincident.json'), dir_name)
+              FileUtils.cp(File.join(path_item, 'mappers/class_project_workflow.osw'), File.join(dir_name, 'mappers', 'base_workflow.osw'))
+              FileUtils.cp(File.join(path_item, 'mappers/ClassProject.rb'), File.join(dir_name, 'mappers'))
+
+              if File.exist?(File.join(dir_name, 'example_project.json'))
+                FileUtils.remove(File.join(dir_name, 'example_project.json'))
+              end
+
+            end
+
+            if @opthash.subopts[:class_diverse]
+              # copy residential files
+              FileUtils.cp_r(File.join(path_item, 'residential'), File.join(dir_name, 'mappers', 'residential'))
+              FileUtils.cp_r(File.join(path_item, 'measures'), File.join(dir_name, 'measures'))
+              FileUtils.cp_r(File.join(path_item, 'resources'), File.join(dir_name, 'resources'))
+              FileUtils.cp_r(File.join(path_item, 'xml_building'), File.join(dir_name, 'xml_building'))
+              # copy class project files
+              FileUtils.cp(File.join(path_item, 'class_project_diverse.json'), dir_name)
+              FileUtils.cp(File.join(path_item, 'mappers/class_project_workflow.osw'), File.join(dir_name, 'mappers', 'base_workflow.osw'))
+              FileUtils.cp(File.join(path_item, 'mappers/ClassProject.rb'), File.join(dir_name, 'mappers'))
+
+              if File.exist?(File.join(dir_name, 'example_project.json'))
+                FileUtils.remove(File.join(dir_name, 'example_project.json'))
+              end
+
+            end
+
             if @opthash.subopts[:combined]
               # copy residential files
               FileUtils.cp_r(File.join(path_item, 'residential'), File.join(dir_name, 'mappers', 'residential'))
@@ -668,84 +784,355 @@ module URBANopt
       end
     end
 
-    # Check Python
+    # Update an existing URBANopt Project
     # params\
+    # +existing_project_folder+:: _string_ Name of existing project folder
+    # +new_project_directory+:: _string_ Location of updated URBANopt project
     #
-    # Check that sys has python 3.7+ installed
-    def self.check_python
-      results = { python: false, message: '' }
+    # Includes weather for example location, a base workflow file, and mapper files to show a baseline and a high-efficiency option.
+    def self.update_project(existing_project_folder, new_project_directory)
+      path = File.expand_path(existing_project_folder)
+      new_path = Pathname.new(new_project_directory)
+
+      if Dir.exist?(new_path)
+        abort("\nERROR:  there is already a directory here named #{new_path}... aborting\n---\n\n")
+      end
+
+      FileUtils.copy_entry(path, new_path)
+
+      $LOAD_PATH.each do |path_item|
+        if path_item.to_s.end_with?('example_files')
+
+          # copy gemfile
+          FileUtils.cp_r(File.join(path_item, 'Gemfile'), new_path, remove_destination: true)
+
+          # copy validation schema
+          FileUtils.cp_r(File.join(path_item, 'validation_schema.yaml'), new_path, remove_destination: true)
+
+          # copy config file
+          FileUtils.cp_r(File.join(path_item, 'runner.conf'), new_path, remove_destination: true)
+          # If the env var is set, change the num_parallel value to be what the env var is set to
+          # TODO: make this into a function...it's used in 2 places
+          if ENV['UO_NUM_PARALLEL']
+            runner_file_path = File.join(new_path, 'runner.conf')
+            runner_conf_hash = JSON.parse(File.read(runner_file_path))
+            runner_conf_hash['num_parallel'] = ENV['UO_NUM_PARALLEL'].to_i
+            File.open(runner_file_path, 'w+') do |f|
+              f << runner_conf_hash.to_json
+            end
+          end
+
+          # Replace standard mappers
+          # Note: this also copies createBar and Floorspace without checking project type (for now)
+          mappers = File.join(path_item, 'mappers')
+          Pathname.new(mappers).children.each { |mapper| FileUtils.cp_r(mapper, File.join(new_path, 'mappers'), remove_destination: true) }
+
+          # Replace OSM files
+          if Dir.exist?(File.join(path, 'osm_building'))
+            Pathname.new(File.join(path_item, 'osm_building')).children.each { |res| FileUtils.cp_r(res, File.join(new_path, 'osm_building'), remove_destination: true) }
+          end
+
+          # Replace weather
+          if Dir.exist?(File.join(path, 'weather'))
+            Pathname.new(File.join(path_item, 'weather')).children.each { |weather_file| FileUtils.cp_r(weather_file, File.join(new_path, 'weather'), remove_destination: true) }
+          end
+
+          # Replace visualization files
+          Pathname.new(File.join(path_item, 'visualization')).children.each { |viz| FileUtils.cp_r(viz, File.join(new_path, 'visualization'), remove_destination: true) }
+
+          # Replace Residential files
+          if Dir.exist?(File.join(path, 'residential'))
+            Pathname.new(File.join(path_item, 'residential')).children.each { |res| FileUtils.cp_r(res, File.join(new_path, 'mappers', 'residential'), remove_destination: true) }
+          end
+          if Dir.exist?(File.join(path, 'measures'))
+            Pathname.new(File.join(path_item, 'measures')).children.each { |res| FileUtils.cp_r(res, File.join(new_path, 'measures'), remove_destination: true) }
+          end
+          if Dir.exist?(File.join(path, 'resources'))
+            Pathname.new(File.join(path_item, 'resources')).children.each { |res| FileUtils.cp_r(res, File.join(new_path, 'resources'), remove_destination: true) }
+          end
+          # adjust for residential workflow
+          FileUtils.cp_r(File.join(path_item, 'base_workflow_res.osw'), File.join(new_path, 'mappers', 'base_workflow.osw'), remove_destination: true)
+          if Dir.exist?(File.join(path, 'xml_building'))
+            Pathname.new(File.join(path_item, 'xml_building')).children.each { |res| FileUtils.cp_r(res, File.join(new_path, 'xml_building'), remove_destination: true) }
+          end
+
+          # Replace Reopt assumption files
+          if Dir.exist?(File.join(path, 'reopt'))
+            Pathname.new(File.join(path_item, 'reopt')).children.each { |reopt_file| FileUtils.cp_r(reopt_file, File.join(new_path, 'reopt'), remove_destination: true) }
+          end
+
+          # Replace OpenDSS files
+          if Dir.exist?(File.join(path, 'opendss'))
+            Pathname.new(File.join(path_item, 'opendss')).children.each { |opendss_file| FileUtils.cp_r(opendss_file, File.join(new_path, 'opendss'), remove_destination: true) }
+          end
+
+          if Dir.exist?(File.join(path, 'disco'))
+            Pathname.new(File.join(path_item, 'disco')).children.each { |disco_file| FileUtils.cp_r(disco_file, File.join(new_path, 'disco'), remove_destination: true) }
+          end
+
+          Pathname.new(path).children.each do |file|
+            if File.extname(file) == '.json'
+              puts file
+              if File.exist?(File.join(path_item, file))
+                FileUtils.cp_r(File.join(path_item, file), new_path)
+              end
+            end
+          end
+
+        end
+      end
+    end
+
+    # Setup Python Variables for DiTTo and DISCO
+    def self.setup_python_variables
+      pvars = {
+        python_version: '3.10',
+        miniconda_version: '4.12.0',
+        python_install_path: nil,
+        python_path: nil,
+        pip_path: nil,
+        ditto_path: nil,
+        gmt_path: nil
+      }
+
+      # get location
+      $LOAD_PATH.each do |path_item|
+        if path_item.to_s.end_with?('example_files')
+          # install python in cli gem's example_files/python_deps folder
+          # so it is accessible to all projects
+          pvars[:python_install_path] = File.join(path_item, 'python_deps')
+          pvars[:pip_path] = pvars[:python_install_path]
+          break
+        end
+      end
+      # look for config file and grab info
+      if File.exist? File.join(pvars[:python_install_path], 'python_config.json')
+        configs = JSON.parse(File.read(File.join(pvars[:python_install_path], 'python_config.json')), symbolize_names: true)
+        pvars[:python_path] = configs[:python_path]
+        pvars[:pip_path] = configs[:pip_path]
+        pvars[:ditto_path] = configs[:ditto_path]
+        pvars[:gmt_path] = configs[:gmt_path]
+        pvars[:disco_path] = configs[:disco_path]
+      end
+      return pvars
+    end
+
+    # Return UO python packages list from python_deps/dependencies.json
+    def self.get_python_deps
+      deps = []
+      the_path = ""
+      $LOAD_PATH.each do |path_item|
+        if path_item.to_s.end_with?('example_files')
+          # install python in cli gem's example_files/python_deps folder
+          # so it is accessible to all projects
+          the_path = File.join(path_item, 'python_deps')
+          break
+        end
+      end
+
+      if File.exist? File.join(the_path, 'dependencies.json')
+        deps = JSON.parse(File.read(File.join(the_path, 'dependencies.json')), symbolize_names: true)
+      end
+      return deps
+    end
+
+    # Check Python
+    def self.check_python(python_only: false)
+      results = { python: false, pvars: [], message: '', python_deps: false, result: false }
       puts 'Checking system.....'
+      pvars = setup_python_variables
+      results[:pvars] = pvars
 
-      # platform agnostic
-      stdout, stderr, status = Open3.capture3('python3 -V')
-      if stderr && !stderr == ''
-        # error
-        results[:message] = "ERROR: #{stderr}"
+      # check vars
+      if pvars[:python_path].nil? || pvars[:pip_path].nil?
+        # need to install
+        results[:message] = 'Python paths have not yet been initialized with URBANopt.'
         puts results[:message]
         return results
       end
 
-      # check version
-      stdout.slice! 'Python3 '
-      if stdout[0].to_i == 2 || (stdout[0].to_i == 3 && stdout[2].to_i < 7)
-        # global python version is not 3.7+
-        results[:message] = "ERROR: Python version must be at least 3.7.  Found python with version #{stdout}."
+      # check python
+      stdout, stderr, status = Open3.capture3("#{pvars[:python_path]} -V")
+      if stderr.empty?
+        puts "...python found at #{pvars[:python_path]}"
+      else
+        results[:message] = "ERROR installing python: #{stderr}"
         puts results[:message]
         return results
-      else
-        puts "...Python >= 3.7 found (#{stdout.chomp})"
       end
 
       # check pip
-      stdout, stderr, status = Open3.capture3('pip3 -V')
-      if stderr && !stderr == ''
-        # error
+      stdout, stderr, status = Open3.capture3("#{pvars[:pip_path]} -V")
+      if stderr.empty?
+        puts "...pip found at #{pvars[:pip_path]}"
+      else
         results[:message] = "ERROR finding pip: #{stderr}"
         puts results[:message]
         return results
-      else
-        puts '...pip found'
       end
 
-      # all good
-      puts 'System check done.'
+      # python and pip installed correctly
       results[:python] = true
+
+      # now check dependencies (if python_only is false)
+      unless python_only
+        deps = get_python_deps
+        puts "DEPENDENCIES RETRIEVED FROM FILE: #{deps}"
+        errors = []
+        deps.each do |dep|
+          #TODO: Update when there is a stable release for DISCO
+          if dep[:name].to_s.include? "disco"
+            stdout, stderr, status = Open3.capture3("#{pvars[:pip_path]} show NREL-disco")
+          else 
+            stdout, stderr, status = Open3.capture3("#{pvars[:pip_path]} show #{dep[:name]}")
+          end
+          if stderr.empty?
+            # check versions
+            m = stdout.match /^Version: (\S{3,}$)/
+            err = true
+            if m and m.size > 1
+              if !dep[:version].nil? and dep[:version].to_s == m[1].to_s
+                puts "...#{dep[:name]} found with specified version #{dep[:version]}"
+                err = false
+              elsif dep[:version].nil?
+                err = false
+                puts "...#{dep[:name]} found (version #{m[1]})"
+              end
+            end
+            if err
+              results[:message] = "incorrect version found for #{dep[:name]}...expecting version #{dep[:version]}"
+              puts results[:message]
+              errors << stderr
+            end
+          else
+            results[:message] = stderr
+            puts results[:message]
+            errors << stderr
+          end
+        end
+        if errors.empty?
+          results[:python_deps] = true
+        end
+      end
+
+      # all is good
+      results[:result] = true
       return results
     end
 
-    def self.check_reader
-      results = { reader: false, message: '' }
+    # Install Python and Related Dependencies
+    def self.install_python_dependencies
+      pvars = setup_python_variables
+
+      # check if python and dependencies are already installed
+      results = check_python
+
+      # install python if not installed
+      if !results[:python]
+
+        # cd into script dir
+        wd = Dir.getwd
+        FileUtils.cd(pvars[:python_install_path])
+        puts 'Installing python...'
+        if (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM).nil?
+          # not windows
+          script = File.join(pvars[:python_install_path], 'install_python.sh')
+          the_command = "cd #{pvars[:python_install_path]}; #{script} #{pvars[:miniconda_version]} #{pvars[:python_version]} #{pvars[:python_install_path]}"
+          stdout, stderr, status = Open3.capture3(the_command)
+          if (stderr && !stderr == '') || (stdout && stdout.include?('Usage'))
+            # error
+            puts "ERROR installing python dependencies: #{stderr}, #{stdout}"
+            return
+          end
+          # capture paths
+          mac_path_base = File.join(pvars[:python_install_path], "Miniconda-#{pvars[:miniconda_version]}")
+          pvars[:python_path] = File.join(mac_path_base, 'bin', 'python')
+          pvars[:pip_path] = File.join(mac_path_base, 'bin', 'pip')
+          pvars[:ditto_path] = File.join(mac_path_base, 'bin', 'ditto_reader_cli')
+          pvars[:gmt_path] = File.join(mac_path_base, 'bin', 'uo_des')
+          pvars[:disco_path] = File.join(mac_path_base, 'bin', 'disco')
+          configs = {
+            python_path: pvars[:python_path],
+            pip_path: pvars[:pip_path],
+            ditto_path: pvars[:ditto_path],
+            gmt_path: pvars[:gmt_path],
+            disco_path: pvars[:disco_path]
+          }
+        else
+          # windows
+          script = File.join(pvars[:python_install_path], 'install_python.ps1')
+
+          command_list = [
+            'powershell Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process',
+            "powershell #{script} #{pvars[:miniconda_version]} #{pvars[:python_version]} #{pvars[:python_install_path]}",
+            'powershell $env:CONDA_DLL_SEARCH_MODIFICATION_ENABLE = 1'
+          ]
+
+          command_list.each do |command|
+            stdout, stderr, status = Open3.capture3(command)
+            if !stderr.empty?
+              puts "ERROR installing python dependencies: #{stderr}, #{stdout}"
+              break
+            end
+          end
+
+          # capture paths
+          windows_path_base = File.join(pvars[:python_install_path], "python-#{pvars[:python_version]}")
+          pvars[:python_path] = File.join(windows_path_base, 'python.exe')
+          pvars[:pip_path] = File.join(windows_path_base, 'Scripts', 'pip.exe')
+          pvars[:ditto_path] = File.join(windows_path_base, 'Scripts', 'ditto_reader_cli.exe')
+          pvars[:gmt_path] = File.join(windows_path_base, 'Scripts', 'uo_des.exe')
+          pvars[:disco_path] = File.join(windows_path_base, 'Scripts', 'disco.exe')
+
+          configs = {
+            python_path: pvars[:python_path],
+            pip_path: pvars[:pip_path],
+            ditto_path: pvars[:ditto_path],
+            gmt_path: pvars[:gmt_path],
+            disco_path: pvars[:disco_path]
+          }
+        end
 
-      puts 'Checking for urbanopt-ditto-reader...'
+        # get back to wd
+        FileUtils.cd(wd)
 
-      stdout, stderr, status = Open3.capture3('pip3 list')
-      if stderr && !stderr == ''
-        # error
-        results[:message] = 'ERROR running pip list'
-        puts results[:message]
-        return results
+        # write config file
+        File.open(File.join(pvars[:python_install_path], 'python_config.json'), 'w') do |f|
+          f.write(JSON.pretty_generate(configs))
+        end
       end
 
-      res = /^urbanopt-ditto-reader.*$/.match(stdout)
-      if res
-        # extract version
-        version = /\d+.\d+.\d+/.match(res.to_s)
-        path = res.to_s.split(' ')[-1]
-        puts "...path: #{path}"
-        if version
-          results[:message] = "Found urbanopt-ditto-reader version #{version}"
-          puts "...#{results[:message]}"
-          results[:reader] = true
-          puts "urbanopt-ditto-reader check done. \n\n"
-          return results
-        else
-          results[:message] = 'urbanopt-ditto-reader version not found.'
-          return results
+      # install python dependencies if not installed
+      if !results[:python_deps]
+        deps = get_python_deps
+        deps.each do |dep|
+          puts "Installing #{dep[:name]}..."
+          the_command = ""
+          if dep[:version].nil?
+            the_command = "#{pvars[:pip_path]} install #{dep[:name]}"
+          else
+            the_command = "#{pvars[:pip_path]} install #{dep[:name]}~=#{dep[:version]}"
+          end
+          # system(the_command)
+          #puts "INSTALL COMMAND: #{the_command}"
+          stdout, stderr, status = Open3.capture3(the_command)
+          if stderr && !stderr == ''
+            puts "Error installing: #{stderr}"
+          end
         end
+      end
+
+      # double check python and dependencies have been installed now
+      if !results[:result]
+        # double check that everything has succeeded now
+        results = check_python
+      end
+
+      if results[:result]
+        puts "Python and dependencies successfully installed in #{pvars[:python_install_path]}"
       else
-        # no ditto reader
-        results[:message] = 'urbanopt-ditto-reader not found.'
-        return results
+        # errors occurred
+        puts "Errors occurred when installing python and dependencies: #{results[:message]}"
       end
     end
 
@@ -756,10 +1143,10 @@ module URBANopt
       case @opthash.subopts[:overwrite]
       when true
         puts "\nOverwriting existing project folder: #{@opthash.subopts[:project_folder]}...\n\n"
-        create_project_folder(@opthash.subopts[:project_folder], empty_folder = false, overwrite_project = true)
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder: false, overwrite_project: true)
       when false
         puts "\nCreating a new project folder...\n"
-        create_project_folder(@opthash.subopts[:project_folder], empty_folder = false, overwrite_project = false)
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder: false, overwrite_project: false)
         if @opthash.subopts[:floorspace] == false && @opthash.subopts[:create_bar] == true
           puts "\nAn example FeatureFile is included: 'example_project.json'. You may place your own FeatureFile alongside the example."
         elsif @opthash.subopts[:floorspace] == true && @opthash.subopts[:create_bar] == false
@@ -773,10 +1160,10 @@ module URBANopt
       case @opthash.subopts[:overwrite]
       when true
         puts "\nOverwriting existing project folder: #{@opthash.subopts[:project_folder]} with an empty folder...\n\n"
-        create_project_folder(@opthash.subopts[:project_folder], empty_folder = true, overwrite_project = true)
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder: true, overwrite_project: true)
       when false
         puts "\nCreating a new empty project folder...\n"
-        create_project_folder(@opthash.subopts[:project_folder], empty_folder = true, overwrite_project = false)
+        create_project_folder(@opthash.subopts[:project_folder], empty_folder: true, overwrite_project: false)
       end
       puts "\nAdd your FeatureFile in the Project directory you just created."
       puts 'Add your weather data files in the Weather folder. They may be downloaded from energyplus.net/weather for free'
@@ -798,11 +1185,34 @@ module URBANopt
       end
     end
 
-    # Create REopt ScenarioFile from existing 
-    if @opthash.command == 'create' && @opthash.subopts[:reopt_scenario_file] 
-      puts "\nCreating ScenarioFile with REopt functionality, extending from #{@opthash.subopts[:reopt_scenario_file]}..."  
-      create_reopt_scenario_file(@opthash.subopts[:reopt_scenario_file])  
-      puts "\nDone" 
+    # Create REopt ScenarioFile from existing
+    if @opthash.command == 'create' && @opthash.subopts[:reopt_scenario_file]
+      puts "\nCreating ScenarioFile with REopt functionality, extending from #{@opthash.subopts[:reopt_scenario_file]}..."
+      create_reopt_scenario_file(@opthash.subopts[:reopt_scenario_file])
+      puts "\nDone"
+    end
+
+    # Graceful error if no flag is provided when using `create` command
+    if @opthash.command == 'create' &&
+       @opthash.subopts[:scenario_file].nil? &&
+       @opthash.subopts[:reopt_scenario_file].nil? &&
+       @opthash.subopts[:project_folder].nil?
+      abort("\nNo options provided to the `create` command. Did you forget the `-p` flag? See `uo create --help` for all options\n")
+    end
+
+    # Update existing URBANopt Project files
+    if @opthash.command == 'update'
+      puts "\nUpdating files in URBANopt project #{@opthash.subopts[:existing_project_folder]} and storing them in updated project folder at #{@opthash.subopts[:new_project_directory]}..."
+      update_project(@opthash.subopts[:existing_project_folder].to_s, @opthash.subopts[:new_project_directory].to_s)
+      puts "\nProject files updated to URBANopt CLI Version #{URBANopt::CLI::VERSION}...double check your runner.conf file as well as any other files you may have previously manually configured."
+      puts "\nDone"
+    end
+
+    # Install python and other dependencies
+    if @opthash.command == 'install_python'
+      puts "\nInstalling python and dependencies"
+      install_python_dependencies
+      puts "\nDone\n"
     end
 
     # Run simulations
@@ -812,13 +1222,13 @@ module URBANopt
       if ENV['UO_NUM_PARALLEL'] || @opthash.subopts[:num_parallel]
         runner_file_path = File.join(@root_dir, 'runner.conf')
         runner_conf_hash = JSON.parse(File.read(runner_file_path))
-        if ENV['UO_NUM_PARALLEL']
-          runner_conf_hash['num_parallel'] = ENV['UO_NUM_PARALLEL'].to_i
+        if @opthash.subopts[:num_parallel]
+          runner_conf_hash['num_parallel'] = @opthash.subopts[:num_parallel]
           File.open(runner_file_path, 'w+') do |f|
             f << runner_conf_hash.to_json
           end
-        elsif @opthash.subopts[:num_parallel]
-          runner_conf_hash['num_parallel'] = @opthash.subopts[:num_parallel].to_i
+        elsif ENV['UO_NUM_PARALLEL']
+          runner_conf_hash['num_parallel'] = ENV['UO_NUM_PARALLEL'].to_i
           File.open(runner_file_path, 'w+') do |f|
             f << runner_conf_hash.to_json
           end
@@ -842,18 +1252,10 @@ module URBANopt
       res = check_python
       if res[:python] == false
         puts "\nPython error: #{res[:message]}"
-        abort("\nYou must install Python 3.7 or above and pip to use this workflow \n")
-      end
-
-      # then check if ditto_reader is installed
-      res = check_reader
-      if res[:reader] == false
-        puts "\nURBANopt ditto reader error: #{res[:message]}"
-        abort("\nYou must install urbanopt-ditto-reader to use this workflow: pip install urbanopt-ditto-reader \n")
+        abort("\nPython dependencies are needed to run this workflow. Install with the CLI command: uo install_python  \n")
       end
 
       # If a config file is supplied, use the data specified there.
-      # absolute paths or paths relative to the location of the config file
       if @opthash.subopts[:config]
 
         opendss_config = JSON.parse(File.read(File.expand_path(@opthash.subopts[:config])), symbolize_names: true)
@@ -868,7 +1270,6 @@ module URBANopt
 
         puts "Scenario path: #{scenario_path}"
 
-        #config_root_dir = File.dirname(File.expand_path(config_scenario_file))
         config_root_dir = config_path
         run_dir = File.join(config_root_dir, 'run', config_scenario_name.downcase)
         featurefile = Pathname.new(opendss_config[:urbanopt_geojson_file])
@@ -878,9 +1279,6 @@ module URBANopt
 
         puts "Run Dir: #{run_dir}"
 
-        # NOTE: this is "fixed" from the CLI perspective.
-        # but Ditto reader CLI can't handle relative paths correctly so use absolute paths in the config file
-
       elsif @opthash.subopts[:scenario] && @opthash.subopts[:feature]
         # Otherwise use the user-supplied scenario & feature files
         run_dir = File.join(@root_dir, 'run', @scenario_name.downcase)
@@ -905,9 +1303,7 @@ module URBANopt
         abort("ERROR: URBANopt simulations are required before using opendss. Please run and process simulations, then try again.\n")
       end
 
-      # We're calling the python cli that gets installed when the user installs ditto-reader.
-      # If ditto-reader is installed into a venv (recommended), that venv must be activated when this command is called.
-      ditto_cli_root = 'ditto_reader_cli run-opendss '
+      ditto_cli_root = "#{res[:pvars][:ditto_path]} run-opendss "
       if @opthash.subopts[:config]
         ditto_cli_addition = "--config #{@opthash.subopts[:config]}"
       elsif @opthash.subopts[:scenario] && @opthash.subopts[:feature]
@@ -933,6 +1329,9 @@ module URBANopt
         if @opthash.subopts[:reopt]
           ditto_cli_addition += ' --reopt'
         end
+        if @opthash.subopts[:rnm]
+          ditto_cli_addition += ' --rnm'
+        end
         if @opthash.subopts[:upgrade]
           ditto_cli_addition += ' --upgrade'
         end
@@ -940,7 +1339,7 @@ module URBANopt
         abort("\nCommand must include ScenarioFile & FeatureFile, or a config file that specifies both. Please try again")
       end
       begin
-        puts "!!DITTO COMMAND: #{ditto_cli_root + ditto_cli_addition}"
+        puts "COMMAND: #{ditto_cli_root + ditto_cli_addition}"
         system(ditto_cli_root + ditto_cli_addition)
       rescue FileNotFoundError
         abort("\nMust post-process results before running OpenDSS. We recommend 'process --default'." \
@@ -948,6 +1347,82 @@ module URBANopt
       end
     end
 
+    # Run DISCO Simulation
+    if @opthash.command == 'disco'
+
+      # first check python and python dependencies
+      res = check_python
+      if res[:result] == false
+        puts "\nPython error: #{res[:message]}"
+        abort("\nPython dependencies are needed to run this workflow. Install with the CLI command: uo install_python  \n")
+      else
+        disco_path = res[:pvars][:disco_path]
+      end
+
+      # disco folder
+      disco_folder = File.join(@root_dir, 'disco')
+
+      # run folder
+      run_folder = File.join(@root_dir, 'run', @scenario_name.downcase)
+
+      # check of opendss models are created
+      opendss_file = File.join(run_folder, 'opendss/dss_files/Master.dss')
+      if !File.exist?(opendss_file)
+        abort("\nYou must run the OpenDSS analysis before running DISCO. Refer to 'opendss --help' for details on how to run th OpenDSS analysis.")
+      end
+
+      if @opthash.subopts[:technical_catalog]
+        # users can specify their technical catalogue name, placed in the disco folder
+        technical_catalog = @opthash.subopts[:technical_catalog]
+      else
+        technical_catalog = 'technical_catalog.json'
+      end
+
+      # set arguments in config hash
+      config_hash = JSON.parse(File.read(File.join(disco_folder, 'config.json')), symbolize_names: true)
+      config_hash[:upgrade_cost_database] = File.join(disco_folder, @opthash.subopts[:cost_database]) # Uses default cost database if not specified
+      if technical_catalog
+        config_hash[:thermal_upgrade_params][:read_external_catalog] = true
+        config_hash[:thermal_upgrade_params][:external_catalog] = File.join(disco_folder, technical_catalog)
+      end
+      config_hash[:jobs][0][:name] = @scenario_name
+      config_hash[:jobs][0][:opendss_model_file] = opendss_file
+
+      # save config file in run folder
+      File.open(File.join(run_folder, 'config.json'), 'w') { |f| f.write(JSON.pretty_generate(config_hash)) }
+
+      # call disco
+      FileUtils.cd(run_folder) do
+        if (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM).nil?
+          # not windows
+          if Dir.exist?(File.join(run_folder, 'disco'))
+            # if disco results folder exists overwrite folder
+            commands = ["#{disco_path} upgrade-cost-analysis run config.json -o disco --console-log-level=warn --force"]
+          else
+            commands = ["#{disco_path} upgrade-cost-analysis run config.json -o disco --console-log-level=warn"]
+          end
+        else
+          # windows
+          if Dir.exist?(File.join(run_folder, 'disco'))
+            # if disco results folder exists overwrite folder)
+            commands = ['powershell $env:CONDA_DLL_SEARCH_MODIFICATION_ENABLE = 1', "#{disco_path} upgrade-cost-analysis run config.json -o disco --console-log-level=warn --force"]
+          else
+            commands = ['powershell $env:CONDA_DLL_SEARCH_MODIFICATION_ENABLE = 1', "#{disco_path} upgrade-cost-analysis run config.json -o disco --console-log-level=warn"]
+          end
+        end
+        puts 'Running DISCO...'
+        commands.each do |command|
+          # TODO: This will be updated so stderr only reports error/warnings at DISCO level
+          stdout, stderr, status = Open3.capture3(command)
+          if !stderr.empty? 
+            puts "ERROR running DISCO: #{stderr}"
+          end
+        end
+        puts "Refer to detailed log file #{File.join(run_folder,'disco','run_upgrade_cost_analysis.log')} for more information on the run."
+        puts "Refer to the output summary file #{File.join(run_folder,'disco','output_summary.json')} for a summary of the results."
+      end
+    end
+
     # Run RNM Simulation
     if @opthash.command == 'rnm'
 
@@ -984,7 +1459,7 @@ module URBANopt
 
     # Post-process the scenario
     if @opthash.command == 'process'
-      if @opthash.subopts[:default] == false && @opthash.subopts[:opendss] == false && @opthash.subopts[:reopt_scenario] == false && @opthash.subopts[:reopt_feature] == false
+      if @opthash.subopts[:default] == false && @opthash.subopts[:opendss] == false && @opthash.subopts[:reopt_scenario] == false && @opthash.subopts[:reopt_feature] == false && @opthash.subopts[:disco] == false 
         abort("\nERROR: No valid process type entered. Must enter a valid process type\n")
       end
 
@@ -997,7 +1472,7 @@ module URBANopt
 
       default_post_processor = URBANopt::Scenario::ScenarioDefaultPostProcessor.new(run_func)
       scenario_report = default_post_processor.run
-      scenario_report.save(file_name = 'default_scenario_report', save_feature_reports = false)
+      scenario_report.save(file_name = 'default_scenario_report', save_feature_reports: false)
       scenario_report.feature_reports.each(&:save)
 
       if @opthash.subopts[:with_database] == true
@@ -1006,7 +1481,7 @@ module URBANopt
 
       if @opthash.subopts[:default] == true
         puts "\nDone\n"
-        results << { "process_type": 'default', "status": 'Complete', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
+        results << { process_type: 'default', status: 'Complete', timestamp: Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
       elsif @opthash.subopts[:opendss] == true
         puts "\nPost-processing OpenDSS results\n"
         opendss_folder = File.join(@root_dir, 'run', @scenario_name.downcase, 'opendss')
@@ -1018,14 +1493,30 @@ module URBANopt
           )
           opendss_post_processor.run
           puts "\nDone\n"
-          results << { "process_type": 'opendss', "status": 'Complete', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
+          results << { process_type: 'opendss', status: 'Complete', timestamp: Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
         else
-          results << { "process_type": 'opendss', "status": 'failed', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
+          results << { process_type: 'opendss', status: 'failed', timestamp: Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
           abort("\nNo OpenDSS results available in folder '#{opendss_folder}'\n")
         end
+      elsif @opthash.subopts[:disco] == true
+        puts "\nPost-processing DISCO results\n"
+        disco_folder = File.join(@root_dir, 'run', @scenario_name.downcase, 'disco')
+        if File.directory?(disco_folder)
+          disco_folder_name = File.basename(disco_folder)
+          disco_post_processor = URBANopt::Scenario::DISCOPostProcessor.new(
+            scenario_report,
+            disco_results_dir_name = disco_folder_name
+          )
+          disco_post_processor.run
+          puts "\nDone\n"
+          results << { process_type: 'disco', status: 'Complete', timestamp: Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
+        else
+          results << { process_type: 'disco', status: 'failed', timestamp: Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
+          abort("\nNo DISCO results available in folder '#{opendss_folder}'\n")
+        end
       elsif (@opthash.subopts[:reopt_scenario] == true) || (@opthash.subopts[:reopt_feature] == true)
         # Ensure reopt default files are prepared
-        #create_reopt_files(@opthash.subopts[:scenario])
+        # create_reopt_files(@opthash.subopts[:scenario])
 
         scenario_base = default_post_processor.scenario_base
 
@@ -1059,7 +1550,7 @@ module URBANopt
             run_resilience: @opthash.subopts[:reopt_resilience],
             community_photovoltaic: community_photovoltaic
           )
-          results << { "process_type": 'reopt_scenario', "status": 'Complete', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
+          results << { process_type: 'reopt_scenario', status: 'Complete', timestamp: Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
           puts "\nDone\n"
         elsif @opthash.subopts[:reopt_feature] == true
           puts "\nPost-processing each building individually with REopt\n"
@@ -1080,7 +1571,7 @@ module URBANopt
             keep_existing_output: @opthash.subopts[:reopt_keep_existing],
             groundmount_photovoltaic: groundmount_photovoltaic
           )
-          results << { "process_type": 'reopt_feature', "status": 'Complete', "timestamp": Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
+          results << { process_type: 'reopt_feature', status: 'Complete', timestamp: Time.now.strftime('%Y-%m-%dT%k:%M:%S.%L') }
           puts "\nDone\n"
         end
       end
@@ -1232,9 +1723,9 @@ module URBANopt
             if feature_eui_value > validation_params['EUI'][@opthash.subopts[:units]][building_type]['max']
               puts "\nFeature #{File.basename(feature_path)} EUI of #{feature_eui_value.round(2)} #{unit_value} is greater than the validation maximum."
             elsif feature_eui_value < validation_params['EUI'][@opthash.subopts[:units]][building_type]['min']
-              puts "\nFeature #{File.basename(feature_path)} EUI of #{feature_eui_value.round(2)} #{unit_value} is less than the validation minimum."
+              puts "\nFeature #{File.basename(feature_path)} (#{building_type}) EUI of #{feature_eui_value.round(2)} #{unit_value} is less than the validation minimum."
             else
-              puts "\nFeature #{File.basename(feature_path)} EUI of #{feature_eui_value.round(2)} #{unit_value} is within bounds set by #{validation_file_name}."
+              puts "\nFeature #{File.basename(feature_path)} (#{building_type}) EUI of #{feature_eui_value.round(2)} #{unit_value} is within bounds set by #{validation_file_name}."
             end
           end
         end
@@ -1242,9 +1733,15 @@ module URBANopt
     end
 
     if @opthash.command == 'des_params'
-      # We're calling the python cli that gets installed when the user pip installs geojson-modelica-reader.
-      # If geojson-modelica-reader is installed into a venv (recommended), that venv must be activated when this command is called.
-      des_cli_root = 'uo_des build-sys-param'
+
+      # first check python
+      res = check_python
+      if res[:python] == false
+        puts "\nPython error: #{res[:message]}"
+        abort("\nPython dependencies are needed to run this workflow. Install with the CLI command: uo install_python  \n")
+      end
+
+      des_cli_root = "#{res[:pvars][:gmt_path]} build-sys-param"
       if @opthash.subopts[:sys_param_file]
         des_cli_addition = " #{@opthash.subopts[:sys_param_file]}"
         if @opthash.subopts[:scenario]
@@ -1267,9 +1764,15 @@ module URBANopt
     end
 
     if @opthash.command == 'des_create'
-      # We're calling the python cli that gets installed when the user pip installs geojson-modelica-reader.
-      # If geojson-modelica-reader is installed into a venv (recommended), that venv must be activated when this command is called.
-      des_cli_root = 'uo_des create-model'
+
+      # first check python
+      res = check_python
+      if res[:python] == false
+        puts "\nPython error: #{res[:message]}"
+        abort("\nPython dependencies are needed to run this workflow. Install with the CLI command: uo install_python  \n")
+      end
+
+      des_cli_root = "#{res[:pvars][:gmt_path]} create-model"
       if @opthash.subopts[:sys_param]
         des_cli_addition = " #{@opthash.subopts[:sys_param]}"
         if @opthash.subopts[:feature]
@@ -1292,9 +1795,15 @@ module URBANopt
     end
 
     if @opthash.command == 'des_run'
-      # We're calling the python cli that gets installed when the user pip installs geojson-modelica-reader.
-      # If geojson-modelica-reader is installed into a venv (recommended), that venv must be activated when this command is called.
-      des_cli_root = 'uo_des run-model'
+
+      # first check python
+      res = check_python
+      if res[:python] == false
+        puts "\nPython error: #{res[:message]}"
+        abort("\nPython dependencies are needed to run this workflow. Install with the CLI command: uo install_python  \n")
+      end
+
+      des_cli_root = "#{res[:pvars][:gmt_path]} run-model"
       if @opthash.subopts[:model]
         des_cli_addition = " #{File.expand_path(@opthash.subopts[:model])}"
       else