From f8379c3268770d712703ebc14ab54640703289a9 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Tue, 7 Mar 2023 15:46:26 -0800 Subject: [PATCH 01/15] Implements scenario changes from #277 Changes how scenarios works per description in #277 and updates relevant documentation about API changes. Also: - various efficiencies and consistency fixes --- README.md | 16 +- network_wrangler/projectcard.py | 75 +-- network_wrangler/scenario.py | 985 ++++++++++++++++---------------- 3 files changed, 512 insertions(+), 564 deletions(-) diff --git a/README.md b/README.md index bd419b1a..c7506135 100644 --- a/README.md +++ b/README.md @@ -196,9 +196,19 @@ my_network.apply_project_card(...) # returns my_network.write_roadway_network(...) # returns ## Scenario Building -my_scenario = scenario_from_network(roadway_network, transit_network) -my_scenario.add_projects(directory, keyword) -my_scenario.write_networks(directory, format) +my_scenario = Scenario.create_scenario( + base_scenario=my_base_scenario, + card_search_dir=project_card_directory, + tags = ["baseline-2050"] + ) +my_scenario.apply_all_projects() +my_scenario.write("my_project/baseline", "baseline-2050") +my_scenario.summarize(outfile="scenario_summary_baseline.txt") + +my_scenario.add_projects_from_files(list_of_build_project_card_files) +my_scenario.queued_projects +my_scenario.apply_all_projects() +my_scenario.write("my_project/build", "baseline") ``` ## Attribution diff --git a/network_wrangler/projectcard.py b/network_wrangler/projectcard.py index e61d1889..0cf3b270 100644 --- a/network_wrangler/projectcard.py +++ b/network_wrangler/projectcard.py @@ -4,8 +4,8 @@ import os import yaml import json -from typing import List - +from typing import List, Collection +from pathlib import Path from jsonschema import validate from jsonschema.exceptions import ValidationError from jsonschema.exceptions import SchemaError @@ -21,6 +21,8 @@ class ProjectCard(object): valid: Boolean indicating if data conforms to project card data schema """ + FILE_TYPES = ["wr", "wrangler", "yml", "yaml"] + TRANSIT_CATEGORIES = ["Transit Service Property Change", "Add Transit"] # categories that may affect transit, but only as a secondary @@ -110,7 +112,7 @@ def read_wrangler_card(path_to_card: str) -> dict: _yaml, _pycode = cardfile.read().split(delim) WranglerLogger.debug("_yaml: {}\n_pycode: {}".format(_yaml, _pycode)) - attribute_dictionary = yaml.safe_load(_yaml) + attribute_dictionary = yaml.safe_load(_yaml.lower()) attribute_dictionary["file"] = path_to_card attribute_dictionary["pycode"] = _pycode.lstrip("\n") @@ -129,7 +131,7 @@ def read_yml(path_to_card: str) -> dict: WranglerLogger.debug("Reading YAML-Style Project Card") with open(path_to_card, "r") as cardfile: - attribute_dictionary = yaml.safe_load(cardfile) + attribute_dictionary = yaml.safe_load(cardfile.read().lower()) attribute_dictionary["file"] = path_to_card return attribute_dictionary @@ -194,10 +196,23 @@ def validate_project_card_schema( except yaml.YAMLError as exc: WranglerLogger.error(exc.message) + def has_any_tags(self, tags: Collection[str]) -> bool: + """Returns true if ProjectCard has at lest one tag in tags list. + + args: + tags: list of tags to search for + """ + if tags and set(tags).isdisjoint(self.tags): + WranglerLogger.debug( + f"Project card tags: {self.tags} don't match search tags: {tags}" + ) + return False + return True + @staticmethod def build_link_selection_query( selection: dict, - unique_model_link_identifiers: [], + unique_model_link_identifiers: list, mode: List[str] = ["drive_access"], ignore=[], ): @@ -263,53 +278,3 @@ def build_link_selection_query( sel_query = sel_query + ")" return sel_query - - def roadway_attribute_change(self, card: dict): - """ - Probably delete. - Reads a Roadway Attribute Change card. - - args: - card: the project card stored in a dictionary - """ - WranglerLogger.info(card.get("Category")) - - def new_roadway(self, card: dict): - """ - Probably delete. - Reads a New Roadway card. - - args: - card: the project card stored in a dictionary - """ - WranglerLogger.info(card.get("Category")) - - def transit_attribute_change(self, card: dict): - """ - Probably delete. - Reads a Transit Service Attribute Change card. - - args: - card: the project card stored in a dictionary - """ - WranglerLogger.info(card.get("Category")) - - def new_transit_right_of_way(self, card: dict): - """ - Probably delete. - Reads a New Transit Dedicated Right of Way card. - - args: - card: the project card stored in a dictionary - """ - WranglerLogger.info(card.get("Category")) - - def parallel_managed_lanes(self, card: dict): - """ - Probably delete. - Reads a Parallel Managed lanes card. - - args: - card: the project card stored in a dictionary - """ - WranglerLogger.info(card.get("Category")) diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index 05c8c266..d92139da 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -6,8 +6,9 @@ import glob import copy import pprint +from pathlib import Path from datetime import datetime -from typing import Union +from typing import Union, Mapping, Collection import pandas as pd import geopandas as gpd @@ -20,7 +21,8 @@ from .roadwaynetwork import RoadwayNetwork from .transitnetwork import TransitNetwork - +##NEXT +# do lazy evaluation of queued projects including evaluating conflicts, etc. class Scenario(object): """ Holds information about a scenario. @@ -47,617 +49,505 @@ class Scenario(object): project_card_directory = os.path.join(STPAUL_DIR, "project_cards") - project_cards_list = [ - ProjectCard.read(os.path.join(project_card_directory, filename), validate=False) - for filename in card_filenames - ] - my_scenario = Scenario.create_scenario( base_scenario=my_base_scenario, - project_cards_list=project_cards_list, + card_search_dir=project_card_directory, ) - my_scenario.check_scenario_requisites() + #check project card queue + my_scenario.queued_projects + + #apply the projects my_scenario.apply_all_projects() - my_scenario.scenario_summary() + #check applied projects + my_scenario.applied_projects + my_scenario.write("my_scenario","optionA") + my_scenario.summarize() Attributes: base_scenario: dictionary representation of a scenario - project_cards (Optional): list of Project Card Instances road_net: instance of RoadwayNetwork for the scenario transit_net: instance of TransitNetwork for the scenario + project_cards: Mapping[ProjectCard.name,ProjectCard] Storage of all project cards by name. + queued_projects: Projects which are "shovel ready" - have had pre-requisits checked and + done any required re-ordering. Similar to a git staging, project cards aren't recognized + in this collecton once they are moved to applied. applied_projects: list of project names that have been applied - project_cards: list of project card instances - ordered_project_cards: + projects: list of all projects either planned, queued, or applied prerequisites: dictionary storing prerequiste information corequisites: dictionary storing corequisite information conflicts: dictionary storing conflict information - requisites_checked: boolean indicating if the co- and pre-requisites - have been checked in the project cards - conflicts_checked: boolean indicating if the project conflicts have been checked - has_requisite_error: boolean indicating if there is a conflict in the pre- or - co-requisites of project cards - has_conflict_error: boolean indicating if there is are conflicting project cards - prerequisites_sorted: boolean indicating if the project cards have - been sorted to make sure cards that are pre-requisites are applied first """ - def __init__(self, base_scenario: dict, project_cards: [ProjectCard] = None): + def __init__( + self, + base_scenario: Union[Scenario, dict], + project_card_list: list[ProjectCard] = None, + name="", + ): """ Constructor args: base_scenario: dict the base scenario - project_cards: list this scenario's project cards + project_card_list: list of ProjectCard instances """ + WranglerLogger.info( + f"Creating Scenario with {len(project_card_list)} project cards" + ) - self.road_net = None - self.transit_net = None + if type(base_scenario) == "Scenario": + base_scenario = base_scenario.__dict__ self.base_scenario = base_scenario - + self.name = name # if the base scenario had roadway or transit networks, use them as the basis. - if self.base_scenario.get("road_net"): - self.road_net = copy.deepcopy(self.base_scenario["road_net"]) - if self.base_scenario.get("transit_net"): - self.transit_net = copy.deepcopy(self.base_scenario["transit_net"]) - - # if the base scenario had applied projects, add them to the list of applied - self.applied_projects = [] - if self.base_scenario.get("applied_projects"): - self.applied_projects = base_scenario["applied_projects"] - - self.project_cards = project_cards - self.ordered_project_cards = OrderedDict() - - self.prerequisites = {} - self.corequisites = {} - self.conflicts = {} + self.road_net = copy.deepcopy(self.base_scenario.get("road_net")) + self.transit_net = copy.deepcopy(self.base_scenario.get("transit_net")) - self.requisites_checked = False - self.conflicts_checked = False + self.project_cards = {} + self._planned_projects = [] + self._queued_projects = None + self.applied_projects = self.base_scenario.get("applied_projects", []) - self.has_requisite_error = False - self.has_conflict_error = False + self.prerequisites = self.base_scenario.get("prerequisites", {}) + self.corequisites = self.base_scenario.get("corequisites", {}) + self.conflicts = self.base_scenario.get("conflicts", {}) - self.prerequisites_sorted = False + for p in project_card_list: + self._add_project(p) - for card in self.project_cards: - if not card.__dict__.get("dependencies"): - continue - - if card.dependencies.get("prerequisites"): - self.prerequisites.update( - {card.project: card.dependencies["prerequisites"]} - ) - if card.dependencies.get("corequisites"): - self.corequisites.update( - {card.project: card.dependencies["corequisites"]} - ) + @property + def projects(self): + return self.applied_projects + self.queued_projects - @staticmethod - def create_base_scenario( - base_shape_name: str, - base_link_name: str, - base_node_name: str, - roadway_dir: str = "", - transit_dir: str = "", - validate: bool = True, - ) -> Scenario: - """ - args - ----- - roadway_dir: optional - path to the base scenario roadway network files - base_shape_name: - filename of the base network shape - base_link_name: - filename of the base network link - base_node_name: - filename of the base network node - transit_dir: optional - path to base scenario transit files - validate: - boolean indicating whether to validate the base network or not - """ - if roadway_dir: - base_network_shape_file = os.path.join(roadway_dir, base_shape_name) - base_network_link_file = os.path.join(roadway_dir, base_link_name) - base_network_node_file = os.path.join(roadway_dir, base_node_name) - else: - base_network_shape_file = base_shape_name - base_network_link_file = base_link_name - base_network_node_file = base_node_name - - road_net = RoadwayNetwork.read( - link_file=base_network_link_file, - node_file=base_network_node_file, - shape_file=base_network_shape_file, - fast=not validate, - ) + @property + def queued_projects(self): + if self._queued_projects is not None: + self._check_projects_requirements_satisfied(self._planned_projects) + self._queued_projects = self.order_projects(self._planned_projects) + return self._queued_projects - if transit_dir: - transit_net = TransitNetwork.read(transit_dir) - else: - transit_net = None - WranglerLogger.info( - "No transit directory specified, base scenario will have empty transit network." - ) - - transit_net.set_roadnet(road_net, validate_consistency=validate) - base_scenario = {"road_net": road_net, "transit_net": transit_net} - - return base_scenario + def __str__(self): + s = ["{}: {}".format(key, value) for key, value in self.__dict__.items()] + return "\n".join(s) @staticmethod def create_scenario( - base_scenario: dict = {}, - card_directory: str = "", - tags: [str] = None, - project_cards_list=None, + base_scenario: Union["Scenario", dict] = {}, + project_card_list=[], + project_card_file_list=[], + card_search_dir: str = "", glob_search="", - validate_project_cards=True, + filter_tags: Collection[str] = None, + validate=True, ) -> Scenario: """ - Validates project cards with a specific tag from the specified folder or - list of user specified project cards and - creates a scenario object with the valid project card. - - args - ----- - base_scenario: - object dictionary for the base scenario (i.e. my_base_scenario.__dict__) - tags: - only project cards with these tags will be read/validated - folder: - the folder location where the project cards will be - project_cards_list: - list of project cards to be applied - glob_search: + Creates scenario from a base scenario and adds project cards. - """ - WranglerLogger.info("Creating Scenario") + Project cards can be added using any/all of the following methods: + 1. List of ProjectCard instances + 2. List of ProjectCard files + 3. Directory and optional glob search to find project card files in - if project_cards_list is None: - project_cards_list = [] - else: - WranglerLogger.debug( - "Adding project cards from List.\n{}".format( - ",".join([p.project for p in project_cards_list]) - ) - ) + Checks that a project of same name is not already in scenario. + If selected, will validate ProjectCard before adding. + If provided, will only add ProjectCard if it matches at least one filter_tags. - scenario = Scenario(base_scenario, project_cards=project_cards_list) + args: + base_scenario: base Scenario scenario instances of dictionary of attributes. + project_card_list: List of ProjectCard instances to create Scenario from. + project_card_file_list: List of ProjectCard files to create Scenario from. + card_search_dir (str): Directory to search for project card files in. + glob_search (str, optional): Optional glob search parameters for card_search_dir. + filter_tags (Collection[str], optional): If used, will only add the project card if + its tags match one or more of these filter_tags. Defaults to [] + which means no tag-filtering will occur. + validate (bool, optional): If True, will validate the projectcard before + being adding it to the scenario. Defaults to True. + """ - if card_directory and tags: - WranglerLogger.debug( - "Adding project cards from directory and tags.\nDir: {}\nTags: {}".format( - card_directory, ",".join(tags) - ) + scenario = Scenario(base_scenario) + if project_card_list: + scenario.add_project_cards( + project_card_list, filter_tags=filter_tags, validate=validate ) - scenario.add_project_cards_from_tags( - card_directory, - tags=tags, - glob_search=glob_search, - validate=validate_project_cards, - ) - elif card_directory: - WranglerLogger.debug( - "Adding project cards from directory.\nDir: {}".format(card_directory) + if project_card_file_list: + scenario.add_projects_from_files( + project_card_file_list, filter_tags=filter_tags, validate=validate ) - scenario.add_project_cards_from_directory( - card_directory, glob_search=glob_search, validate=validate_project_cards - ) - return scenario - - def add_project_card_from_file( - self, project_card_file: str, validate: bool = True, tags: list = [] - ): - - WranglerLogger.debug( - "Trying to add project card from file: {}".format(project_card_file) - ) - project_card = ProjectCard.read(project_card_file, validate=validate) - - if project_card is None: - msg = "project card not read: {}".format(project_card_file) - WranglerLogger.error(msg) - raise ValueError(msg) - - if tags and set(tags).isdisjoint(project_card.tags): - WranglerLogger.debug( - "Project card tags: {} don't match search tags: {}".format( - ",".join(project_card.tags), ",".join(tags) - ) + if card_search_dir: + scenario.add_projects_from_directory( + card_search_dir, + glob_search=glob_search, + filter_tags=filter_tags, + validate=validate, ) - return - - if project_card.project in self.get_project_names(): - msg = f"project card with name '{project_card.project}' already in Scenario. \ - Project names must be unique" - WranglerLogger.error(msg) - raise ValueError(msg) - self.requisites_checked = False - self.conflicts_checked = False - self.prerequisites_sorted = False + return scenario - WranglerLogger.debug( - "Adding project card to scenario: {}".format(project_card.project) - ) - self.project_cards.append(project_card) + def _add_dependencies(self, project_name, dependencies: dict) -> None: + """Add dependencies from a project card to relevant scenario variables. - if not project_card.__dict__.get("dependencies"): - return + Updates existing "prerequisites", "corequisites" and "conflicts". + Lowercases everything to enable string matching. - WranglerLogger.debug("Adding project card dependencies") - if project_card.dependencies.get("prerequisites"): - self.prerequisites.update( - {project_card.project: project_card.dependencies["prerequisites"]} - ) - if project_card.dependencies.get("corequisites"): - self.corequisites.update( - {project_card.project: project_card.dependencies["corequisites"]} - ) - if project_card.dependencies.get("conflicts"): - self.conflicts.update( - {project_card.project: project_card.dependencies["conflicts"]} - ) - - def add_project_cards_from_directory( - self, folder: str, glob_search="", validate=True - ): + Args: + project_name: name of project you are adding dependencies for. + dependencies: Dictionary of depndencies by dependency type and list of associated projects. """ - Adds projects cards to the scenario. - A folder is provided to look for project cards and if applicable, a glob-style search. + project_name = project_name.lower() + WranglerLogger.debug(f"Adding {project_name} dependencies:\n{dependencies}") + for d in ["prerequisites", "corequisites", "conflicts"]: + if d not in dependencies: + continue + _dep = {k.lower(): map(str.lower, v) for k, v in dependencies[d].items()} + self.__dict__[d].update({project_name: _dep}) - i.e. glob_search = 'road*.yml' + def _add_project( + self, + project_card: ProjectCard, + validate: bool = True, + filter_tags: Collection[str] = [], + ) -> None: + """Adds a single ProjectCard instances to the Scenario. - args: - folder: the folder location where the project cards will be - glob_search: https://docs.python.org/2/library/glob.html - """ + Checks that a project of same name is not already in scenario. + If selected, will validate ProjectCard before adding. + If provided, will only add ProjectCard if it matches at least one filter_tags. - if not os.path.exists(folder): - msg = "Cannot find specified directory to add project cards: {}".format( - folder - ) - WranglerLogger.error(msg) - raise ValueError(msg) + Resets scenario queued_projects. - if glob_search: - WranglerLogger.info( - "Adding project cards using glob search: {}".format(glob_search) - ) - for file in glob.iglob(os.path.join(folder, glob_search)): - if not ( - file.endswith(".yml") - or file.endswith(".yaml") - or file.endswith(".wrangler") - or file.endswith(".wr") - ): - continue - else: - self.add_project_card_from_file(file, validate=validate) - else: - for file in os.listdir(folder): - if not ( - file.endswith(".yml") - or file.endswith(".yaml") - or file.endswith(".wrangler") - or file.endswith(".wr") - ): - continue - else: - self.add_project_card_from_file( - os.path.join(folder, file), validate=validate - ) + Args: + project_card (ProjectCard): ProjectCard instance to add to scenario. + validate (bool, optional): If True, will validate the projectcard before + being adding it to the scenario. Defaults to True. + filter_tags (Collection[str], optional): If used, will only add the project card if + its tags match one or more of these filter_tags. Defaults to [] + which means no tag-filtering will occur. - def add_project_cards_from_tags( - self, folder: str, tags: [str] = [], glob_search="", validate=True - ): """ - Adds projects cards to the scenario. - A folder is provided to look for project cards that have a matching tag that - is passed to the method. + project_name = project_card.project.lower() + filter_tags = map(str.lower, filter_tags) - args: - folder: the folder location where the project cards will be - tags: only project cards with these tags will be validated and added to the - returning scenario - """ + if project_name in self.projects: + raise ValueError( + f"Names not unique from existing scenario projects: {project_card.project}" + ) - if glob_search: + if filter_tags and project_card.tags.isdisjoint(filter_tags): WranglerLogger.debug( - "Adding project cards using \n-tags: {} and \nglob search: {}".format( - tags, glob_search - ) + f"Skipping {project_name} - no overlapping tags with {filter_tags}." ) - for file in glob.iglob(os.path.join(folder, glob_search)): - self.add_project_card_from_file(file, tags=tags, validate=validate) - else: - WranglerLogger.debug("Adding project cards using \n-tags: {}".format(tags)) - for file in os.listdir(folder): - self.add_project_card_from_file( - os.path.join(folder, file), tags=tags, validate=validate - ) + return - def __str__(self): - s = ["{}: {}".format(key, value) for key, value in self.__dict__.items()] - return "\n".join(s) + if validate: + project_card.validate() - def get_project_names(self) -> list: - """ - Returns a list of project names - """ - return [project_card.project for project_card in self.project_cards] + WranglerLogger.info(f"Adding {project_name} to scenario.") + self.project_cards[project_name] = project_card + self._planned_projects.append(project_name) + self._queued_projects = None + if "dependencies" in project_card: + self._add_dependencies(project_name, project_card.dependencies) - def check_scenario_conflicts(self) -> bool: - """ - Checks if there are any conflicting projects in the scenario - Fail if the project A specifies that project B is a conflict and project B is included - in the scenario + def add_project_cards( + self, + project_card_list: Collection[ProjectCard], + validate: bool = True, + filter_tags: Collection[str] = [], + ) -> None: + """Adds a list of ProjectCard instances to the Scenario. + + Checks that a project of same name is not already in scenario. + If selected, will validate ProjectCard before adding. + If provided, will only add ProjectCard if it matches at least one filter_tags. - Returns: boolean indicating if the check was successful or returned an error + Args: + project_card_list (Collection[ProjectCard]): List of ProjectCard instances to add to + scenario. + validate (bool, optional): If True, will require each ProjectCard is validated before + being added to scenario. Defaults to True. + filter_tags (Collection[str], optional): If used, will filter ProjectCard instances + and only add those whose tags match one or more of these filter_tags. Defaults to [] + which means no tag-filtering will occur. """ + for p in project_card_list: + self._add_project(p, validate=validate, filter_tags=filter_tags) - conflict_dict = self.conflicts - scenario_projects = [p.project for p in self.project_cards] + def add_projects_from_files( + self, + project_card_file_list: Collection[str], + validate: bool = True, + filter_tags: Collection[str] = [], + ) -> None: + """Adds a list of ProjectCard files to the Scenario. - for project, conflicts in conflict_dict.items(): - if conflicts: - for name in conflicts: - if name in scenario_projects: - self.project_cards - WranglerLogger.error( - "Projects %s has %s as conflicting project" - % (project, name) - ) - self.has_conflict_error = True + Creates ProjectCard instances from each file. + Checks that a project of same name is not already in scenario. + If selected, will validate ProjectCard before adding. + If provided, will only add ProjectCard if it matches at least one filter_tags. - self.conflicts_checked = True + Args: + project_card_file_list (Collection[str]): List of project card files to add to scenario. + validate (bool, optional): If True, will require each ProjectCard is validated before + being added to scenario. Defaults to True. + filter_tags (Collection[str], optional): If used, will filter ProjectCard instances + and only add those whose tags match one or more of these filter_tags. Defaults to [] + which means no tag-filtering will occur. + """ + _project_card_list = [ + ProjectCard.read(_pc_file) for _pc_file in project_card_file_list + ] + self.add_project_cards( + _project_card_list, validate=validate, filter_tags=filter_tags + ) - return self.has_conflict_error + def add_projects_from_directory( + self, + search_dir: str, + glob_search: str = "", + validate: bool = True, + filter_tags: Collection[str] = [], + ) -> None: + """Adds ProjectCards from project card files found in a directory to the Scenario. - def check_scenario_requisites(self) -> bool: - """ - Checks if there are any missing pre- or co-requisite projects in the scenario - Fail if the project A specifies that project B is a pre- or co-requisite and project B is - not included in the scenario + Finds files in directory which have ProjectCard.FILE_TYPE suffices. + If provided, will filter directory search using glob_search pattern. + Creates ProjectCard instances from each file. + Checks that a project of same name is not already in scenario. + If selected, will validate ProjectCard before adding. + If provided, will only add ProjectCard if it matches at least one filter_tags. - Returns: boolean indicating if the checks were successful or returned an error + Args: + search_dir (str): Search directory. + glob_search (str, optional): Optional glob search parameters. + validate (bool, optional): If True, will require each ProjectCard is validated before + being added to scenario. Defaults to True. + filter_tags (Collection[str], optional): If used, will filter ProjectCard instances + and only add those whse tags match one or more of these filter_tags. Defaults to [] + which means no tag-filtering will occur. """ + _project_card_file_list = project_card_files_from_directory( + search_dir, glob_search + ) + self.add_projects_from_files( + _project_card_file_list, validate=validate, filter_tags=filter_tags + ) - corequisite_dict = self.corequisites - prerequisite_dict = self.prerequisites - - scenario_projects = [p.project for p in self.project_cards] + def _check_projects_requirements_satisfied(self, project_list: Collection[str]): + """Checks that all requirements are satisified to apply this specific set of projects including: - for project, coreq in corequisite_dict.items(): - if coreq: - for name in coreq: - if name not in scenario_projects: - WranglerLogger.error( - f"Projects {project} has {name} as corequisite project which is \ - missing for the scenario" - ) - self.has_requisite_error = True + 1. has an associaed project card + 2. is in scenario's planned projects + 3. pre-requisites satisfied + 4. co-requisies satisfied by applied or co-applied projects + 5. no conflicing applied or co-applied projects - for project, prereq in prerequisite_dict.items(): - if prereq: - for name in prereq: - if name not in scenario_projects: - WranglerLogger.error( - f"Projects{project} has {name} as prerequisite project which is \ - missing for the scenario" - ) - self.has_requisite_error = True + Args: + project_name (str): name of project. + co_applied_project_list (Collection[str]): List of projects that will be applied with this project. + """ + self._check_projects_planned(project_list) + self._check_projects_have_project_cards(project_list) + self._check_projects_prerequisites(project_list) + self._check_projects_corequisites(project_list) + self._check_projects_conflicts(project_list) + + def _check_projects_planned(self, project_names: Collection[str]) -> None: + """Checks that a list of projects are in the scenario's planned projects.""" + _missing_ps = [ + p for p in self.planned_projects if p not in self.planned_projects + ] + if _missing_ps: + raise ValueError( + f"Projects are not in planned projects:\n {_missing_ps}. Add them by \ + using add_project_cards(), add_projects_from_files(), or add_projects_from_directory()." + ) - self.requisites_checked = True + def _check_projects_have_project_cards(self, project_list: Collection[str]) -> bool: + """Checks that a list of projects has an associated project card in the scenario.""" + _missing = [p for p in project_list if p not in self.project_cards] + if _missing: + WranglerLogger.error( + f"Projects referenced which are missing project cards: {_missing}" + ) + return False + return True - return self.has_requisite_error + def _check_projects_prerequisites(self, project_names: str) -> None: + """Checks that a list of projects' pre-requisites have been or will be applied to scenario.""" + if project_names.is_disjoint(self.prerequisites): + return + _prereqs = set( + [self.prerequisites[p] for p in project_names if p in self.prerequisites] + ) + _projects_applied = set(self.applied_projects + project_names) + _missing = list(_prereqs - _projects_applied) + if _missing: + raise ValueError(f"Missing {len(_missing)} pre-requites: {_missing}") + + def _check_projects_corequisites(self, project_names: str) -> None: + """Checks that a list of projects' co-requisites have been or will be applied to scenario.""" + if project_names.is_disjoint(self.corequisites): + return + _coreqs = set( + [self.corequisites[p] for p in project_names if p in self.corequisites] + ) + _projects_applied = set(self.applied_projects + project_names) + _missing = list(_coreqs - _projects_applied) + if _missing: + raise ValueError(f"Missing {len(_missing)} corequites: {_missing}") + + def _check_projects_conflicts(self, project_names: str) -> None: + """Checks that a list of projects' conflicts have not been or will be applied to scenario.""" + projects_to_check = project_names + self.applied_projects + if projects_to_check.is_disjoint(self.conflicts): + return + _conflicts = list( + set([self.conflicts[p] for p in projects_to_check if p in self.conflicts]) + ) + _conflict_problems = [p for p in _conflicts if p in projects_to_check] + if _conflict_problems: + WranglerLogger.warning(f"Conflict Problems: \n{_conflict_problems}") + _conf_dict = { + k: v + for k, v in self.conflicts.items() + if k in projects_to_check and not v.is_disjoint(_conflict_problems) + } + WranglerLogger.debug(f"Problematic Conflicts:\n{_conf_dict}") + raise ValueError(f"Found {len(_conflicts)} conflicts: {_conflict_problems}") - def order_project_cards(self): + def order_projects(self, project_list: Collection[str]) -> Collection[str]: """ - create a list of project cards such that they are in order based on pre-requisites + Orders a list of projects based on moving up pre-requisites. - Returns: ordered list of project cards to be applied to scenario - """ + args: + project_list: list of projects to order - scenario_projects = [p.project.lower() for p in self.project_cards] + Returns: ordered list of project cards based on pre-requisites + """ + project_list = [p.lower() for p in project_list] + assert self._check_projects_have_project_cards(project_list) # build prereq (adjacency) list for topological sort adjacency_list = defaultdict(list) visited_list = defaultdict() - for project in scenario_projects: + for project in project_list: visited_list[project] = False if not self.prerequisites.get(project): continue for prereq in self.prerequisites[project]: # this will always be true, else would have been flagged in missing \ # prerequsite check, but just in case - if prereq.lower() in scenario_projects: + if prereq.lower() in project_list: adjacency_list[prereq.lower()] = [project] # sorted_project_names is topological sorted project card names (based on prerequsiite) - sorted_project_names = topological_sort( + ordered_projects = topological_sort( adjacency_list=adjacency_list, visited_list=visited_list ) - # get the project card objects for these sorted project names - project_card_and_name_dict = {} - for project_card in self.project_cards: - project_card_and_name_dict[project_card.project.lower()] = project_card + if not set(ordered_projects) == set(project_list): + _missing = list(set(project_list) - set(ordered_projects)) + raise ValueError(f"Project sort resulted in missing projects:_missing") - sorted_project_cards = [ - project_card_and_name_dict[project_name] - for project_name in sorted_project_names - ] + WranglerLogger.debug(f"Ordered Projects:\n{ordered_projects}") - try: - assert len(sorted_project_cards) == len(self.project_cards) - except: - msg = "Sorted project cards ({}) are not of same number as unsorted ({}).".format( - len(sorted_project_cards), len(self.project_cards) - ) - WranglerLogger.error(msg) - raise ValueError(msg) - - self.prerequisites_sorted = True - self.ordered_project_cards = { - project_name: project_card_and_name_dict[project_name] - for project_name in sorted_project_names - } - - WranglerLogger.debug( - "Ordered Project Cards: {}".format(self.ordered_project_cards) - ) - self.project_cards = sorted_project_cards - - WranglerLogger.debug("Project Cards: {}".format(self.project_cards)) - - return sorted_project_cards + return ordered_projects def apply_all_projects(self): + """Applies all planned projects in the queue.""" + + for p in self.queued_projects: + self._apply_project(p) - # Get everything in order + def _apply_change(self, change: dict) -> None: + """Applies a specific change specified in a project card. - if not self.requisites_checked: - self.check_scenario_requisites() - if not self.conflicts_checked: - self.check_scenario_conflicts() - if not self.prerequisites_sorted: - self.order_project_cards() + "category" must be in at least one of: + - ROADWAY_CATEGORIES + - TRANSIT_CATEGORIES - for p in self.project_cards: - self.apply_project(p.__dict__) + Args: + change (dict): dictionary of a project card change + """ + if change["category"] in ProjectCard.ROADWAY_CATEGORIES: + if not self.road_net: + raise ("Missing Roadway Network") + self.road_net.apply(change) + if change["category"] in ProjectCard.TRANSIT_CATEGORIES: + if not self.transit_net: + raise ("Missing Transit Network") + self.transit_net.apply(change) + if ( + change["category"] in ProjectCard.SECONDARY_TRANSIT_CATEGORIES + and self.transit_net + ): + self.transit_net.apply(change) + + if ( + change["category"] + not in ProjectCard.TRANSIT_CATEGORIES + ProjectCard.ROADWAY_CATEGORIES + ): + raise ValueError(f"Don't understand project category: {change['category']}") + + def _apply_project(self, project_name: str) -> None: + """Applies project card to scenario. + + If a list of changes is specified in referenced project card, iterates through each change. - def apply_project(self, p): - if isinstance(p, ProjectCard): - p = p.__dict__ + Args: + project_name (str): name of project to be applied. + """ + project_name = project_name.lower() - if p.get("project"): - WranglerLogger.info("Applying {}".format(p["project"])) + WranglerLogger.info(f"Applying {project_name}") - if p.get("changes"): + p = self.project_cards[project_name].__dict__ + if "changes" in p: for pc in p["changes"]: pc["project"] = p["project"] - self.apply_project(pc) + self._apply_change(pc) else: - if p["category"] in ProjectCard.ROADWAY_CATEGORIES: - if not self.road_net: - raise ("Missing Roadway Network") - self.road_net.apply(p) - if p["category"] in ProjectCard.TRANSIT_CATEGORIES: - if not self.transit_net: - raise ("Missing Transit Network") - self.transit_net.apply(p) - if ( - p["category"] in ProjectCard.SECONDARY_TRANSIT_CATEGORIES - and self.transit_net - ): - self.transit_net.apply(p) - - if p["project"] not in self.applied_projects: - self.applied_projects.append(p["project"]) - - def remove_all_projects(self): - self.project_cards = [] - - def applied_project_card_summary(self, project_card_dictionary: dict) -> dict: - """ - Create a summary of applied project card and what they changed for the scenario. + self._apply_change(p) - Args: - project_card_dictionary: dictionary representation of the values of a project card - (i.e. ProjectCard.__dict__ ) + self.applied_projects.append(project_name) - Returns: - A dict of project summary change dictionaries for each change + def apply_projects(self, project_list: Collection[str]): """ - changes = project_card_dictionary.get("changes", [project_card_dictionary]) - - summary = { - "project_card": project_card_dictionary["file"], - "total_parts": len(changes), - } - - def _summarize_change_roadway(change: dict, change_summary: dict): + Applies a specific list of projects from the planned project queue. - sel_key = RoadwayNetwork.build_selection_key( - self.road_net, change["facility"] - ) + Will order the list of projects based on pre-requisites. - change_summary["sel_idx"] = self.road_net.selections[sel_key][ - "selected_links" - ].index.tolist() + NOTE: does not check co-requisites b/c that isn't possible when applying a sin - change_summary["attributes"] = [p["property"] for p in change["properties"]] - - if type(sel_key) == tuple: - _, A_id, B_id = sel_key - else: - A_id, B_id = (None, None) - - change_summary["map"] = self.road_net.selection_map( - change_summary["sel_idx"], - A=A_id, - B=B_id, - candidate_link_idx=self.road_net.selections[sel_key] - .get("candidate_links", pd.DataFrame([])) - .index.tolist(), - ) - return change_summary - - def _summarize_add_roadway(change: dict, change_summary: dict): - change_summary["added_links"] = pd.DataFrame(change.get("links")) - change_summary["added_nodes"] = pd.DataFrame(change.get("nodes")) - change_summary["map"] = RoadwayNetwork.addition_map( - self.road_net, - change.get("links"), - change.get("nodes"), - ) - return change_summary - - def _summarize_deletion(change: dict, change_summary: dict): - change_summary["deleted_links"] = change.get("links") - change_summary["deleted_nodes"] = change.get("nodes") - change_summary["map"] = RoadwayNetwork.deletion_map( - self.base_scenario["road_net"], - change.get("links"), - change.get("nodes"), - ) - return change_summary + Args: + project_list: List of projects to be applied. All need to be in the planned project queue. + """ + project_list = [p.lower() for p in project_list] - for i, change in enumerate(changes): - WranglerLogger.debug( - "Summarizing {} Part: {}".format( - project_card_dictionary["project"], i + 1 - ) - ) - change_summary = { - "project": project_card_dictionary["project"] + " – Part " + str(i + 1), - "category": change["category"].lower(), - } + self._check_projects_requirements_satisfied(project_list) + ordered_projects = self.order_projects(project_list) - if change["category"].lower() == "roadway deletion": - change_summary = _summarize_deletion(change, change_summary) - elif change["category"].lower() == "add new roadway": - change_summary = _summarize_add_roadway(change, change_summary) - elif change["category"].lower() in [ - "roadway property change", - "parallel managed lanes", - ]: - change_summary = _summarize_change_roadway(change, change_summary) + for p in ordered_projects: + self._apply_project(p) - summary["Part " + str(i + 1)] = change_summary + def write(self, path: Union(Path, str), name: str) -> None: + """_summary_ - return summary + Args: + path: Path to write scenario networks and scenario summary to. + name: Name to use. + """ + self.road_net.write(path, name) + self.transit_net.write(path, name) + self.summarize(outfile=os.path.join(path, name)) - def scenario_summary( + def summarize( self, project_detail: bool = True, outfile: str = "", mode: str = "a" ) -> str: """ @@ -673,28 +563,20 @@ def scenario_summary( """ - WranglerLogger.info("Summarizing Scenario") + WranglerLogger.info(f"Summarizing Scenario {self.name}") report_str = "------------------------------\n" - report_str += "Scenario created on {}\n".format(datetime.now()) + report_str += f"Scenario created on {datetime.now()}\n" report_str += "Base Scenario:\n" report_str += "--Road Network:\n" - report_str += "----Link File: {}\n".format( - self.base_scenario["road_net"].link_file - ) - report_str += "----Node File: {}\n".format( - self.base_scenario["road_net"].node_file - ) - report_str += "----Shape File: {}\n".format( - self.base_scenario["road_net"].shape_file - ) + report_str += f"----Link File: {self.base_scenario['road_net'].link_file}\n" + report_str += f"----Node File: {self.base_scenario['road_net'].node_file}\n" + report_str += f"----Shape File: {self.base_scenario['road_net'].shape_file}\n" report_str += "--Transit Network:\n" - report_str += "----Feed Path: {}\n".format( - self.base_scenario["transit_net"].feed_path - ) + report_str += f"----Feed Path: {self.base_scenario['transit_net'].feed_path}\n" report_str += "\nProject Cards:\n -" - report_str += "\n-".join(p.file for p in self.project_cards) + report_str += "\n-".join([pc.file for p, pc in self.project_cards.items()]) report_str += "\nApplied Projects:\n-" report_str += "\n-".join(self.applied_projects) @@ -703,13 +585,15 @@ def scenario_summary( report_str += "\n---Project Card Details---\n" for p in self.project_cards: report_str += "\n{}".format( - pprint.pformat(self.applied_project_card_summary(p.__dict__)) + pprint.pformat( + [self.project_cards[p].__dict__ for p in self.applied_projects] + ) ) if outfile: with open(outfile, mode) as f: f.write(report_str) - WranglerLogger.info("Wrote Scenario Report to: {}".format(outfile)) + WranglerLogger.info(f"Wrote Scenario Report to: {outfile}") return report_str @@ -783,3 +667,92 @@ def net_to_mapbox( "If mbview isn't installed, try `npm install -g @mapbox/mbview` or \ visit https://github.com/mapbox/mbview" ) + + +def project_card_files_from_directory( + search_dir: str, glob_search="" +) -> Collection[str]: + """Returns a list of ProjectCard instances from searching a directory. + + Args: + search_dir (str): Search directory. + glob_search (str, optional): Optional glob search parameters. + + Returns: + Collection[cls]: list of ProjectCard isntances. + """ + + project_card_files = [] + if not Path(search_dir).exists(): + raise ValueError( + "Cannot find specified directory to find project cards: {search_dir}" + ) + + if glob_search: + WranglerLogger.debug(f"Finding project cards using glob search: {glob_search}") + for f in glob.iglob(os.path.join(search_dir, glob_search)): + if not Path(f).suffix in ProjectCard.FILE_TYPES: + continue + else: + project_card_files.append(f) + else: + for f in os.listdir(search_dir): + if not Path(f).suffix in ProjectCard.FILE_TYPES: + continue + else: + project_card_files.append(f) + return project_card_files + + +def create_base_scenario( + base_shape_name: str, + base_link_name: str, + base_node_name: str, + roadway_dir: str = "", + transit_dir: str = "", + validate: bool = True, +) -> Scenario: + """ + args + ----- + roadway_dir: optional + path to the base scenario roadway network files + base_shape_name: + filename of the base network shape + base_link_name: + filename of the base network link + base_node_name: + filename of the base network node + transit_dir: optional + path to base scenario transit files + validate: + boolean indicating whether to validate the base network or not + """ + if roadway_dir: + base_network_shape_file = os.path.join(roadway_dir, base_shape_name) + base_network_link_file = os.path.join(roadway_dir, base_link_name) + base_network_node_file = os.path.join(roadway_dir, base_node_name) + else: + base_network_shape_file = base_shape_name + base_network_link_file = base_link_name + base_network_node_file = base_node_name + + road_net = RoadwayNetwork.read( + link_file=base_network_link_file, + node_file=base_network_node_file, + shape_file=base_network_shape_file, + fast=not validate, + ) + + if transit_dir: + transit_net = TransitNetwork.read(transit_dir) + else: + transit_net = None + WranglerLogger.info( + "No transit directory specified, base scenario will have empty transit network." + ) + + transit_net.set_roadnet(road_net, validate_consistency=validate) + base_scenario = {"road_net": road_net, "transit_net": transit_net} + + return base_scenario From d1846a819bcf60b577d81b83f898a3b0d99f7906 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Tue, 7 Mar 2023 15:49:36 -0800 Subject: [PATCH 02/15] Update example notebooks for tiny API changes --- notebook/Scenario Building Example.ipynb | 15 ++++++++----- notebook/Wrangler Quickstart.ipynb | 27 ++++++++++++++---------- 2 files changed, 26 insertions(+), 16 deletions(-) diff --git a/notebook/Scenario Building Example.ipynb b/notebook/Scenario Building Example.ipynb index 40d1d15c..521783cf 100644 --- a/notebook/Scenario Building Example.ipynb +++ b/notebook/Scenario Building Example.ipynb @@ -180,7 +180,7 @@ "source": [ "my_scenario_nobuild = Scenario.create_scenario(\n", " base_scenario=base_scenario, \n", - " card_directory = os.path.join(STPAUL_DIR, \"project_cards\"),\n", + " card_search_directory = os.path.join(STPAUL_DIR, \"project_cards\"),\n", " glob_search = \"*attribute*.yml\"\n", ")" ] @@ -218,7 +218,7 @@ } ], "source": [ - "my_scenario_nobuild.get_project_names()" + "my_scenario_nobuild.queued_projects" ] }, { @@ -375,7 +375,7 @@ "source": [ "my_scenario_build_alt1 = Scenario.create_scenario(\n", " base_scenario=my_scenario_nobuild.__dict__, \n", - " project_cards_list=project_cards_list\n", + " project_card_list=project_cards_list\n", ")\n", "\n", "my_scenario_build_alt1.applied_projects" @@ -448,7 +448,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "wrangler", "language": "python", "name": "python3" }, @@ -462,7 +462,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.12 | packaged by conda-forge | (default, Oct 26 2021, 05:59:23) \n[Clang 11.1.0 ]" + }, + "vscode": { + "interpreter": { + "hash": "5cfb67e0b2744a84e81e5a9906808c277839f4126dccc23f819e7f035f52be10" + } } }, "nbformat": 4, diff --git a/notebook/Wrangler Quickstart.ipynb b/notebook/Wrangler Quickstart.ipynb index 6f19ee99..746793be 100644 --- a/notebook/Wrangler Quickstart.ipynb +++ b/notebook/Wrangler Quickstart.ipynb @@ -1330,7 +1330,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1385,7 +1385,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1397,7 +1397,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1487,7 +1487,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1530,7 +1530,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1581,7 +1581,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATIAAAD4CAYAAABvwmqjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABNxElEQVR4nO2dd3xUVfqHnzMz6SGFhISWUKRIwgpEQJqCoKKCoKJYdsUVlQUU+am7q6y7a1nLWrAgCy6yu1ZURBZEFlCqFOkBQkJJaKEmkEp6Zub8/pi5lwlpEzLJzCTnyWc+mbn3nnvfMzP3O6e8532FlBKFQqHwZgzuNkChUCjqixIyhULh9SghUygUXo8SMoVC4fUoIVMoFF6Pyd0G1IXIyEjZsWNHd5uhUCjcwK5duy5IKVtVtc+rhKxjx47s3LnT3WYoFAo3IIQ4Ud0+1bVUKBRejxIyhULh9SghUygUXo8SMoVC4fUoIVMoFF6PEjKFQuH1KCFTKBRejxIyhULh9SghUyjqwZdffsmcOXMa/DorVqxgxYoVDX4db8WrPPsVCk/jxIkTlJeXN/h1MjMzUUFQq0e1yBQKL0AIgdVqdbcZHosSMoXCCxBCuNsEj0YJmaLRKS8v58CBA1y4cMHdpngVqmtZPUrIFI1OYmIiCxcu5F//+pe7TfEahBBKyGpACZmi0VE3ZN1RQlYzSsgUjY52QzaFcZ/GqoPBYFCD/TWg3C8UjUZBQQFms5nCwkJ3m+J1qBZZzTgtZEIII7ATOC2lHO2wfRYwUUoZXEUZX+CfQF/ACkyXUq6373sA+BMggTPAb6SUavS3iXLkyBG++OKLCtuaQousocnNzWXz5s2kpaXRunVrd5vjsdSlRTYdOACEaBuEEH2B8BrKPA4gpfyVECIKWCGE6IetS/sBECelvCCEeAt4EnipbuYrvIWLFy8CcNNNN5GVlUViYiImk3d0CFatWsX+/fv53e9+R3Bwpd/rBiEnJ4eNGzeyd+9eAHr37s3111/fKNf2Rpz6Jgkh2gOjgNeAZ+zbjMDbwIPAXdUUjQPWAkgpM4UQudhaZ4mAAIKEEFnYxDHtimuh8Hi08Z2ePXty+vRpEhMT3WyR8xw5coSCggIKCwsrCZmrW5U5OTn8/PPP7Nu3DyEEffv2ZfDgwYSEhNReuBnj7E/i+8AfgRYO254EvpdSnq3hw9wLjBFCfAXEANcCMVLK7UKIKUASUAikAk9UdQIhxCRgEkBsbKyT5io8DW8e4DcYbHNiDbkU6cKFC2zatIl9+/ZhNBqVgNWRWoVMCDEayJRS7hJCDLNvawvcCwyrpfi/gR7YxtZOAFsAixDCB5gC9AGOAh8CM4BXLz+BlHIeMA+gb9++arTTS3EUMovFoj/3BmoSsvrWobi4mOXLl5OcnIzJZKJ///4MHjyYFi1a1F5YoeNMi2wwtlbV7YA/tm5gMlAKpNk/yEAhRJqUsotjQSmlGXhaey2E2AIcBnrb9x+xb18IPF/fyig8F61r6ehG4G1CZjabXX7uY8eOkZycTL9+/Rg6dChBQUEuv0ZzoFY/MinlDClleyllR+B+YK2UMlxK2VpK2dG+vehyEQMQQgQKIYLsz28GzFLKFOA0ECeE0JJt3oxtIkHRRGmqLTJtX33p27evErF64PJpIyHEGKCvlPKvQBSwSghhxSZeDwFIKc8IIV4GfhZClGPrdv7W1bYoPAfHFpkmZN6CJlZV2e0qMVY+YvWjTkJm9wFbX8X2YIfn3wPf258fB7pXc66PgI/qcn2F9+LNLTKj0QhU3SKrr7e9t7wHno53OPIovB5NyD788EPKysoAm6vBu+++W+VxNZ3D8bnRaCQiIoJWrVoRFRVF+/btiY6OdqlA1DRGponyK6+8UqX9/v7+BAcH6/ZIKZFSYrVakVLq74WifighUzQKcXFx5OXlYbFYOH36NBkZGfj6+tKlS6Wh1RpFyHGfEILy8nIuXLjA3r17dVEICAigQ4cOxMTE0KpVK3x9fbFYLFgsFsxms1PPCwsLKSgowM/PT79mVUJ21VVXcejQIf21wWDQgyBarVYsFgvR0dFYrVaEEJUeBoMBf39/IiMjr/i9VSghUzQS4eHh3H777QCsXr2ajIwMwsLCGDNmjEvOL6UkNzeX9PR0jh8/zvHjxzl48GCdz2MwGDAajQQGBmIymcjKyqJTp05A1WNk48ePr/I8u3fvZtmyZQQHB3PPPffU2Q5F3VBCpmh0HAf+XYUQgvDwcMLDw+nVqxcARUVFXLhwAbPZjNFoxGQyYTQaKz13fO3Y4svLy+P999+nuLgYqJv7hYpU0bgoIVM0WQIDA+u1GiQ0NJSQkBBdyOoy26qtI1WzkY2DikemUNRAbGwsRUVFQN1aZNpMpxKyxkEJmaLR8aabOyYmRne7qEuLTBMyReOghEzR6HjTAvKYmBj9ubc58jYnlJApGh1vWmsZHR1do2d/bXhT69ObUUKmaHS0rpo3dL8MBoMeSkcN9nsuSsgUjY4mCN4gZABhYWEAdfLC11pxSsgaByVkikbH227uiIgIAH320hn8/PwA76urt6KETNHoNIRDbEPi4+MD1M3JVblfNC7e8U1SNCm8adYSLvmP1UV4CwoKAO/pPns7SsgUjY43zVrClbUg8/PzASVkjYUSMkWj421dyyuZZfW2Ono7TfJdnjp1KiaTqcqwKY6PqVOn6mXi4+Mr7AsPD9dDsmiP+Pj4StumTp1aqWx8fHyV26ZOnVpl+eq2a3VprDLae2YymSq8N65Gu8m9pbWSlZUFXBr0V3ggWqC32h6AEVs+yh8u2z4LKKimjC/wH2xp3/YCw+zbWwB7HB4XgPdrs+Haa6+VtTFlyhSJLXu5U48pU6bIuLi4OpVprMeV2OXKMnFxcbW+31fCp59+Kl966SW5aNGiBjm/q5k5c6Z86aWXZEpKitNltm3bJl966SU5a9asBrSseQHslNVog1syjUspL2LPpGQ/zy5gcR1sqZZ58+YBEDEjglzfXAy1NDrnMx/uBV98qz1GyNrHcgSiyue1ldGOdbyGtu2kPEnI3RXzGkokCPv/Ks5XZRkh0f/szx05xjECCADAx+pD/mv5ICElJYWpU6cyZ84cp+pTV7xljKykpASArl27VntMTk4Ohw8f1gMqnjhxAlCzlo2FuzKNb3c4dzdsSUo2XlENLkNztiz0KcRi/6szl99f3nG/uYRiQzExD8dw8pOTgO2HoaGEzFvQZi01b/2q+Pe//63PVDpSUxmF63BLpnEchAxbirlvZDU/XXXNNG40GrFYLJS8UlLrsY7HO4UA/MDkb8JSeqmM0c8WkM/oa0QYBCa/qt9Wg9GAwWgAHxBGgcFoQBgEwkcgDAKDrwEppG2bSYABhMm2DwHSLJEWCWaQVom0ykstOSO240xVlCmXWMusyFKJtdSKpdxiO8/l3Ak5PjkI30ufZ0MulPaW1oozdpaXl2MymRgxYgRCCLKzs9m+fXuFReeKhsMtmcYvO+Z+7GniqkLWMdP4pEmTmDt3bm2HVTh+w4YNpKSk1H6wBErAXFIxLpW52Pa6nMpZdupDXFycc3a5qEyrMbY0o45dz4YYkK/PImx3UVs3WEqJj48PAwYMAODQoUNs375dd6ZVNCzOzFpqmcaPA18Dw7FlGu+CLdP4ceyZxi8vKKU0SymfllL2llKOBcKwZRoHQAjRCzBJKXfVtyIac+bMYcqUKU7dgFOmTGHOnDkkJycTFxdXYV9YWFilL29cXFylbVOmTKlUNi4ursptU6ZMqbJ8dduTk5MbpczQoUMrbHMc4+vevcpsfvVC+2y8IRy0Nj5WmyBJKSu8t960ML4pUGuLTEo5A5gBYG+R/V5KOdrxGCFEgawm0zggpJSFl2Ua13gA+OrKza+aOXPm1HlcJzk52dVmVEl1dtW0vaHL6JEaqphAcMwQ5Cq0m7suEVfdRWpqKmBL61YT2iB/dnY2YIv3D7ULoMI1uCXTuAPjgdtdbYOiblTq4ska9rkAb3ISPXr0KGCL318TWiq5Dz/8sML22gRQ4Rrclmncvr9zXa6vaBhqmvBoyK6RNwz2Z2ZmAtCmTRunjr/66qv15/7+/iQkJDSIXYqKqLlhBd27d692gmDSpEkuv57W3fLEruX58+fZtm0bwcHBtGnThtzcXIAqEwlfjhCC++67r4EtVFSFEjJFpXGwhm4peXKIm/nz51cZQHHBggWAzXZfX19atGjBDTfcQI8ePbyqq9xUUUKmqHEcrCEcYjUh82T3i+Bg22jJ5U6uFouF4uJiiouLWbRoEaCcXj0B9Qko9DEyKewtJIceX0OIjScvTfL19aWsrIzbbruN9u3b89577wG2sS+t23j06FF+/PFHsrOzKS8v17vInlyvpo4SMoXuRKy5XwjLpRuyuflBlZaWArZVJIsXX1r+6+gX2LlzZyZPnqy/zs/PZ+PGjcTHxzeeoYoKqM69gjlz5hAXF6e3yByXLzXEYL8nJ+bQHFmDg4M5efKkvr1Hjx7VlgkJCWHUqFF07Nixoc1TVIMSMkWNbNiwweXn1MaUPNWzXxNarcvo4+OjxsE8HCVkCsAWsscgbV+Hc13PEXZ1mL7d1XjqrGVSUhIAgYGBFba3b9/eHeYo6oASMoVO2YIyhBSUi3Jy78sl+C/BmMJc3xLxNAHT2L17N2ATLk3UALp16+YukxROooRMoXPx+EXky5KYTFvomQJjAebpZjq81kFfPO0KPLVLee7cOQAGDRrE2rVr9e3XXHONu0xSOEmT7fjn5uZSVlamx6g3Go11HufQjr/8f1PEMfzPyTm2Qe7oP0aTEZBBujmdgDcDGNhiIL3TevPRRx9VaFVpUUTqiqe5K2gzljExMfqib6jc1VR4Hk32zpw9e7ZHO1xeCVOnTqVVq1YNcu7k5GTi4+MrjIlF/BDB/s376TGrBxfkBX65+Au/RP1CzAMxnFxwaUZPi//mrJh5atfSMRSPZmPbtm3daZLCSZqskHXo0IFz587pX8j63DzVnaOmc9bl2NrQBLmgoKDBhAyqD2V0/q/n+SX1F2784kZKRSknu57E+KKRyJ8iydiSAdRtBYAnCtnp06cB8PPzq7BEyZk1lgr302SF7KGHqg0663W88cYblJWVER0d7TYbBnYdSOkrpbS+sTXnbziPBQsZN2cQcFMA8p+SkowSvTXjbFfTk7qWW7ZsASAqKorly5fr23v16uUukxR1QA32exHuHqsxGo2cW3cOy8sWYo/b8icUG4opmVxCxIxLOR/nzp1bY15MT2yRaVmPEhISKiyib9mypbtMUtQBJWRexKZNm9i4cSM///wz69evZ926dfz8888unVGsCUcv//RP0+FlaF3QGoAsvyx4Edo/YfO5mjt3brXJkDUh86QWmWZTQECAPugfFhbmRosUdcHprqU9/dtO4LRjqGshxCxgomNwRYd9vsA/saWAswLT7cEZtX2zsSUwsQIvSCm/u+KaNGG0G37NmjVV7s/JyWHs2LENbofWXXSctTz3zjnwh5Dfh5BvzOdUq1OIFwXtk9pzcvGVTwg0Nq1bt+bo0aPs2nUpfYQaH/Me6tIi0xL06tQlQS9wMzBTCKFd8wVs2Zm6Yct/6fq1ME2EiAhbt+32229n1KhR3HHHHYwZM4abbroJoNFaZGATIqvVipTy0oLyEsh/NZ/wr8Lxlb5IJCd/dRLTiyba3nBp1k9LnuyJXcvevXsDl7qYgFo76UU4JWQOCXrnO2zTEvT+sYaiFRL0ArnYWmcAE4E37PusUsoLdbS92aCt/evXrx99+/YlISGBPn366NEW3CUMly8ozzmcQ9nLZbTd3hYDBsyYOXPjGQL/GkiLNi2wWCyYTCbeffddoKJouBttUbjWrQRUTkovwtkW2fvYBMvRJVtP0FtDOS1Br0kI0Ql7gl4hRJh9/9+EELuFEN8KIaqckhNCTBJC7BRC7Dx//ryT5jYttAQWWthlDXePMWmp9y63Y1j4MP7CXxgihgBQZCji4qSLtP1LWywWC76+voDN5cFTQt9U5ewcEhLiBksUV4K7EvSagPbAFinlM0KIZ4B3qCJRb10T9DZFgoKCAPjggw+q3H/o0CFeeeUVt7TMoqOjefHFF/XXjk6lCdkJbJq1iZg/x3DSeJIzxjPwIpwwn6AvfbFaraSkpDB16lSPHTtTeAfuStCbBRQBWuS6bwGVbqYanIm+4CnjTkIIpJQUFhby0UcfAXDy1ZME/zOYYKttPijJJ4mXeIkLUbbRBG3szJNobgElvR23JegVQizD1qJbC4wAXB8vponQt29f+vbtW/uBHsZbb72lPzeZTFhesdD5hs6cuvEUZaKMlEDbR+7upWRms1mfVdWIjIx0kzWKK8HlfmRCiDFCiFfsL6OA3UKIA8BzVOw6Pge8JITYZ9/+rKttUXgO2sTA0Z+P0sVc2a2hJgfahmTDhg289tpreoZwDWfzWCo8A+EpXRJn6Nu3r9y5c6e7zVBcIdrYWdyf40gxpdDR0pHjfzsO2LpyjZnncvPmzby0+iX2sY8SSiiiiH70YyQjAZtfWatWrSgvL6e0tBSLxcLw4cPp0KFDo9moqIgQYpeUssquSZNda6nwYKT279KPaGN0Ly0WC//4zz+Yf3o+KaRgoeI1T3Naf15UVMTJkyfx9fXFZDJx5swZ1q9fz8MPP9zgdirqjhIyRaOhpZ3TEDROtqacnBxmzJ3BsvJlnOEMACZMJJDAfx74D89+9yyry1YzIHgA2NNYTps2TXfJMJvNvPbaaw1mn6L+KCHzYqxWK3PmzKGgoKDKWcvAwECmTZvmMZmw9bRz9mxNjkLWENmadu/ezQvLXmAzm7nIRQBCCGGE7wi+mP6Fvgj/UJltkfifxvyJJQuWABX9yjzl/VNUjxIyL8ZqtZKVlYXBYNCdTME2FlVaWkpubi5FRUV61mxPQc+faReysLAwl/mRWSwWfvrpJ17a9hK72IXZnm24Pe2Z3HEyLzz8QqUy5zmPCRO9uvZiCUuqt9uLxpObG01WyL755hvS09MreZ3X5A1f3RfVsYzj87KysgpLWtyF1Wqtdr3lzJkzG9maSzi2ZKSUREZG8pe//IVvDd/q+//6179SVlbGn//8Z3r06IGvr2+lQJaOn0t1QS61kObHjx9nZ8lOtrENI0au4Rrm3T2P6351XZU2ZudmU0IJragYsNJqtVZqiWVlZbF06dJa6zxw4EDlvtHINFkhS01Ndbt/UnPn8iQjeho4LoXxMQiDvgQrLe2ST7XJZMLPz4+AgAC9XFU/KJoDrvaIjIzkzCnbOFhLWrL3xb012vj6otcB6GjoWGH7pk2buOGGG4BLIllQUMCePXtqrff+/ft57rnnVJe0EWmyQjZ8+HB27dp1xWJWXeusLqGzr3QtZE3n1uJ7XX6Ny/9rrbTg4OAqj3E8z+Xn0x7ajWgwGDAajRiNRgwGg/5wfK2VLSoqYk/KHg5wgLCwMEzChMlgwtfky+4duzGXm8nrlAcGW0bzufPmkpCQQPfu3WnZsqUufmazGbPZTGFhIUIIAgMD6dixI/3796d9+/bVisRPW38i81QmYOsy/mvxv3j07kerPDb9XDqfn/4cgFs73ArYBNRsNrN582Z69OihhxZ/5plnyMnJqfZz0fj8888pKytj586d9O/fv9bj64LFYqG4uJiLFy9SUFBAQUEBxcXFtGnThk6dOrn0Wt6G8iNTuJSzZ88yZN4QjnK01mM7WTtx7JVjgE0ErVYrVquV1NRUdu3axalTpyguLq6yrNFoJDQ0lLi4OPr168eBEwd4YPEDHMN2vgACGM5wrjNcx6RJkyqFCR8/czyLCxZjwUI44Zx57gz+/v78/e9/rzBc0KtXL8aMGeN062rXrl388MMPmEwmnn/+eadnY4uLi/nhhx84fPgwFovlisbjAgICiI2N5YYbbmiSSVNq8iNTQqZwKWfOnKHvx305y1lG+I7AKq1YpAWJpKCoAATsM+3DIixEySgyX87Uy1b3XSwpKWHfvn3s2bOHCxcuUF5eXumYRSxiP/sxYOC+wPtY8IcF7Ny5k+XLl2M0Gpk6dSotW7bku/XfMWnDJLLJxoCBm/1uZuXzK/XzvPPOOxQWFnLjjTeyZcsWSktL8fX15a677uLqq6926j3QxHDEiBEMGTKkxmN37tzJ+vXrKSwsrPE4g8Ggd7f9/f3x9fXFx8cHX19fsrKyyMnJqdSVDwgIoHPnzgwdOrRBk9Y0FsohVtFomM1mrPZoT6tnrK6wT+vC+v/VH4uwUEzVra3L8ff3p3///hW6atnZ2ezcuZMDBw6Qn5/PLdZbSCONEkrYU7QHsK1RLS0tZfXq1cyePZvv+Z5d0hYBth3tWP7gcnp1vZRcxGw260MR69ev14W1rKyMb775hjvuuIOEhJpjGxw6dEiv5/r164mLi6sU9//ChQt8//33nDp1qoJ4a+N9YBOuli1bUlJSQlFREVarlbKyMsrKyrh48SJ+fn6EhobSokULBg0ahJ+fH4sXL64gZsXFxSQnJ5OcnIwQguDgYLp06cLQoUMJDQ116r33FlSLTOFStm7dyo2rbsSMmfIXK7acTCYTFosF/7/6U2IowUf6UP6y7Zj6LlGyWq28/u7rvFn4JgUU0IEOpPwhBX9/fx554xG+MX9DKaX44suU1lN4/3fvYzabWbt2LcnJyVy8eLHW7lxAQAB//GNNcUTh1VdfxWKxEBkZSX5+PqGhoTz++OMYDAZWr17N7t27K6Sbc8TX15eYmBj69etH165dK3Rn8/PzSU1N5ciRI6Snp1NUVFStvT4+PhVarZc7IoNNNENCQrj66qsZOnQoAQEBNdbLE1AtMkWjsWf/HkooIYqoSvt0h1j7rKXm46Xtqw8Gg4GIoAimF05nLnM5wQli344lkEBOYssdcA3X8Ieuf+DMqTO8/PLLlc4hhMDf318fl3v44YexWq18/rltQqC4uJg333yTJ554okrfvMzMTIKDg8nLyyM7O1v385szZ06loJgaQUFBXHXVVQwaNKjKdH9FRUXs2bOHQ4cOkZGRUaO7j8lkwmq1Vup6ayIWGBhISEgIeXl5lJSUkJeXx7Zt29i2bRsGg4GwsDDi4+MZMmRIBb9Eb0AJmcJlWK1W/nv6vwB0pnO1x2me/Y5rLV2BlBIffFgwYAGjt44my/4XSigP8iDRRHMk9Yh+vMFgIDw8XA+TpHnzf/755xw9epRPP/1U7yYOHDiQrVu3UlJSwsyZMyu4hGiTFI5or61WayURCw4Oplu3bgwePLhSt7OkpITExEQOHjxYSbh8fHwICQkhPz+/yvqbTCYSEhK47rrrOHbsGEeOHCE5OVm3paioiKKiIt1uf39/hBCUlZVhsVjIzs5m48aNbNy4EaPRSMuWLenVqxcDBgzw+PhsqmupcBnJyckMWDSAAgrYec9Oro2/tsJ+rWvp+6IvZcLWvYpbH0fK+hSXRL+YM2cO+8/vZwELyCNP396a1kxiEr4mX6Kjo7nhhhvo1q1bjef67LPPOHbMNgM6bNgwhg4dCsD8+fP1rOR1ISAggJ49ezJs2LAK+UlLSkrYs2cPBw8e5Ny5c5WEKzIykm7dulFUVMTOnTsrdCcHDBjAyJEjyc7OZsWKFRw5ckSP0HvVVVdx2223ERYWxtdff01qaioGg6GS4DqL0WgkKiqK3r17c+2117pF2NSspZMsWrSIgwcPuvSc1a0KqOqY6v5Xt6+mco4Po9FIdHQ08fHxdOzYET8/P5fVz5F3P3qXZzOepQ1tOPPimUr7NfschWzQuUFs+WiLfozRaGTSpElOL1nKycnh4sWLpJ5OZeqPUznMYQBiiKEVrdjNbgAe4iE+e/GzOtVHa5l16dKFX//61xX2FRcXM2/ePL211aVLF+6//36klHzyySecPn0ak8lEhw4dyM/PR8s30b59e2699VbatWvH0aNH9W4rXBKurl27kpCQQGhoKD/88EOFFHVCCIYNG6Y76zpiNptZt24du3fv1ld6REREMHz4cLZu3crJkyfp0KEDUkpyc3MpKyujvLz8inwto6OjmTx5cp3L1QclZE5S1bhJc0AIgclkIigoiI4dOzJo0KArmq6f+LeJ/Mf6HzrSkbva3EVCxwTuvuFuAv1tLRCtRRb+13ByDDbn0mAZTN+NfZEWqXfRrFYrAwcO5P7776/SAVcIwYEDB0hLS+NM8Rm+53vdf8wXX1rSkkwysWLFiJE+9GE0o/H39+e5555zuj5Wq5X33nuPgoIC7r33XuLi4gDYtm0bK1faXDZ8fHz4zW9+Q2xsLBkZGXzyySeUlJQQGRnJo48+qq9ayMrKIiUlhe3btxMYGMjvfvc7Ll68yKxZs7BarYwePZprr73Ugv3uu+/Yv39/hc9o5MiRXHdd1UutLiclJYW1a9eSlZUFgJ+fH1JKysrKKrmFmM1mPv74Y86fP++0/5rJZKJdu3ZERETQunVrWrdujY+PTwXnae24qhK71LavKpSQOclXX31VYZmMs9T2HnrTe1wTAQEB+Pn56T5N2pdW+0L+98h/WaynYbiEAQMmTPhLf4IIwl/6c8xwrML+trSlBz24iqsoooh8+1+h/a+IIoopppRSyiijnHIsWPQJA198QaK39EzSRK+yXiTkJjBn1hxef/11pJQEBgbyhz/8wek6nz17lo8//hiACRMm0LFjR2bOnElBQQG+vr7MmDEDgB07drBixQqklPTp04cxY8ZUeb79+/fz3XffMXbsWE6ePMmePXuwWq307NmTcePG8eWXX1b4DhoMBsaOHcs111zjtM2OZGVlsWLFCo4ePVrhezht2jRatmzJwoULOXDgQA1naFimTJlCVFTliaGqcImQNUCm8fVAG9CdiW6x576sFjVGVj8sFgsXLlzg2LFjnD17lqysLAoKCigsLHRJdFYLFraylSKKsGIljzzyyaeAAkoooYwy3cesEhKouuddASGFLoxGjFix2kRNXOoeDSsexvo319Pr0V7ktMlheNZw5r47l7feegspJS1atOCZZ55xul4HDx7km2++wWAw8Nhjj+Hn58fs2bOr/IFybLlVRXl5Oe+9954+M2oymRg8eDBHjx7l5MlLmdlNJhPjx4+na9euTttZE1q3c9u2bXpX0tFvLSIigsmTJ9faQjKbzWRmZnL8+HEyMjLIycmhoKCgwtietu61JrSu79ixY/XkyLXhKiF7BpsghWhCZs80Ph24qxohewLoK6V8RAgRBawA+kkprXYh+72U0mllUkLWOGRnZ3Pq1CnOnj1LTk6O/qjKo746NIdOsAmo1mUsKSnhXPk5Msggk0yyrFnkiTyKKKLU/ldGmS5qAkEYYfSgB93Od+OTf3xCdEw0LR9pyUFxECkkRmkkjDCyhK0bFSyDMWOmRNhulgAZgGmOifKL5fzxj3/UXQ2mT5/udH12797NsmXLMBqNtG3btoLoOBIbG8sjjzxSaXtZWRkrV65k7969+oB7TEwMZWVlZGRk6Mf5+Pjw0EMPNWhy4Pfee0+f+fT39+fRRx9t9GgdH3zwAbm5uY0rZPZM458CrwHPSClH21toq4EHgdRqhOwfwFYp5ef212uAGVLK7UrIvJPi4mKWLl1KamqqfkMKIQgNDSUyMlKfOdNo3749jz5qW7RttVp5//33uXjRFuTw8ccf59VXX62UwQhg/J/Gk+SbxAlOUITNZQAJ/vhTSilSSPykH0MYwiAGIS2SpaalJJGkH9vZ3BmT1cRhv8MEySDM75rxkT4888wzCCGIjo5mypQpTtf9jTfeqNaZ1ZH4+HjuuecewCZgP/zwg+4GYTKZ6NOnD7t27aowg+jn58cjjzxSpS9ZQ7Bo0SLi4uJqbD02JO+//z55eXncfffd/OpXv3KqjCuEbBHwBtACezo4IcR0wCClfM+eDq4qIZsE3Aw8AMQAicCjUsrv7EIWgS1h73fAq7IKY+znmAQQGxt77YkTJ5yps6IROHDgAKtWrSIv75KrQ2BgIC1btuTUqVMVjh0xYgRpaWlon9+YMWPo06cPYMugNG/ePCwWS5WzlkmHk3h+4fPsMe8hk0yMGBlQPoANr2/g0Ucf1fN+7t+/n8y4TDYaNiIQ3M3drJ+9nshJkRzyO0SwDKZsZhmBpkC9NVZeXl5rGOvLF5KDrSXTt29fNm3aVGWZ/v37U1BQwIEDB2z+bT4+9OrVi5SUFN2XC2xdyCeffLLJLRmqDW1N6yOPPEJsbKxTZeolZPZM47dLKadqeS2xCctCYJiU0lyDkJmAt4EbsWUa9wHmSSmXCCHaSSlPCyFaYBOyL6SUNc6PqxaZZ1JWVsby5ctJSUnRx9q00DtVLYa+9tprGT16dKXttaHNel7O73//ez0b+8yZMxk2eRjLg5YjkdzN3SR+lojxQSNpPmm0kC0o+nsREaERemusrKyM119/vdJ5teVGjgQFBRETE+O0m46fnx89e/YkKSmpQmsuNDSU8PBwzp07x/Tp0/XZzebCW2+9RXFxMU888YTT3dqahMxdmcaRUp62/78ILABcG7xJ0Who0SFeeOEFJkyYQEREhJ5tvCoub5U4S3XLmAoLC3VH0GeffZblM5dzW8ZtCASLxWJ6TehF6MpQOpd35qK4SPDzwVzIvaDPRvr6+lbw53r55Zd5+eWXK4hYVFQU7dq1o7CwsIKICSF47rnnqvXNKy8vZ9euXbqIRUdH86c//Yn/+7//Y+TIkZSUlLB58+Y6vxfejtaAcpWA18n9opZM41W1yC7PNP4XKeUN9pZamJTyghDCB/gKWC2l/Kim66sWmfdgsVj48ccfSUxMrHaSICIigqlTp9YpkmpN3dC//e1v+rjTjBkz+Mu8v/DOhXewCit3yjsp3V7KgWsPcNx0nJayJdmvZNMhtgO//e1vgaodlrt168a5c+cqLQsKDAzk6quvZvfu3ZXK5JBDAAH4c+km7dSpExMmTKh07HfffcehQ4d46qmnPC63QkOydOlS0tLSmD59utO+ZC7zI3NGyIQQY7DNVP5VCNERWIXN9eI0tvGxE0KIIOBnbF1NbdLgGSlljS7GSsi8j8sdO6vCmfA4zuLo1DxjxgxenP8ib2a+iRSSe+W9+B/1Z12ndZwynCLaGk3JhyVMnza9UuTdgQMHsnPnzkoiHBoays+FP1NgLmAwg/WWoJSS9eXr2eC7AYCWsiXTmEbbtm1rXBCflZXFP/7xD/r27cvtt9/ukvegqaIcYhVuY86cOZw/f5527drxyCOPsHHjRrZt21YpWYqfnx+PPvpovQMAlpWV8cYbb+ivX3zxRW6fejsro1YikTwgHqBlVksWhS8iw5BBrIxlopiod3WqW0YWFhbGj7k/spa1lGCzfbgczt7Ze+k+pTu/mH6psAj+tsLbWPH2CqZMmVLrcqtly5axZ88ennzyScLDw+tV/6aMEjKF23j77bcpKiqif//+3Hbbbfr27OxslixZUskfKzAwkCeffLJe8bEcxUzL1HT7tNtZ0XIFAL8Rv6Gj7Mg/xD/IJptYGUv6K+n85c9/qbQY2s/Pjw2lG1jPekooQSDoSleOchSzNCMQtmge9tvopsKbWP3OpYCSziyGz8/P58MPPyQ+Pp4777zziuvd1KnvYL9CccVoY1YdO3assL1ly5ZMnDiRadOmVdheVFTEW2+9xRtvvMHhw4ev6JqOS4esVit//vOfKUoq4l55LxLJF3xBOulMkVMIl+Gki3Ri/xpbQcSsWNnMZl4qfYmVrKSUUrrRjZ9u+YkBEQMwYQJhC0nkK30ZcmIIvEwFEQOcWpAdEhJCv3792Lt3L5mZNS5uUVRDk22RvfLKK01mjWNT4Lnnnqs0Q5Wens7XX3+NxWLRZ/X8/f2rzdF5OX5+fnTv3p3hw4dX6YdVUFCg5/XUxrKSZBLf8R0GDPxW/JZ2sh1zxByyyKKT7MQEJiCE4Hu+Zze7EQjiDfEseGABHyz8gC/Kv6AUm09ZO2s7bhG30Kq4FR988EGVQQ+dDU9UVFTErFmz6NSpE/fdd59T9W9uNMsIsVFRUeTk5FQSs4Ze4K3dMA11/vqc43K7nHkvXFGXFi1aVBKxpKQkli5dSmhoKHfeeSf//ve/ARg8eDBr1qxx6rylpaXs27ePffv21XqsFgBx56c7ufPhO1kilvAJn/Bb8Vumyql8KD7kmDjGArmA0XmjiSyKhNa2svd1uI8JX01gj3UPAFdzNS9f+zLr/7feFhqnbwemT5/Ohx9+WCnrk7ORbwMDAxk4cCDr16/n1KlTupOvwjmabItM4ZlIKdmwYQMbNmygffv2+Pj46AEMG4qqYtYnykSWshSBYAITaGNpwxzjHPJFPt3M3Tj86mH6/74/24O36wvaAwjgnd7vEF4UzuHDh4mLi2PDhg0UFBTQvn17Zs+eTX5+PlLKOsdVA5swz5o1i+jo6CpdNZo7zbJFpvA8zGYzy5YtY9++fQQHB+vLmAICAoiIiKiwrCkhIQEhRIWggrVhMBgICAjQu6pWqxUhRCURs1gsLP3bUu78y50sMS7hM/kZA9MGUva/MoKfDuaw6TD+L/qzne36IH5nOrPs3mXExcUhpWTz5s2sX7+eVq1a0apVK+Lj46uNy+8sfn5+XH/99axatYqjR4/SuXP14cIVFVEtMkWjUFRUxJdffsmZM5cixwYFBTF8+HASEhIwm838/e9/x2Qy8cwzz/Dzzz/rHu99+vShV69erFu3jpMnT9YrXLNj8lvHMTOBYOChgRRTzJ7ue3RXihBCGHhuIAPbDARg4sSJemSKrKws9u3bR2xsLJ07d77izPKOmM1mZs+eTVBQEI899phLztlUUO4XCrdhsVjYvHkzGzZs0AWoRYsW3HzzzdVGPThw4AALFy4EYNCgQdx88801XuPcuXMsXbqUjIyMSnkiDQYD3bp1Y/z48fq5v/nmG8C2tGn27NncMPUGfgz58dIJJUQQQeutrUlelQzA8uXL2bFjB1C3YIBXQmJiIt9//z3jx4+nR48eDXYdb0MJmaLRsVqt7Nixg9WrV+uzdkFBQYwePbrGjN0nTpzgk08+0V8/9thjtGvXzqW2ZWVl8eGHHwI2nzM/Pz/2yD0sYxnRRBO8NpjDGy+5fmgTBYsXLyYpKQkhBNOmTWsw51Wr1aqHNnr88cf1aLzNHSVkikbDarWyb98+VqxYobtU+Pn5MWrUqFrjTqWmprJgwQLAJno+Pj6YzWYee+wxl4e5yczM1MXCYDDw5JNP8sILL1QZG83RO/+rr77i8OHDGAwGnn76aZetj7RarZw4cYLDhw9z6tQpLly4UMENxWg04ufnR1BQEGFhYURGRhIdHU1MTAxhYWHNQuiUkCkaHCklKSkpLF++vEIY5+HDhzNw4MBay69Zs0aP7XX99dczfPhwzp8/z7/+9S9CQ0OZOHGiy7M/OQqnlpCjtthoAP/5z39IT0/HaDTy7LPPXvEqhP3797N161aysrIq+c5pwiSEoFWrVhQUFFBSUlKlT5qPjw8jR46skLykKaKETNFgSClJTU3lhx9+0CO/CiEYNGgQw4cPr7WlYDab+fTTTzl16hQ+Pj5MmDBB96GyWCx6ir66RBKtC3v37mXJkiVA1U671TFv3jzOnj2Lj48Pv//9753OzJ2fn8+qVas4fPiwLko+Pj6EhobSpk0brrrqKrp3746/vz9Hjhzhiy++4NZbb62QPSk3N5eTJ09y7tw5MjIy9MQiYWFhjB8/njZt2tTtTfASlJApXI6UkqNHj7J8+XJycnL07b1792bUqFFOhWY5deoUn332GeXl5URERPDYY4/pQpKfn8+iRYs4efIk/fr1Y+TIkQ2WFPajjz4iIyOjzuniZs+eTVZWFn5+fvzhD3+o0b7U1FRWr16tL0EymUx069aNESNGVMo2rqHlyMzJyWH69OnVnr+goIBvvvlGd1+5+uqrm+TqACVkCpdy4sQJ/ve//1VYF9itWzfuuusup1s0mzZt0j34fXx8GD9+PF26dAHg2LFjfPfdd5SVlTFmzBh69uzp+kpchrakraZUblWhJfIIDAzkmWeeqSA2ZrOZjRs3smPHDr27HRYWxvXXX+902KK0tDS+/PJLp0IdaceCLYSRs61Eb0EJmcIlnDp1ipUrV3L69Gl9W0xMDOPGjavTYLyWwRtsLThtcLtXr15ERESwbt06IiIiGD9+fL3D+jjL8ePH+fTTTwHqFH7ZYrHw7rvvUlRUREhICE8//TS5ubmsWLGCtLQ03Sm3Q4cO3HrrrXVOLiKl5OOPP6a0tJQnnniixq669r5qOTKbGkrIFPXi7Nmz/Pjjjxw/flzf1qpVK8aNG1enGzMvL4+PPvqIkpIShBA89NBDdOrUCbPZzM8//8ymTZuQUhIXF8eYMWNcPrhfGwsWLCA1NRWj0cif//xnp8tZLBbefvttSktL8fHx0YMx+vr60qdPH4YPH16v1pHmVzdu3LhqW6da9vPQ0FCeeuqpJjmLqYRMcUVkZmayZs2aCuF0tEXel4flqY3Vq1frnvrBwcFMnTq10mxfRkYG58+fJz4+3m0e7a+99hpms7na0NTVUVZWxjvvvEN5eTlBQUGMHDnSZZMTUkrmzJmDwWBg8uTJld6bo0eP8sUXXyCl5OmnnyYkJMQl1/U0XLLW0tWZxh2O+R7oLKVs+IEQhVNkZWWxbt06kpOT9W0BAQGMGjWK+Pj4Op2roKCAf/7znxQUFAA1Z1CKjo5utLyO1fHEE0/wwQcfcOzYMdLS0vRxu9rw9fXl97//PZ999hkZGRnVDuBfCUIIhgwZwpIlS0hNTaVbt26AbWXCTz/9xN69ewFbjLemKmK1UZdF49OBA4D+Ttkzjdfk3vw4gJTyV1qmcSFEPyml1V7+bqCgzlYrGoTc3Fw2bNjAnj179G0+Pj6MGDGiwvS/s2zcuJG1a9cCrgtl3dCEhYXRv39/tm/fzoIFC/jTn/7kdHIMX19fHnjgAebPn8/XX3/N448/7jJh6dmzJ+vXr2fjxo1cddVVJCYmsmbNGsrKyhgyZAjp6enNel2mUx1pe6bxUcB8h21GbDkr/1hD0ThgLYCUMhPIxdY6QwgRDDwDvHoFditcSH5+PsuXL2fWrFm6iBkMBoYMGcLzzz9fZxErKyvjgw8+0EWsZ8+ePP/88x4vYhq33XYbAQEBSCn5xz/+UaeyQUFBPPDAA5SVlfHNN99Um0GqLlitVi5evEhsbCynTp3i7bffZvny5bRu3ZrJkyczYsQITCbTFS+mbwo42yJ7H5tgtXDY9iTwvZTybA2/BHux5cT8Clum8Wvt/7cDfwNmAjUmOLws07iT5iqcoaCggE2bNrFjx44KN0GfPn24/fbbnW6JOJKamspXX32lZ9d2dHD1Jp555hlee+01fQbSMd9AbURFRXH33Xfz9ddfs3TpUsaNG1dra8lsNpObm0t2drb+yMnJIScnh9zc3AqhiEwmE3feeSfdu3fXz2swGJwKq91UqfWbas80niml3GVPB4cQoi1wLzCsluL/BnpgG1s7AWwBLEKI3sBVUsqn7SnjqkVKOQ+YB7bB/trsVdROUVERW7ZsYevWrRW+/N27d+fOO++8oqSpVquVRYsWceDAAcB2M2uZvL0Rk8nE+PHjWbhwIdu3b6dDhw7ExcU5Xb579+7cdNNNrF69mlatWjF06FB9n9lsJj09nbS0NM6dO0d2djZ5eXkVyvv5+REeHk5UVBTdu3cnPDycdu3acfToUVavXk1AQEAFcTQYDKpFVgtapvHbAX9sY2TJQCm2TONgzzQupawwMiqlNANPa6+FEFuwZRofCvS1Zyk3AVFCiPVSymH1rpGiWs6fP8+2bdvYs2dPBQGLjY1l3LhxVzyek56ezldffUVJSQmBgYEUFRXVGOHCW+jRowcJCQns3r2bb7/9lunTpxMWFuZ0+UGDBnH+/HnWr1+v/zgcOXKE48ePU15ejsFgoE2bNsTGxtKyZcsKj8uFSiMyMpKtW7eyZs0aHnnkkQotMiVkNSClnAHMgFoT9Faa3qki07hZSpkCpABz7cd0BH5QItYwSCk5cuQIW7du5ciRIxX2dejQgTFjxlzxDJvVamXp0qV6zPxf/epX3Hnnnfztb3+rt92ewh133MGZM2c4d+4cH374ITNmzKhLZmxGjx7N6dOnWblyJWCbWezduzddunShY8eOdfYv8/HxYejQoSxfvrzCDKbRaFRC5kocM40DUcAqIYSWafwhV19PUTVms5nExES2bdtGVlZWhX1dunThjjvuqNeM2qlTp1iwYAHFxcX4+/tz33336b5lWvyupsLvfvc73nzzTUpKSnj33Xf54x9rmt+qiMlk4t5772Xu3LkYDIZavfOdoU+fPmzZsoW1a9fStWtXPYBkU3rP60qdhMzuA7a+iu3BDs+/B763Pz8OdK/lnMcB5UPmQlJTU1mxYkWFxdwA8fHx3H777QQGBl7xua1WK1988YWeMCQuLo5x48ZVuDkdvdubCs8++yyvv/46xcXFzJ8/n8cee8zpslFRUfTp04fExESWLVvG2LFj62WL0Whk2LBh/Pe//yU5OZmePXs2eyFreusYmjG5ubksWLCABQsW6CImhKBPnz7MmDGDe+65p14ilpmZydtvv62L2IQJE7j33nsrtTAiIyNJS0tzKp+jt2AymXjiiScAOH36NJ9//nmdyo8ePRpfX1/27NlDdnZ2ve351a9+RVRUFOvWrcNisSghc7cBivpjNptZs2YNs2bNIjU1FbD9ag8YMIA//elPjBkzpt6REFavXs3cuXP1AICDBw+mU6dOVR574403kpWVxYoVK5rUzRUREcGDDz4I2JYF/ec//3G6rMFg0FtiX331Vb1tEUIwfPhwsrOz2bNnT7MXMpUOzsvZu3cvy5cv17tyPj4+DBw4kKFDh7pk4XBxcTEff/wxOTk5mEwmxo0bV+uMZJcuXRg8eDCbN2+muLiYu+66Cx8fn3rb4gl07dqVhx56iM8//5z09HT+9a9/8eijjzpVNi4ujtatW3Pu3DkSExPp06dPvWzp1q0b7du3Z8OGDXTr1s3pDO1NEbVo3EvJzs7ms88+0/2PfH19GTZsGNddd53LIh+kpaWxZMkSCgsLadOmDb/97W/r1LLbunUrq1atIiYmhvvvv79e3VpPIz09XW+RtWnTxumM4vn5+bz//vsYjUaee+65K3I6dsQx/BDAiy++WK/zeTIq+oUbWLJkCUlJSYCtG6D5+wgh8PPzY+LEiZWy8BQWFhIQEFCjEJnNZv773/+SkpIC2Lost956K/369XOZ7aWlpfz444/s3r2b8PBwcnJyagwhUxMpKSksXryYsLAwHnzwQZcupnY3p0+fZv5826q9ujgAr1ixgu3bt9O7d+96D/yDLQ7ZyZMn6dq1K/fee2+9z+epqEzjbiAjI4PQ0FDdG1xKiZSSvLw8UlJSyM3NxWw2c+LECdLT00lPTycvL4+EhATuuOOOKs+ZmJjI8uXLdWfW+Ph47r77bpfGnkpOTmb16tXk5uYycOBA+vTpw5w5c6544D4uLo7g4GC+/vprPv74Y+6++266du3qMnvdSXFxMRMnTuTf//43mZmZzJ49myeffLLWciNHjmT79u2cO3fOJXaMGDGCjz/+2GvWsjYESsgaiPPnz2OxWCgqqriUVJtN/Prrr/V0aUFBQXTo0IE2bdqwe/duevToUSF8TFZWFp999hn5+fmALULDww8/XCcv89ooKiri888/12+u3r174+fnR2JiIgD1abnHxsby+OOPs3DhQhYsWMCwYcO44YYbvD5agxZWesqUKcydO5esrCxmzZrFU089VWM57YfHVWsj27ZtS48ePfjll1/o379/k+rCO0uzEzKr1VrtoKhjy+byVo7BYNAfjkgpq7whtS+pJgSX07p1a3r37q0vTxFCYDabmTdvHsuWLePpp5/GbDbz3XffcfDgQcA2Ezl27FiXZxNKTEzkhx9+qDDr5RjKRwhR77yS4eHhTJw4kR9++IH169dz5syZOsX492S+/PJLnnzySWbPnk1OTg7vv/8+//d//1djGVc7Dd94440cPHiQjRs3MnLkSJed11todmNkjrkM3YnjWjohBIWFhU6Vu1w0XfX5adP5Q4YM0c+pdYcBl2UwklKyY8cOVq1aRVhYGPfddx9RUVEuOXdj8/LLL+vPBwwYwHXXXccHH3wA2PzOXnjhhWrLvvLKK4SFhdXaeqsLS5cuJSkpiWnTprk8obEnoMbIHGjZsmWFbpujEFwuCpfvk1JitVor3OjV/arm5eURHBxM586dK5R3PK/jtpSUFD3TjiMGg4GQkBAMBoPe+nMUwKr+X05VZRzt8PPz46677tK//LWdrz4IIejfvz+tW7fm22+/Zf78+YwdO7bOkWc9jZSUFEaOHMmzzz7LzJkzMZvNfPnll/z617+u8viGWMY1dOhQ9u3bx88//1ztOGtTpdkJWURERLVfLndy2223sXDhQj0+vrM+W95KbGwskyZN4ttvv2XRokWcOXOGESNGeGXSDKPRSFFREa+99lqF7aNGjaq2TEMIWVhYGH379mXHjh0MGjSIiIgIl57fk2l2QuaJ7Nixg5UrV+pf7ISEBEaNGuWVN3VdaNGiBQ8//DArV65ky5YtnD17lvvuu6/RsyfVl+oG7WuajBFCuGxYwJHrr7+exMRE1q1bxz333OPy83sqTftO8XAuXLjAzJkz+d///ofVaqVVq1b84Q9/4I477mjyIqZhNBoZNWoUY8eO5cSJE3zxxReUlpa62yynGDx4MIGBgQQGBhIUFERQUJC+r3Xr1jWWbaiIrsHBwVx33XUkJyeTm5vr8vN7KqpF1ohYLBaKi4spLi7mxx9/JC0tDaicabs5orl7LFq0SB9b8vSW2U033cRNN91UYZuWsby21lBDhqa+5ppr2LRpE0eOHOHaa69tkGt4GkrI6oiUktLSUl2QiouLKSkpqfD68m1FRUUUFxdX+cXt379/neLBN2V69OjBuHHjWLRoEQsWLODBBx/0eDFz5JNPPkFKia+vb63jUwaDocGig0RGRtKiRQuOHTumhExh48cff+TEiRO6OJWUlNQ4tqHNEDrOSFZF27Zteeihh5qEH5Ur0eKbfffddyxYsIBf//rX9Y7c0RhoqzQAp5YqBQcHk5mZyUcffcSECRNc6sQqhKBz584cPny4Wj/HpobbEvQKIVYCbew2bASekFJ6XBqYsrIyrFYrJpOJgIAATCYT5eXllJeXV9nC0gTMx8cHPz8/goODCQ0NpWXLlkRFRdGmTRtatWrVbMbArgTNFUMTswcffNArxAxsrizOrLh4+OGH9WS+M2fOZPTo0fWOhuFIp06d2Lt3L+fOnaNNmzYuO6+n4s4EveOllPnC9nOxCFtWpq/rWgFXkZSUxN69e8nPz6ewsJDS0tJqxzAMBgO+vr6EhITQokULwsPDiYyMJDo6mnbt2jXLJSKuJj4+HovFwn//+1+SkpI8voukRbFwdiYyMDCQyZMns3nzZtasWcP3339PYmIiv/nNb1wi2pr/4qFDh5SQaTgk6H0NW1JdxwS9DwJ3VVO0QoJeIUQuttbZdillvoMNvoDblhikp6ezePFi/bXW+goKCiIkJKRCayo6Olq1phqJnj17smTJkkqp0jyZurpUDB48mJ49e/LZZ59x8uRJ3n77be666646pZ6rihYtWtC1a1e2bt3aLNZfujNBL0KIVUB/YAW2VlklGjpBr9Vq5ZtvvgFsoZuri3qqaHwMBgOBgYEUFBS42xQAdu7cyU8//VSjWF2Jb1hoaCjTpk1jzZo1bNq0iW+//ZagoCDatWtHly5diI+PvyIhuvnmm5k7dy4bNmxo8hNKbknQq+2UUo4UQvgDXwLDgZ8uP0FDJ+hduXKlnodRiZjn4ePj4zEZtNetW6dHLKmOFi1a1Li/JkaMGEGvXr1YunQpp0+f5vDhwxw+fJj//e9/BAQE0L59exISEujWrZtTvYJWrVqRkJDAzp076d+/f5P29HdXgl7HY0qEEEuBsVQhZA1JVlYWO3bswMfHh3HjxjXmpRV1wNNm3R5//HHatm3bIOeOjIzUQ2dnZGSwf/9+0tLSOH/+PKmpqaSmpiKEoGXLlnTv3p0BAwbUKJ7Dhg0jKSmJ1atXc9999zWIzZ6AWxL0CiGCgRb2bqkJ2/jbxnrXpo5o8aTuvPPOeoccVjR9tAggzkYqqS/R0dFER0czYsQIwJZLdMeOHRw9epSsrCy2bNnCli1bCAgIIDY2lkGDBlUafgkODmbIkCGsXbuW48eP67lHmxruStAbBHwvhPDDtkxqHfCRq22pic2bN5OTk0P79u3rPbCqaFg8JdSUlkAlKyvLLVFu27dvT/v27QFbOPLdu3eTlJREZmYmhw4d4tChQ/j4+NChQwcGDRqkD5UMGDBAH9977LHHPK6F6wrckqBXSpkBuC7IfB0pKipi7dq1GAwGj4yEobiE0Wj0mDEybZWBFqnXnfj5+TFw4EAGDhwI2NLT/fLLL5w4cYK0tDTS0tIwmUzExMQwcOBAhg8frueRuOaaa9xsvetplv2pL7/8EqvVysiRI5VnvYfjSfkaXR2i2pV07txZ9x1LT09n8+bNHD9+nGPHjnHs2DGMRiM+Pj6sXLmS7t27e9XSL2dodkKWlJTEmTNniIiIYMCAAe42R1ELDRXu5krwZCFzJDY2Vh8rO336NJs3b+bo0aOUlpZSXl7Om2++ydVXX83o0aObjH9ZsxIys9nM999/jxBCdSkVzYJ27doxfvx4ADIzM/niiy+4ePEiBw4c4ODBg/Ts2ZMxY8Z4/WRXs3JRX7hwIWazmQEDBlTKKalQNHWioqKYMGECQghiYmLw8fEhKSmJv//976xdu9bd5tWLZiNkx48fJzU1leDg4EoxpBSei9VqVUvCXEhkZCR9+/bl1KlTPProowwePBgpJRs3bmTr1q3uNu+KaRbfEKvVysKFCwG4//771Y3hRXhiGBpPGbO7UoYOHYqvry9r1qzhpptu4v777wcgOzvbzZZdOd7dMXaSbdu2UVxcTFxcHO3atXO3OYo64EmD/RqeJqx1JSgoiCFDhrBmzRqOHTumby8qKuLs2bNYLBasVitCCNq1a+cVP/zNQsi0hLzucGJU1A9Pcr/QIrpqjrHejKOTrDbUkpycTHJycoXjgoKCePzxxz0+T2azELLgYJu/rqdEUVA4jycJWVPCZDIxYsQIFi9eTF5eHv369aOoqAghBAaDAYPBQE5ODidOnGDWrFmMHz+e7t0r+bZ7DM1CyLRFtUrIvA9PEjLNRaG2CBjeQs+ePdm6dSvr16/nySefrLKluX37dlasWMHXX3/N6NGjPTbAped3fl1ASIgtqG1RUZGbLVHUFU9aoqQtGvcUe+qLEIJbbrmF/Px8fvnllyqP6d+/P4899hgGg4Hly5d7bIo5JWQKj8ZgMHjcYL+n2VMfOnToQFxcnD6OXBXt2rVj1KhRSCn55JNPPKaF7EizEDJtGUZNH5bCMxFCeMyNo81WNiUhA7jnnnu45ZZbajwmISGBzp07k5eXx4IFCxrJMudpFkKmTR97SwZrxSU8aYxMo6kJmbPuJL/+9a8JDQ3lyJEj/Pjjjw1sVd1oFkIGthuiqQzSNic8yY9M+0H0NGFtLAwGA5MnT8bX15dffvmF1atXu9sknWYjZEajkfLycneboagjniRkTbVrWRf8/f353e9+h4+PD5s3b2bp0qXuNgloRkJmMpkaLEW9ouHwpK6lJmSeYo+7aNmyJU899RQBAQHs2bPHI8bMnBYyIYRRCJEohPjhsu2zhBBVOmgJIXyFEP8RQiQJIfY6ZGEKFEIsF0IcFEIkCyH+Xp9KOIMnZeNROI/RaPQY4dC6ls25RaYRHBzMU089RUhICKmpqcyfP9+tn1NdWmRapnGdumQaB24GZgohtGu+I6W8GugDDBZCNGjiPV9fX4+5IRTOM3DgwFpn1BoLbwms2Fj4+/szbdo0IiMjOX36NHPmzHFbr8cpIXPIND7fYZuWafyPNRStkGkcyMWWmKRISrnOvr0M2A20vwL7nUYLaa3EzLuIiYnhqquucrcZwCWHWPUduoTJZGLKlCnExMSQlZXFrFmz3OLm5GyL7H1sguX4CeqZxmsop2UaNwkhOnEp07iOECIMuANYU9UJhBCThBA7hRA7z58/76S5ldGETDnFKq6UoKAgwNa6V1zCYDAwceJEunfvzsWLF5kzZ06j2+DWTOP2nJZfAbOklEerOoGrMo0HBAQAkJeXpy8iVyjqwq233sqtt97qbjM8lvvvv59ly5bRqlWrRr+2uzONzwNSpZTv16cSzqD9mubl5amYZApFA3HHHXe45bq1di2llDOklO2llB2B+4G1UspwKWVrKWVH+/ai6jKNCyGC7M/1TOP2168CocD/uaw2NaBC+SgUTReX+5EJIcYIIV6xv4wCdgshDgDPYc80bp88eAHbZMBuIcQeIcRjrrbFESVkCkXTxV2Zxk8BjRovWIuAUVhY2JiXVSgUjUCz8ezXQvWqWUuFounRbIRMa5EVFxe72RKFQuFqmo2QaWGKVUwyhaLp0WyEDGyOeyommULR9Gh2QqZikikUTY9mJWQqlI9C0TRpVkLm6+urIhcoFE0QJWQKhcLraVZC5ufnB6gwLApFU6NZCZkWAUM5xSoUTYtmKWSemi1ZoVBcGc1KyLSF4/UJ0KhQKDyPZiVkvXv3BmD79u3uNUShULiUZiVkUVFRhIaGcu7cOTVOplA0IZqVkIEtKw/ATz/95GZLFAqFq2h2QtavXz+MRiPJycnuNkWhULiIZidkBoOBbt26UV5ezt69e91tjkKhcAFuyTRu3/eaEOJkdWUbkpEjRwKwcePGxr60QqFoANyZaXwZ0L8O13cZoaGhREREkJWVRV5enjtMUCgULsQtmcbtr7fWkty3Qbn++usBWLVqlbtMUCgULsLtmcZrw1WZxi+nV69e+Pj4cPjwYbX2UqHwcmoVMsdM4w7btEzjH9ZS/N/AKWyZxt/nskzjziClnCel7Cul7OvqDMbx8fFYLBZ27Njh0vMqFIrGxZkWmZZp/DjwNTAcW6bxLtgyjR/Hnmn88oJSSrOU8mkpZW8p5VggjIqZxt3KzTffDMAvv/ziZksUCkV9cFumcU8gMDCQ1q1bk5eXR0ZGhrvNUSgUV4hbMo3bj3tLCHEKW2vulBDiJVfb4gzDhw8HlKe/QuHNuCXTuH3fH6l5xrNR6Nq1K/7+/qpFplB4MXUSsqbK5MmTadGihbvNUCgUV4gSMmwOsgqFwntpdmstFQpF00MJmUKh8HqUkCkUCq9HCZlCofB6lJApFAqvRwmZQqHwepSQKRQKr0cJmUKh8HqElNLdNjiNEOI8cKIRLxkJXGjE6zUkTaku0LTqo+riHB2klFXG8vIqIWtshBA7pZR93W2HK2hKdYGmVR9Vl/qjupYKhcLrUUKmUCi8HiVkNTPP3Qa4kKZUF2ha9VF1qSdqjEyhUHg9qkWmUCi8HiVkCoXC62mWQiaE6CWE+EUIkSSEWCaECLFv7y+E2GN/7BVC3FVN+SeFEGlCCCmEiKxifz8hhFkIcY+31kUI8WshxD77ebcIIXp5cV2EEGKWfd8+IURCQ9fFRfXpJITYZrf7GyGEr317rBBinRAi0V6f2721LvZ944UQKUKIZCHEgisyUErZ7B7ADmCo/flE4G/254GAyf68DZCpvb6sfB+gI3AciLxsnxFbdvX/Afd4a12AQUC4/fltwDYvrsvtwApAAAMaoy4uqs9C4H7784+AKfbn8xyexwHHvbguXYFEh+9a1BXZ1xgfqKc9gDwuTXTEAClVHNMJyKjqQ3E4pioh+z/gCeCTRhKyBquLw75w4LS31gX4J/CAw+tDQBtPro9ddC84iMRAYJVDfZ5z2L7Fi+vyFvBYfe1rll1LbAmGx9qf34vtgwFACHGdECIZSAImSynNzp5UCNEOuAuY60Jba6NB6nIZj2Jr0TQ0DVWXdsBJh9en7NsamvrUJwLIddjuaPNLwG/s6RT/B0xrGPMr0FB16QZ0E0JsFkJsFULceiXGNVkhE0KsFkLsr+IxFlvTeKoQYhfQAijTykkpt0kp44F+wAwhhH8dLvs+tl9Kqwur4q66aNe+EZuQPeftdWkI3FSfB4BPpJTtsXWbPxdC1PtedlNdTNi6l8Ps9fpYCBFWZ+Mbuknq6Q9svwjbq9m3FuhbQ9njVOzCHLNvOw4UYBsvuNMb62Lfdg1wBOjm5Z+LW7qW9akPNXfHkoEYh2OPcoVjSx5Ql4+ARxyOXQP0q6tNTbZFVhNCiCj7fwPwZ2xvpjazYrI/7wBcje2mcAopZScpZUcpZUdgETBVSrnEpcZfRkPVRQgRCywGHpJSHnax2dVds0Hqgi1h9ARhYwCQJ6U860rbq6I+9ZG2u3odoM18PwwstT9PB0bYy/cA/IHzDViVhqzLEmytMYRtprkbNmGuG435q+QpD2A6cNj++DuXBjEfwvZrtwfYjUNrCttYRFv786ew9fPNwBlgfhXX+ITGGexvkLoA84Ece/k9wE4vrosA/oGtdZlEDa05D6tPZ2A7kAZ8C/jZt8cBm4G99nPc4sV1EcC7QIr9s7n/SuxTS5QUCoXX0yy7lgqFommhhEyhUHg9SsgUCoXXo4RMoVB4PUrIFAqF16OETKFQeD1KyBQKhdfz/wP23TUUyglUAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -2075,7 +2075,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -2658,10 +2658,10 @@ "from network_wrangler import Scenario\n", "my_scenario = Scenario.create_scenario(\n", " base_scenario={\"road_net\":net, \"transit_net\":transit_net}, \n", - " project_cards_list= [roadway_project_card]\n", + " project_card_list= [roadway_project_card]\n", " )\n", "\n", - "my_scenario .apply_all_projects()" + "my_scenario.apply_all_projects()" ] }, { @@ -2687,7 +2687,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "wrangler", "language": "python", "name": "python3" }, @@ -2701,7 +2701,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.12" + "version": "3.7.12 | packaged by conda-forge | (default, Oct 26 2021, 05:59:23) \n[Clang 11.1.0 ]" + }, + "vscode": { + "interpreter": { + "hash": "5cfb67e0b2744a84e81e5a9906808c277839f4126dccc23f819e7f035f52be10" + } } }, "nbformat": 4, From 48c708d2fb015187825bf15b65fe251d541cc3e6 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Tue, 7 Mar 2023 16:31:13 -0800 Subject: [PATCH 03/15] Update to use a deque object So you aren't iterating over a changing list --- network_wrangler/scenario.py | 51 +++++++++++++++++++++++------------- 1 file changed, 33 insertions(+), 18 deletions(-) diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index d92139da..fc74a25a 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -6,8 +6,10 @@ import glob import copy import pprint -from pathlib import Path + +from collections import deque from datetime import datetime +from pathlib import Path from typing import Union, Mapping, Collection import pandas as pd @@ -21,8 +23,7 @@ from .roadwaynetwork import RoadwayNetwork from .transitnetwork import TransitNetwork -##NEXT -# do lazy evaluation of queued projects including evaluating conflicts, etc. + class Scenario(object): """ Holds information about a scenario. @@ -124,10 +125,11 @@ def projects(self): @property def queued_projects(self): - if self._queued_projects is not None: + """Returns a list version of _queued_projects queue.""" + if self._queued_projects is None: self._check_projects_requirements_satisfied(self._planned_projects) self._queued_projects = self.order_projects(self._planned_projects) - return self._queued_projects + return list(self._queued_projects) def __str__(self): s = ["{}: {}".format(key, value) for key, value in self.__dict__.items()] @@ -419,14 +421,14 @@ def _check_projects_conflicts(self, project_names: str) -> None: WranglerLogger.debug(f"Problematic Conflicts:\n{_conf_dict}") raise ValueError(f"Found {len(_conflicts)} conflicts: {_conflict_problems}") - def order_projects(self, project_list: Collection[str]) -> Collection[str]: + def order_projects(self, project_list: Collection[str]) -> deque: """ - Orders a list of projects based on moving up pre-requisites. + Orders a list of projects based on moving up pre-requisites into a deque. args: project_list: list of projects to order - Returns: ordered list of project cards based on pre-requisites + Returns: deque for applying projects. """ project_list = [p.lower() for p in project_list] assert self._check_projects_have_project_cards(project_list) @@ -446,23 +448,31 @@ def order_projects(self, project_list: Collection[str]) -> Collection[str]: adjacency_list[prereq.lower()] = [project] # sorted_project_names is topological sorted project card names (based on prerequsiite) - ordered_projects = topological_sort( + _ordered_projects = topological_sort( adjacency_list=adjacency_list, visited_list=visited_list ) - if not set(ordered_projects) == set(project_list): - _missing = list(set(project_list) - set(ordered_projects)) + if not set(_ordered_projects) == set(project_list): + _missing = list(set(project_list) - set(_ordered_projects)) raise ValueError(f"Project sort resulted in missing projects:_missing") - WranglerLogger.debug(f"Ordered Projects:\n{ordered_projects}") + project_deque = deque(_ordered_projects) + + WranglerLogger.debug(f"Ordered Projects:\n{project_deque}") - return ordered_projects + return project_deque def apply_all_projects(self): """Applies all planned projects in the queue.""" + # Call this to make sure projects are appropriately queued in hidden variable. + self.queued_projects - for p in self.queued_projects: - self._apply_project(p) + # Use hidden variable. + while self._queued_projects: + self._apply_project(self._queued_projects.popleft()) + + # set this so it will trigger re-queuing any more projects. + self._queued_projects = None def _apply_change(self, change: dict) -> None: """Applies a specific change specified in a project card. @@ -515,6 +525,7 @@ def _apply_project(self, project_name: str) -> None: else: self._apply_change(p) + self._planned_projects.remove(project_name) self.applied_projects.append(project_name) def apply_projects(self, project_list: Collection[str]): @@ -531,10 +542,14 @@ def apply_projects(self, project_list: Collection[str]): project_list = [p.lower() for p in project_list] self._check_projects_requirements_satisfied(project_list) - ordered_projects = self.order_projects(project_list) + ordered_project_queue = self.order_projects(project_list) + + while ordered_project_queue: + self._apply_project(ordered_project_queue.popleft()) + + # Set so that when called again it will retrigger queueing from planned projects. + self._ordered_projects = None - for p in ordered_projects: - self._apply_project(p) def write(self, path: Union(Path, str), name: str) -> None: """_summary_ From 1dc89033d9f52a1dcf7664fcefce3f91c1c6a945 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Fri, 10 Mar 2023 16:00:50 -0800 Subject: [PATCH 04/15] Merge updates from develop. Black. --- main.py | 17 +++--- network_wrangler/roadwaynetwork.py | 58 +++++++++++++------ setup.py | 6 +- tests/test_dependencies.py | 1 - .../test_roadway/test_changes/test_pycode.py | 2 +- .../test_changes/test_roadway_add_delete.py | 13 ++++- .../test_roadway_feature_change.py | 19 ++++-- tests/test_roadway/test_selections.py | 29 +++++++--- tests/test_scenario.py | 1 + tests/test_transit.py | 3 + tests/test_utils.py | 6 ++ 11 files changed, 108 insertions(+), 47 deletions(-) diff --git a/main.py b/main.py index 57942360..388f3388 100644 --- a/main.py +++ b/main.py @@ -2,6 +2,7 @@ import os import re + def define_env(env): """ This is the hook for defining variables, macros and filters @@ -11,13 +12,15 @@ def define_env(env): """ @env.macro - def include_file(filename: str, downshift_h1 = True, start_line: int = 0, end_line: int = None): + def include_file( + filename: str, downshift_h1=True, start_line: int = 0, end_line: int = None + ): """ Include a file, optionally indicating start_line and end_line. args: filename: file to include, relative to the top directory of the documentation project. - downshift_h1: If true, will downshift headings by 1 if h1 heading found. Defaults to True. + downshift_h1: If true, will downshift headings by 1 if h1 heading found. Defaults to True. start_line (Optional): if included, will start including the file from this line (indexed to 0) end_line (Optional): if included, will stop including at this line (indexed to 0) @@ -39,10 +42,10 @@ def include_file(filename: str, downshift_h1 = True, start_line: int = 0, end_li print(f"???before downshifting! {full_filename}") if md_heading_re[1].search(content) and downshift_h1: print("!!!downshifting!") - content = re.sub(md_heading_re[5],r'#\1\2',content) - content = re.sub(md_heading_re[4],r'#\1\2',content) - content = re.sub(md_heading_re[3],r'#\1\2',content) - content = re.sub(md_heading_re[2],r'#\1\2',content) - content = re.sub(md_heading_re[1],r'#\1\2',content) + content = re.sub(md_heading_re[5], r"#\1\2", content) + content = re.sub(md_heading_re[4], r"#\1\2", content) + content = re.sub(md_heading_re[3], r"#\1\2", content) + content = re.sub(md_heading_re[2], r"#\1\2", content) + content = re.sub(md_heading_re[1], r"#\1\2", content) return content diff --git a/network_wrangler/roadwaynetwork.py b/network_wrangler/roadwaynetwork.py index 7cebf250..8d597e98 100644 --- a/network_wrangler/roadwaynetwork.py +++ b/network_wrangler/roadwaynetwork.py @@ -56,7 +56,7 @@ class RoadwayNetwork(object): Representation of a Roadway Network. Typical usage example: - + ```py net = RoadwayNetwork.read( link_file=MY_LINK_FILE, @@ -1695,8 +1695,10 @@ def update_node_geometry(self, updated_nodes: List = None) -> gpd.GeoDataFrame: updated_nodes_df = copy.deepcopy(self.nodes_df) updated_nodes = self.nodes_df.index.values.tolist() - if len(updated_nodes_df)<25: - WranglerLogger.debug(f"Original Nodes:\n{updated_nodes_df[['X','Y','geometry']]}") + if len(updated_nodes_df) < 25: + WranglerLogger.debug( + f"Original Nodes:\n{updated_nodes_df[['X','Y','geometry']]}" + ) updated_nodes_df["geometry"] = updated_nodes_df.apply( lambda x: point_from_xy( @@ -1708,14 +1710,18 @@ def update_node_geometry(self, updated_nodes: List = None) -> gpd.GeoDataFrame: axis=1, ) WranglerLogger.debug(f"{len(self.nodes_df)} nodes in network before update") - if len(updated_nodes_df)<25: - WranglerLogger.debug(f"Updated Nodes:\n{updated_nodes_df[['X','Y','geometry']]}") + if len(updated_nodes_df) < 25: + WranglerLogger.debug( + f"Updated Nodes:\n{updated_nodes_df[['X','Y','geometry']]}" + ) self.nodes_df.update( updated_nodes_df[[RoadwayNetwork.UNIQUE_NODE_KEY, "geometry"]] ) WranglerLogger.debug(f"{len(self.nodes_df)} nodes in network after update") - if len(self.nodes_df)<25: - WranglerLogger.debug(f"Updated self.nodes_df:\n{self.nodes_df[['X','Y','geometry']]}") + if len(self.nodes_df) < 25: + WranglerLogger.debug( + f"Updated self.nodes_df:\n{self.nodes_df[['X','Y','geometry']]}" + ) self._update_node_geometry_in_links_shapes(updated_nodes_df) @@ -1729,10 +1735,16 @@ def nodes_in_links( links_df: Links which to return node list for """ if len(links_df) < 25: - WranglerLogger.debug(f"Links:\n{links_df[RoadwayNetwork.LINK_FOREIGN_KEY_TO_NODE]}") - nodes_list = list(set( - pd.concat([links_df[c] for c in RoadwayNetwork.LINK_FOREIGN_KEY_TO_NODE]).tolist() - )) + WranglerLogger.debug( + f"Links:\n{links_df[RoadwayNetwork.LINK_FOREIGN_KEY_TO_NODE]}" + ) + nodes_list = list( + set( + pd.concat( + [links_df[c] for c in RoadwayNetwork.LINK_FOREIGN_KEY_TO_NODE] + ).tolist() + ) + ) if len(nodes_list) < 25: WranglerLogger.debug(f"_node_list:\n{nodes_list}") return nodes_list @@ -1748,20 +1760,26 @@ def links_with_nodes( node_id_list (list): List of nodes to find links for. Nodes should be identified by the foreign key - the one that is referenced in LINK_FOREIGN_KEY. """ - #If nodes are equal to all the nodes in the links, return all the links + # If nodes are equal to all the nodes in the links, return all the links _nodes_in_links = RoadwayNetwork.nodes_in_links(links_df) - WranglerLogger.debug(f"# Nodes: {len(node_id_list)}\nNodes in links:{len(_nodes_in_links)}") - if len( set(node_id_list) - set(_nodes_in_links) ) == 0: - return links_df + WranglerLogger.debug( + f"# Nodes: {len(node_id_list)}\nNodes in links:{len(_nodes_in_links)}" + ) + if len(set(node_id_list) - set(_nodes_in_links)) == 0: + return links_df WranglerLogger.debug(f"Finding links assocated with {len(node_id_list)} nodes.") if len(node_id_list) < 25: WranglerLogger.debug(f"node_id_list: {node_id_list}") _selected_links_df = links_df[ - links_df.isin({c:node_id_list for c in RoadwayNetwork.LINK_FOREIGN_KEY_TO_NODE}) + links_df.isin( + {c: node_id_list for c in RoadwayNetwork.LINK_FOREIGN_KEY_TO_NODE} + ) ] - WranglerLogger.debug(f"Temp Selected {len(_selected_links_df)} associated with {len(node_id_list)} nodes.") + WranglerLogger.debug( + f"Temp Selected {len(_selected_links_df)} associated with {len(node_id_list)} nodes." + ) """ _query_parts = [ f"{prop} == {str(n)}" @@ -1772,7 +1790,9 @@ def links_with_nodes( _query = " or ".join(_query_parts) _selected_links_df = links_df.query(_query, engine="python") """ - WranglerLogger.debug(f"Selected {len(_selected_links_df)} associated with {len(node_id_list)} nodes.") + WranglerLogger.debug( + f"Selected {len(_selected_links_df)} associated with {len(node_id_list)} nodes." + ) return _selected_links_df @@ -2451,7 +2471,7 @@ def delete_nodes(self, del_nodes: dict, ignore_missing: bool = True) -> None: f"Node deletion failed because being used in following links:\n{_links_with_nodes[RoadwayNetwork.LINK_FOREIGN_KEY_TO_NODE]}" ) raise ValueError - + # Check if node is in network if RoadwayNetwork.UNIQUE_NODE_KEY in del_nodes: _del_node_ids = pd.Series(del_nodes[RoadwayNetwork.UNIQUE_NODE_KEY]) diff --git a/setup.py b/setup.py index ffaf1ba8..f7cf0d9b 100644 --- a/setup.py +++ b/setup.py @@ -17,11 +17,11 @@ with open("requirements.txt") as f: install_requires = [r.strip() for r in f.readlines()] -EXTRAS = ["tests","viz","docs"] +EXTRAS = ["tests", "viz", "docs"] extras_require = {} for e in EXTRAS: with open(f"requirements.{e}.txt") as f: - extras_require[e]=[r.strip() for r in f.readlines()] + extras_require[e] = [r.strip() for r in f.readlines()] setup( @@ -36,5 +36,5 @@ packages=["network_wrangler"], include_package_data=True, install_requires=install_requires, - extras_require = extras_require, + extras_require=extras_require, ) diff --git a/tests/test_dependencies.py b/tests/test_dependencies.py index a524ed28..7118bbd2 100644 --- a/tests/test_dependencies.py +++ b/tests/test_dependencies.py @@ -2,7 +2,6 @@ import pytest - @pytest.mark.dependencies def test_dependencies_api(request): print("\n--Starting:", request.node.name) diff --git a/tests/test_roadway/test_changes/test_pycode.py b/tests/test_roadway/test_changes/test_pycode.py index c98dbc5d..2daf3439 100644 --- a/tests/test_roadway/test_changes/test_pycode.py +++ b/tests/test_roadway/test_changes/test_pycode.py @@ -40,7 +40,7 @@ def test_apply_pycode_roadway(request, small_net): _link_sel_idx = _link_sel["model_link_id"].squeeze() _expected_value = 12 _show_fields = ["model_link_id", "lanes"] - + WranglerLogger.debug(f"Before Change:\n{_link_sel[_show_fields]}") net = net.apply( diff --git a/tests/test_roadway/test_changes/test_roadway_add_delete.py b/tests/test_roadway/test_changes/test_roadway_add_delete.py index 3a753ce8..9818ce62 100644 --- a/tests/test_roadway/test_changes/test_roadway_add_delete.py +++ b/tests/test_roadway/test_changes/test_roadway_add_delete.py @@ -72,6 +72,7 @@ def test_add_roadway_link_project_card(request, small_net): WranglerLogger.info(f"--Finished: {request.node.name}") + def test_add_roadway_project_card(request, stpaul_net, stpaul_ex_dir): WranglerLogger.info(f"--Starting: {request.node.name}") @@ -92,13 +93,14 @@ def test_add_roadway_project_card(request, stpaul_net, stpaul_ex_dir): assert net_links == expected_net_links assert net_nodes == expected_net_nodes + def test_multiple_add_delete_roadway_project_card(request, stpaul_net, stpaul_ex_dir): WranglerLogger.info(f"--Starting: {request.node.name}") net = copy.deepcopy(stpaul_net) card_name = "11_multiple_roadway_add_and_delete_change.yml" expected_net_links = -2 + 2 - expected_net_nodes = +1 -1 + 1 + expected_net_nodes = +1 - 1 + 1 project_card_path = os.path.join(stpaul_ex_dir, "project_cards", card_name) project_card = ProjectCard.read(project_card_path, validate=False) @@ -112,6 +114,7 @@ def test_multiple_add_delete_roadway_project_card(request, stpaul_net, stpaul_ex assert net_links == expected_net_links assert net_nodes == expected_net_nodes + @pytest.mark.xfail(strict=True) def test_add_roadway_links(request, stpaul_net, stpaul_ex_dir): WranglerLogger.info(f"--Starting: {request.node.name}") @@ -133,6 +136,7 @@ def test_add_roadway_links(request, stpaul_net, stpaul_ex_dir): print("--Finished:", request.node.name) + def test_delete_roadway_shape(request, stpaul_net, stpaul_ex_dir): WranglerLogger.info(f"--Starting: {request.node.name}") @@ -148,7 +152,7 @@ def test_delete_roadway_shape(request, stpaul_net, stpaul_ex_dir): project_card = ProjectCard.read(project_card_path, validate=False) orig_links_count = len(net.links_df) - + net = net.apply(project_card.__dict__) net_links = len(net.links_df) - orig_links_count @@ -200,6 +204,7 @@ def test_add_nodes(request, small_net): "expected ValueError when adding a node with a model_node_id that already exists" WranglerLogger.info(f"--Finished: {request.node.name}") + def test_change_node_xy(request, small_net): """Tests if X and Y property changes from a project card also update the node/link geometry.""" WranglerLogger.info(f"--Starting: {request.node.name}") @@ -241,7 +246,9 @@ def test_change_node_xy(request, small_net): _updated_link = net.links_df.loc[_test_link_idx] _first_point = _updated_link.geometry.coords[0] - WranglerLogger.info(f"Updated Node:\n{_updated_node[[RoadwayNetwork.UNIQUE_NODE_KEY,'X','Y','geometry']]}") + WranglerLogger.info( + f"Updated Node:\n{_updated_node[[RoadwayNetwork.UNIQUE_NODE_KEY,'X','Y','geometry']]}" + ) WranglerLogger.info( f"Updated Link Geometry for ({_updated_link.A}-->{_updated_link.B}):\n{_updated_link[['geometry']]}" ) diff --git a/tests/test_roadway/test_changes/test_roadway_feature_change.py b/tests/test_roadway/test_changes/test_roadway_feature_change.py index 4ee4ef64..2e953977 100644 --- a/tests/test_roadway/test_changes/test_roadway_feature_change.py +++ b/tests/test_roadway/test_changes/test_roadway_feature_change.py @@ -118,6 +118,7 @@ def test_change_multiple_properties_multiple_links(request, stpaul_net): assert _rev_links[p["property"]].eq(_expected_value).all() WranglerLogger.info(f"--Finished: {request.node.name}") + def test_change_multiple_properties_multiple_links_existing_set(request, stpaul_net): WranglerLogger.info(f"--Starting: {request.node.name}") net = copy.deepcopy(stpaul_net) @@ -177,7 +178,9 @@ def test_add_adhoc_field(request, small_net): net = copy.deepcopy(small_net) net.links_df["my_ad_hoc_field"] = 22.5 - WranglerLogger.debug(f"Network with field...\n{net.links_df['my_ad_hoc_field'].iloc[0:5]}") + WranglerLogger.debug( + f"Network with field...\n{net.links_df['my_ad_hoc_field'].iloc[0:5]}" + ) assert net.links_df["my_ad_hoc_field"].iloc[0] == 22.5 WranglerLogger.info(f"--Finished: {request.node.name}") @@ -243,7 +246,9 @@ def test_add_adhoc_field_from_card(request, stpaul_net, stpaul_ex_dir): rev_links = net.links_df.loc[selected_link_indices, attributes_to_update] rev_types = [(a, net.links_df[a].dtypes) for a in attributes_to_update] - WranglerLogger.debug(f"Revised Links:\n{rev_links}\nNew Property Types:\n{rev_types}") + WranglerLogger.debug( + f"Revised Links:\n{rev_links}\nNew Property Types:\n{rev_types}" + ) assert net.links_df.loc[selected_link_indices[0], "my_ad_hoc_field_float"] == 1.1 assert net.links_df.loc[selected_link_indices[0], "my_ad_hoc_field_integer"] == 2 @@ -266,12 +271,16 @@ def test_bad_properties_statements(request, small_net): bad_properties_existing = [{"property": "my_random_var", "existing": 1}] with pytest.raises(ValueError): - net.validate_properties(net.links_df,bad_properties_change) + net.validate_properties(net.links_df, bad_properties_change) with pytest.raises(ValueError): - net.validate_properties(net.links_df,ok_properties_change, require_existing_for_change=True) + net.validate_properties( + net.links_df, ok_properties_change, require_existing_for_change=True + ) with pytest.raises(ValueError): - net.validate_properties(net.links_df,bad_properties_existing, ignore_existing=False) + net.validate_properties( + net.links_df, bad_properties_existing, ignore_existing=False + ) WranglerLogger.info(f"--Finished: {request.node.name}") diff --git a/tests/test_roadway/test_selections.py b/tests/test_roadway/test_selections.py index 1fd06491..ec62d187 100644 --- a/tests/test_roadway/test_selections.py +++ b/tests/test_roadway/test_selections.py @@ -59,8 +59,10 @@ def test_select_roadway_features(request, selection, stpaul_net): net.select_roadway_features(selection) sel_key = net.build_selection_key(selection) - - WranglerLogger.debug(f"Features selected: {len(net.selections[sel_key]['selected_links'])}") + + WranglerLogger.debug( + f"Features selected: {len(net.selections[sel_key]['selected_links'])}" + ) selected_link_indices = net.selections[sel_key]["selected_links"].index.tolist() if "answer" in selection.keys(): selected_nodes = [str(selection["A"]["osm_node_id"])] + net.links_df.loc[ @@ -86,19 +88,21 @@ def test_select_roadway_features_from_projectcard(request, stpaul_net, stpaul_ex selected_link_idx = net.select_roadway_features(_facility) WranglerLogger.debug(f"Features selected: {len(selected_link_idx)}") - selected_nodes = \ - [str(_facility["A"]["osm_node_id"])] \ - + net.links_df.loc[selected_link_idx, "v"].tolist() + selected_nodes = [str(_facility["A"]["osm_node_id"])] + net.links_df.loc[ + selected_link_idx, "v" + ].tolist() assert set(selected_nodes) == set(_expected_answer) WranglerLogger.info(f"--Finished: {request.node.name}") + variable_queries = [ {"v": "lanes", "category": None, "time_period": ["7:00", "9:00"]}, {"v": "ML_price", "category": "sov", "time_period": ["7:00", "9:00"]}, {"v": "ML_price", "category": ["hov3", "hov2"], "time_period": ["7:00", "9:00"]}, ] + @pytest.mark.menow @pytest.mark.parametrize("variable_query", variable_queries) def test_query_roadway_property_by_time_group( @@ -124,11 +128,14 @@ def test_query_roadway_property_by_time_group( selected_link_indices = net.select_roadway_features(project_card.facility) WranglerLogger.debug(f"CALCULATED:\n{v_series.loc[selected_link_indices]}") - WranglerLogger.debug(f"ORIGINAL:\n{net.links_df.loc[selected_link_indices, variable_query['v']]}") + WranglerLogger.debug( + f"ORIGINAL:\n{net.links_df.loc[selected_link_indices, variable_query['v']]}" + ) # TODO make test make sure the values are correct. WranglerLogger.info(f"--Finished: {request.node.name}") + def test_get_modal_network(request, stpaul_net): WranglerLogger.info(f"--Starting: {request.node.name}") @@ -142,7 +149,9 @@ def test_get_modal_network(request, stpaul_net): ) test_links_of_selection = _links_df["model_link_id"].tolist() - WranglerLogger.debug(f"TEST - Number of selected links: {len(test_links_of_selection)}") + WranglerLogger.debug( + f"TEST - Number of selected links: {len(test_links_of_selection)}" + ) mode_variables = RoadwayNetwork.MODES_TO_NETWORK_LINK_VARIABLES[mode] @@ -151,7 +160,9 @@ def test_get_modal_network(request, stpaul_net): control_links_of_selection.extend( net.links_df.loc[net.links_df[m], "model_link_id"] ) - WranglerLogger.debug(f"CONTROL - Number of selected links: {len(control_links_of_selection)}") + WranglerLogger.debug( + f"CONTROL - Number of selected links: {len(control_links_of_selection)}" + ) all_model_link_ids = _links_df["model_link_id"].tolist() WranglerLogger.debug(f"CONTROL - Number of total links: {len(all_model_link_ids)}") @@ -159,6 +170,7 @@ def test_get_modal_network(request, stpaul_net): assert set(test_links_of_selection) == set(control_links_of_selection) WranglerLogger.info(f"--Finished: {request.node.name}") + def test_identify_segment_ends(request, stpaul_net): WranglerLogger.info(f"--Starting: {request.node.name}") @@ -190,6 +202,7 @@ def test_identify_segment_ends(request, stpaul_net): assert calculated_d == correct_d WranglerLogger.info(f"--Finished: {request.node.name}") + def test_find_segment(request, stpaul_net): "TODO: add assert" WranglerLogger.info(f"--Starting: {request.node.name}") diff --git a/tests/test_scenario.py b/tests/test_scenario.py index 0d5f8065..18c8ff46 100644 --- a/tests/test_scenario.py +++ b/tests/test_scenario.py @@ -50,6 +50,7 @@ def test_project_card_write(request): for k, v in project_card.__dict__.items(): assert v == test_card.__dict__[k] + def test_scenario_conflicts(request): project_cards_list = [] project_cards_list.append( diff --git a/tests/test_transit.py b/tests/test_transit.py index 74892a5d..fd096446 100644 --- a/tests/test_transit.py +++ b/tests/test_transit.py @@ -269,6 +269,7 @@ def test_zero_valid_facilities(request): print("--Finished:", request.node.name) + def test_invalid_selection_key(request): print("\n--Starting:", request.node.name) net = TransitNetwork.read(STPAUL_DIR) @@ -279,6 +280,7 @@ def test_invalid_selection_key(request): print("--Finished:", request.node.name) + def test_invalid_optional_selection_variable(request): print("\n--Starting:", request.node.name) net = TransitNetwork.read(STPAUL_DIR) @@ -305,6 +307,7 @@ def test_invalid_optional_selection_variable(request): print("--Finished:", request.node.name) + def test_transit_road_consistencies(request): print("\n--Starting:", request.node.name) net = TransitNetwork.read(STPAUL_DIR) diff --git a/tests/test_utils.py b/tests/test_utils.py index 7a8bd634..9543b85d 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -13,6 +13,7 @@ {"text": "I am a roadway", "delim": "", "answer": "iamaroadway"}, ] + @pytest.mark.parametrize("slug_test", slug_test_list) def test_get_slug(request, slug_test): print("\n--Starting:", request.node.name) @@ -25,6 +26,7 @@ def test_get_slug(request, slug_test): print("Expected: {}".format(slug_test["answer"])) assert slug == slug_test["answer"] + def test_time_convert(request): print("\n--Starting:", request.node.name) @@ -50,6 +52,7 @@ def test_time_convert(request): assert_series_equal(df["time"], df["time_results"], check_names=False) + def test_get_distance_bw_lat_lon(request): print("\n--Starting:", request.node.name) @@ -60,6 +63,7 @@ def test_get_distance_bw_lat_lon(request): assert dist == 0.34151200885686445 print("--Finished:", request.node.name) + def test_get_unique_shape_id(request): geometry = LineString([[-93.0855338, 44.9662078], [-93.0843092, 44.9656997]]) @@ -69,6 +73,7 @@ def test_get_unique_shape_id(request): print("--Finished:", request.node.name) + def test_location_reference_offset(request): print("\n--Starting:", request.node.name) @@ -91,6 +96,7 @@ def test_location_reference_offset(request): print("--Finished:", request.node.name) + @pytest.mark.menow def test_point_from_xy(request): from network_wrangler.utils import point_from_xy From e459a161f1ad9ba87a2956ea3512335d6b36a8f8 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Thu, 16 Mar 2023 09:44:23 -0700 Subject: [PATCH 05/15] add a little more documentation --- network_wrangler/scenario.py | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index 5eaf47b5..5237229a 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -31,7 +31,7 @@ class Scenario(object): Typical usage example: ```python - my_base_scenario = { + my_base_year_scenario = { "road_net": RoadwayNetwork.read( link_file=STPAUL_LINK_FILE, node_file=STPAUL_NODE_FILE, @@ -41,29 +41,32 @@ class Scenario(object): "transit_net": TransitNetwork.read(STPAUL_DIR), } - card_filenames = [ - "3_multiple_roadway_attribute_change.yml", - "multiple_changes.yml", - "4_simple_managed_lane.yml", - ] - + # create a future baseline scenario from a base by searching for all cards in a dir w/ baseline tag project_card_directory = os.path.join(STPAUL_DIR, "project_cards") - my_scenario = Scenario.create_scenario( - base_scenario=my_base_scenario, + base_scenario=my_base_year_scenario, card_search_dir=project_card_directory, + filter_tags = [ "baseline2050" ] ) - #check project card queue + # check project card queue and then apply the projects my_scenario.queued_projects - - #apply the projects my_scenario.apply_all_projects() - #check applied projects + # check applied projects, write it out, and create a summary report. my_scenario.applied_projects - my_scenario.write("my_scenario","optionA") - my_scenario.summarize() + my_scenario.write("baseline") + my_scenario.summarize(outfile = "baseline2050summary.txt") + + # Add some projects to create a build scenario based on a list of files. + build_card_filenames = [ + "3_multiple_roadway_attribute_change.yml", + "multiple_changes.yml", + "4_simple_managed_lane.yml", + ] + my_scenario.add_projects_from_files(build_card_filenames) + my_scenario.write("build2050") + my_scenario.summarize(outfile = "build2050summary.txt") ``` Attributes: From bfa3f17b24a0571aa3487e2c3e80f88224e0a65e Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Tue, 21 Mar 2023 14:53:38 -0700 Subject: [PATCH 06/15] Update notebook/Scenario Building Example.ipynb Co-authored-by: Sijia Wang --- notebook/Scenario Building Example.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebook/Scenario Building Example.ipynb b/notebook/Scenario Building Example.ipynb index 521783cf..320268d3 100644 --- a/notebook/Scenario Building Example.ipynb +++ b/notebook/Scenario Building Example.ipynb @@ -180,7 +180,7 @@ "source": [ "my_scenario_nobuild = Scenario.create_scenario(\n", " base_scenario=base_scenario, \n", - " card_search_directory = os.path.join(STPAUL_DIR, \"project_cards\"),\n", + " card_search_dir = os.path.join(STPAUL_DIR, \"project_cards\"),\n", " glob_search = \"*attribute*.yml\"\n", ")" ] From 48ad42bd6b73a8810f45b251b1a1f53a7e2c9447 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Tue, 21 Mar 2023 15:07:50 -0700 Subject: [PATCH 07/15] Fix default project_card_list to be [] not None Also: - Better document Scenario.__init__ arguments - Require minimum variables in base_scenario: applied_projects and conflicts --- network_wrangler/scenario.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index 5237229a..750c92d9 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -23,6 +23,7 @@ from .roadwaynetwork import RoadwayNetwork from .transitnetwork import TransitNetwork +BASE_SCENARIO_REQUIRES = ["applied_projects","conflicts"] class Scenario(object): """ @@ -87,15 +88,17 @@ class Scenario(object): def __init__( self, base_scenario: Union[Scenario, dict], - project_card_list: list[ProjectCard] = None, + project_card_list: list[ProjectCard] = [], name="", ): """ Constructor args: - base_scenario: dict the base scenario - project_card_list: list of ProjectCard instances + base_scenario: A base scenario object to base this isntance off of, or a dict which + describes the scenario attributes including applied projects and respective conflicts. + `{"applied_projects": [],"conflicts":{...}}` + project_card_list: Optional list of ProjectCard instances to add to planned projects. """ WranglerLogger.info( f"Creating Scenario with {len(project_card_list)} project cards" @@ -104,6 +107,9 @@ def __init__( if type(base_scenario) == "Scenario": base_scenario = base_scenario.__dict__ + if not set(BASE_SCENARIO_REQUIRES) <= set(base_scenario.keys()): + raise ValueError(f"base_scenario must contain {BASE_SCENARIO_REQUIRES}") + self.base_scenario = base_scenario self.name = name # if the base scenario had roadway or transit networks, use them as the basis. @@ -113,11 +119,11 @@ def __init__( self.project_cards = {} self._planned_projects = [] self._queued_projects = None - self.applied_projects = self.base_scenario.get("applied_projects", []) + self.applied_projects = self.base_scenario["applied_projects"] self.prerequisites = self.base_scenario.get("prerequisites", {}) self.corequisites = self.base_scenario.get("corequisites", {}) - self.conflicts = self.base_scenario.get("conflicts", {}) + self.conflicts = self.base_scenario["conflicts"] for p in project_card_list: self._add_project(p) From f0dbbd7a7437e999404a86418c56ad329335ed0a Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Tue, 21 Mar 2023 15:48:36 -0700 Subject: [PATCH 08/15] Address mapping type --> list and set type needed for isdisjoint --- network_wrangler/scenario.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index 750c92d9..d9199ab3 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -240,14 +240,14 @@ def _add_project( """ project_name = project_card.project.lower() - filter_tags = map(str.lower, filter_tags) + filter_tags = list(map(str.lower, filter_tags)) if project_name in self.projects: raise ValueError( f"Names not unique from existing scenario projects: {project_card.project}" ) - if filter_tags and project_card.tags.isdisjoint(filter_tags): + if filter_tags and set(project_card.tags).isdisjoint(set(filter_tags)): WranglerLogger.debug( f"Skipping {project_name} - no overlapping tags with {filter_tags}." ) From cff89fd82c7ad563d748d3d4f740a0e6d547cc45 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Wed, 22 Mar 2023 09:36:48 -0700 Subject: [PATCH 09/15] Varia fixes from Sijia! (thx!) - is_disjoint is actually isdisjoint (doh!) and performed on a set object - mapping objects converted to lists (doh!) - `planned_proejects` should actually be `_planned _projects` - _queued_projects should be truthiness-checked, not ever none --- network_wrangler/scenario.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index d9199ab3..5d298c71 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -135,7 +135,7 @@ def projects(self): @property def queued_projects(self): """Returns a list version of _queued_projects queue.""" - if self._queued_projects is None: + if not self._queued_projects: self._check_projects_requirements_satisfied(self._planned_projects) self._queued_projects = self.order_projects(self._planned_projects) return list(self._queued_projects) @@ -213,7 +213,7 @@ def _add_dependencies(self, project_name, dependencies: dict) -> None: for d in ["prerequisites", "corequisites", "conflicts"]: if d not in dependencies: continue - _dep = {k.lower(): map(str.lower, v) for k, v in dependencies[d].items()} + _dep = {k.lower(): list(map(str.lower, v)) for k, v in dependencies[d].items()} self.__dict__[d].update({project_name: _dep}) def _add_project( @@ -369,7 +369,7 @@ def _check_projects_requirements_satisfied(self, project_list: Collection[str]): def _check_projects_planned(self, project_names: Collection[str]) -> None: """Checks that a list of projects are in the scenario's planned projects.""" _missing_ps = [ - p for p in self.planned_projects if p not in self.planned_projects + p for p in self._planned_projects if p not in self._planned_projects ] if _missing_ps: raise ValueError( @@ -389,7 +389,7 @@ def _check_projects_have_project_cards(self, project_list: Collection[str]) -> b def _check_projects_prerequisites(self, project_names: str) -> None: """Checks that a list of projects' pre-requisites have been or will be applied to scenario.""" - if project_names.is_disjoint(self.prerequisites): + if set(project_names).isdisjoint(set(self.prerequisites)): return _prereqs = set( [self.prerequisites[p] for p in project_names if p in self.prerequisites] @@ -401,7 +401,7 @@ def _check_projects_prerequisites(self, project_names: str) -> None: def _check_projects_corequisites(self, project_names: str) -> None: """Checks that a list of projects' co-requisites have been or will be applied to scenario.""" - if project_names.is_disjoint(self.corequisites): + if set(project_names).isdisjoint(set(self.corequisites)): return _coreqs = set( [self.corequisites[p] for p in project_names if p in self.corequisites] @@ -414,7 +414,7 @@ def _check_projects_corequisites(self, project_names: str) -> None: def _check_projects_conflicts(self, project_names: str) -> None: """Checks that a list of projects' conflicts have not been or will be applied to scenario.""" projects_to_check = project_names + self.applied_projects - if projects_to_check.is_disjoint(self.conflicts): + if set(projects_to_check).isdisjoint(set(self.conflicts)): return _conflicts = list( set([self.conflicts[p] for p in projects_to_check if p in self.conflicts]) @@ -425,7 +425,7 @@ def _check_projects_conflicts(self, project_names: str) -> None: _conf_dict = { k: v for k, v in self.conflicts.items() - if k in projects_to_check and not v.is_disjoint(_conflict_problems) + if k in projects_to_check and not set(v).isdisjoint(set(_conflict_problems)) } WranglerLogger.debug(f"Problematic Conflicts:\n{_conf_dict}") raise ValueError(f"Found {len(_conflicts)} conflicts: {_conflict_problems}") From e35d84403fea9724d9f78aabada0cffeafa38e35 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Wed, 22 Mar 2023 09:53:15 -0700 Subject: [PATCH 10/15] Remove universal lower() / fixed validate method ref --- network_wrangler/projectcard.py | 3 ++- network_wrangler/scenario.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/network_wrangler/projectcard.py b/network_wrangler/projectcard.py index c1810045..1019f966 100644 --- a/network_wrangler/projectcard.py +++ b/network_wrangler/projectcard.py @@ -94,6 +94,7 @@ def read(path_to_card: str, validate: bool = True): return card + @staticmethod def read_wrangler_card(path_to_card: str) -> dict: """ @@ -131,7 +132,7 @@ def read_yml(path_to_card: str) -> dict: WranglerLogger.debug("Reading YAML-Style Project Card") with open(path_to_card, "r") as cardfile: - attribute_dictionary = yaml.safe_load(cardfile.read().lower()) + attribute_dictionary = yaml.safe_load(cardfile.read()) attribute_dictionary["file"] = path_to_card return attribute_dictionary diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index 5d298c71..82adeed4 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -254,7 +254,7 @@ def _add_project( return if validate: - project_card.validate() + project_card.validate_project_card_schema(project_card.file) WranglerLogger.info(f"Adding {project_name} to scenario.") self.project_cards[project_name] = project_card From f081e52d1ff20f5fcbf647de422e93c2317554c1 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Wed, 22 Mar 2023 15:35:02 -0700 Subject: [PATCH 11/15] scenario tests now use fixtures + are consistently formatted also: - fixed a lot of API usage - added specific Exception types for better error catching in testing - black --- network_wrangler/logger.py | 23 +- network_wrangler/projectcard.py | 5 +- network_wrangler/scenario.py | 163 ++++++--- notebook/Scenario Building Example.ipynb | 4 +- notebook/Visual Checks.ipynb | 13 +- notebook/change-functionality-bug.ipynb | 11 +- scripts/build_scenario.py | 10 +- tests/conftest.py | 34 +- .../test_changes/test_managed_lanes.py | 4 - tests/test_roadway/test_model_roadway.py | 6 +- tests/test_roadway/test_selections.py | 103 +++++- tests/test_scenario.py | 341 ++++++------------ 12 files changed, 396 insertions(+), 321 deletions(-) diff --git a/network_wrangler/logger.py b/network_wrangler/logger.py index d6480058..03714af0 100644 --- a/network_wrangler/logger.py +++ b/network_wrangler/logger.py @@ -11,10 +11,13 @@ WranglerLogger = logging.getLogger("WranglerLogger") + def setup_logging( - info_log_filename: str = None, - debug_log_filename: str = "wrangler_{}.debug.log".format(datetime.now().strftime("%Y_%m_%d__%H_%M_%S")), - log_to_console: bool = False + info_log_filename: str = None, + debug_log_filename: str = "wrangler_{}.debug.log".format( + datetime.now().strftime("%Y_%m_%d__%H_%M_%S") + ), + log_to_console: bool = False, ): """ Sets up the WranglerLogger w.r.t. the debug file location and if logging to console. @@ -25,12 +28,12 @@ def setup_logging( Defaults to file in cwd() `wrangler_[datetime].log`. To turn off logging to a file, use log_filename = None. debug_log_filename: the location of the log file that will get created to add the DEBUG log. - The DEBUG log is very noisy, for debugging. Defaults to file in cwd() + The DEBUG log is very noisy, for debugging. Defaults to file in cwd() `wrangler_[datetime].log`. To turn off logging to a file, use log_filename = None. log_to_console: if True, logging will go to the console at DEBUG level. Defaults to False. """ - #add function variable so that we know if logging has been called + # add function variable so that we know if logging has been called setup_logging.called = True # Clear handles if any exist already @@ -43,11 +46,13 @@ def setup_logging( ) if not info_log_filename: info_log_filename = os.path.join( - os.getcwd(), - "network_wrangler_{}.info.log".format(datetime.now().strftime("%Y_%m_%d__%H_%M_%S")), - ) + os.getcwd(), + "network_wrangler_{}.info.log".format( + datetime.now().strftime("%Y_%m_%d__%H_%M_%S") + ), + ) - info_file_handler = logging.StreamHandler(open(info_log_filename,'w')) + info_file_handler = logging.StreamHandler(open(info_log_filename, "w")) info_file_handler.setLevel(logging.INFO) info_file_handler.setFormatter(FORMAT) WranglerLogger.addHandler(info_file_handler) diff --git a/network_wrangler/projectcard.py b/network_wrangler/projectcard.py index 1019f966..a0b08d6f 100644 --- a/network_wrangler/projectcard.py +++ b/network_wrangler/projectcard.py @@ -48,8 +48,8 @@ def __init__(self, attribute_dictonary: dict): """ # add these first so they are first on write out self.project = None - self.tags = "" - self.dependencies = "" + self.tags = [] + self.dependencies = {} self.__dict__.update(attribute_dictonary) self.valid = False @@ -94,7 +94,6 @@ def read(path_to_card: str, validate: bool = True): return card - @staticmethod def read_wrangler_card(path_to_card: str) -> dict: """ diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index 82adeed4..4a0fa749 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -10,20 +10,40 @@ from collections import deque from datetime import datetime from pathlib import Path -from typing import Union, Mapping, Collection +from typing import Union, Collection -import pandas as pd import geopandas as gpd from .projectcard import ProjectCard -from collections import OrderedDict from .logger import WranglerLogger from collections import defaultdict from .utils import topological_sort from .roadwaynetwork import RoadwayNetwork from .transitnetwork import TransitNetwork -BASE_SCENARIO_REQUIRES = ["applied_projects","conflicts"] +BASE_SCENARIO_SUGGESTED_PROPS = [ + "road_net", + "transit_net", + "applied_projects", + "conflicts", +] + + +class ScenarioConflictError(Exception): + pass + + +class ScenarioCorequisiteError(Exception): + pass + + +class ScenarioPrerequisiteError(Exception): + pass + + +class ProjectCardError(Exception): + pass + class Scenario(object): """ @@ -42,7 +62,7 @@ class Scenario(object): "transit_net": TransitNetwork.read(STPAUL_DIR), } - # create a future baseline scenario from a base by searching for all cards in a dir w/ baseline tag + # create a future baseline scenario from base by searching for all cards in dir w/ baseline tag project_card_directory = os.path.join(STPAUL_DIR, "project_cards") my_scenario = Scenario.create_scenario( base_scenario=my_base_year_scenario, @@ -76,8 +96,8 @@ class Scenario(object): transit_net: instance of TransitNetwork for the scenario project_cards: Mapping[ProjectCard.name,ProjectCard] Storage of all project cards by name. queued_projects: Projects which are "shovel ready" - have had pre-requisits checked and - done any required re-ordering. Similar to a git staging, project cards aren't recognized - in this collecton once they are moved to applied. + done any required re-ordering. Similar to a git staging, project cards aren't + recognized in this collecton once they are moved to applied. applied_projects: list of project names that have been applied projects: list of all projects either planned, queued, or applied prerequisites: dictionary storing prerequiste information @@ -95,20 +115,20 @@ def __init__( Constructor args: - base_scenario: A base scenario object to base this isntance off of, or a dict which + base_scenario: A base scenario object to base this isntance off of, or a dict which describes the scenario attributes including applied projects and respective conflicts. `{"applied_projects": [],"conflicts":{...}}` - project_card_list: Optional list of ProjectCard instances to add to planned projects. + project_card_list: Optional list of ProjectCard instances to add to planned projects. """ - WranglerLogger.info( - f"Creating Scenario with {len(project_card_list)} project cards" - ) + WranglerLogger.info("Creating Scenario") if type(base_scenario) == "Scenario": base_scenario = base_scenario.__dict__ - if not set(BASE_SCENARIO_REQUIRES) <= set(base_scenario.keys()): - raise ValueError(f"base_scenario must contain {BASE_SCENARIO_REQUIRES}") + if not set(BASE_SCENARIO_SUGGESTED_PROPS) <= set(base_scenario.keys()): + WranglerLogger.warning( + f"Base_scenario doesn't contain {BASE_SCENARIO_SUGGESTED_PROPS}" + ) self.base_scenario = base_scenario self.name = name @@ -119,18 +139,18 @@ def __init__( self.project_cards = {} self._planned_projects = [] self._queued_projects = None - self.applied_projects = self.base_scenario["applied_projects"] + self.applied_projects = self.base_scenario.get("applied_projects", []) self.prerequisites = self.base_scenario.get("prerequisites", {}) self.corequisites = self.base_scenario.get("corequisites", {}) - self.conflicts = self.base_scenario["conflicts"] + self.conflicts = self.base_scenario.get("conflicts", {}) for p in project_card_list: self._add_project(p) @property def projects(self): - return self.applied_projects + self.queued_projects + return self.applied_projects + self._planned_projects @property def queued_projects(self): @@ -151,7 +171,7 @@ def create_scenario( project_card_file_list=[], card_search_dir: str = "", glob_search="", - filter_tags: Collection[str] = None, + filter_tags: Collection[str] = [], validate=True, ) -> Scenario: """ @@ -206,14 +226,13 @@ def _add_dependencies(self, project_name, dependencies: dict) -> None: Args: project_name: name of project you are adding dependencies for. - dependencies: Dictionary of depndencies by dependency type and list of associated projects. + dependencies: Dictionary of depndencies by dependency type and list of associated + projects. """ project_name = project_name.lower() WranglerLogger.debug(f"Adding {project_name} dependencies:\n{dependencies}") - for d in ["prerequisites", "corequisites", "conflicts"]: - if d not in dependencies: - continue - _dep = {k.lower(): list(map(str.lower, v)) for k, v in dependencies[d].items()} + for d, v in dependencies.items(): + _dep = list(map(str.lower, v)) self.__dict__[d].update({project_name: _dep}) def _add_project( @@ -243,7 +262,7 @@ def _add_project( filter_tags = list(map(str.lower, filter_tags)) if project_name in self.projects: - raise ValueError( + raise ProjectCardError( f"Names not unique from existing scenario projects: {project_card.project}" ) @@ -254,14 +273,18 @@ def _add_project( return if validate: + if not project_card.__dict__.get("file", None): + WranglerLogger.warning( + f"Could not validate Project Card {project_card.project} because no file specified" + ) + return project_card.validate_project_card_schema(project_card.file) WranglerLogger.info(f"Adding {project_name} to scenario.") self.project_cards[project_name] = project_card self._planned_projects.append(project_name) self._queued_projects = None - if "dependencies" in project_card: - self._add_dependencies(project_name, project_card.dependencies) + self._add_dependencies(project_name, project_card.dependencies) def add_project_cards( self, @@ -281,8 +304,8 @@ def add_project_cards( validate (bool, optional): If True, will require each ProjectCard is validated before being added to scenario. Defaults to True. filter_tags (Collection[str], optional): If used, will filter ProjectCard instances - and only add those whose tags match one or more of these filter_tags. Defaults to [] - which means no tag-filtering will occur. + and only add those whose tags match one or more of these filter_tags. + Defaults to [] - which means no tag-filtering will occur. """ for p in project_card_list: self._add_project(p, validate=validate, filter_tags=filter_tags) @@ -301,12 +324,13 @@ def add_projects_from_files( If provided, will only add ProjectCard if it matches at least one filter_tags. Args: - project_card_file_list (Collection[str]): List of project card files to add to scenario. + project_card_file_list (Collection[str]): List of project card files to add to + scenario. validate (bool, optional): If True, will require each ProjectCard is validated before being added to scenario. Defaults to True. filter_tags (Collection[str], optional): If used, will filter ProjectCard instances - and only add those whose tags match one or more of these filter_tags. Defaults to [] - which means no tag-filtering will occur. + and only add those whose tags match one or more of these filter_tags. + Defaults to [] - which means no tag-filtering will occur. """ _project_card_list = [ ProjectCard.read(_pc_file) for _pc_file in project_card_file_list @@ -358,7 +382,8 @@ def _check_projects_requirements_satisfied(self, project_list: Collection[str]): Args: project_name (str): name of project. - co_applied_project_list (Collection[str]): List of projects that will be applied with this project. + co_applied_project_list (Collection[str]): List of projects that will be applied + with this project. """ self._check_projects_planned(project_list) self._check_projects_have_project_cards(project_list) @@ -374,7 +399,8 @@ def _check_projects_planned(self, project_names: Collection[str]) -> None: if _missing_ps: raise ValueError( f"Projects are not in planned projects:\n {_missing_ps}. Add them by \ - using add_project_cards(), add_projects_from_files(), or add_projects_from_directory()." + using add_project_cards(), add_projects_from_files(), or \ + add_projects_from_directory()." ) def _check_projects_have_project_cards(self, project_list: Collection[str]) -> bool: @@ -388,47 +414,63 @@ def _check_projects_have_project_cards(self, project_list: Collection[str]) -> b return True def _check_projects_prerequisites(self, project_names: str) -> None: - """Checks that a list of projects' pre-requisites have been or will be applied to scenario.""" - if set(project_names).isdisjoint(set(self.prerequisites)): + """Checks that list of projects' pre-requisites have been or will be applied to scenario.""" + if set(project_names).isdisjoint(set(self.prerequisites.keys())): return - _prereqs = set( - [self.prerequisites[p] for p in project_names if p in self.prerequisites] - ) - _projects_applied = set(self.applied_projects + project_names) - _missing = list(_prereqs - _projects_applied) + _prereqs = [] + for p in project_names: + _prereqs += self.prerequisites.get(p, []) + _projects_applied = self.applied_projects + project_names + _missing = list(set(_prereqs) - set(_projects_applied)) if _missing: - raise ValueError(f"Missing {len(_missing)} pre-requites: {_missing}") + WranglerLogger.debug( + f"project_names: {project_names}\nprojects_have_or_will_be_applied:{_projects_applied}\nmissing: {_missing}" + ) + raise ScenarioPrerequisiteError( + f"Missing {len(_missing)} pre-requisites: {_missing}" + ) def _check_projects_corequisites(self, project_names: str) -> None: """Checks that a list of projects' co-requisites have been or will be applied to scenario.""" - if set(project_names).isdisjoint(set(self.corequisites)): + if set(project_names).isdisjoint(set(self.corequisites.keys())): return - _coreqs = set( - [self.corequisites[p] for p in project_names if p in self.corequisites] - ) - _projects_applied = set(self.applied_projects + project_names) - _missing = list(_coreqs - _projects_applied) + _coreqs = [] + for p in project_names: + _coreqs += self.corequisites.get(p, []) + _projects_applied = self.applied_projects + project_names + _missing = list(set(_coreqs) - set(_projects_applied)) if _missing: - raise ValueError(f"Missing {len(_missing)} corequites: {_missing}") + WranglerLogger.debug( + f"project_names: {project_names}\nprojects_have_or_will_be_applied:{_projects_applied}\nmissing: {_missing}" + ) + raise ScenarioCorequisiteError( + f"Missing {len(_missing)} corequisites: {_missing}" + ) def _check_projects_conflicts(self, project_names: str) -> None: - """Checks that a list of projects' conflicts have not been or will be applied to scenario.""" + """Checks that list of projects' conflicts have not been or will be applied to scenario.""" + # WranglerLogger.debug("Checking Conflicts...") projects_to_check = project_names + self.applied_projects - if set(projects_to_check).isdisjoint(set(self.conflicts)): + # WranglerLogger.debug(f"\nprojects_to_check:{projects_to_check}\nprojects_with_conflicts:{set(self.conflicts.keys())}") + if set(projects_to_check).isdisjoint(set(self.conflicts.keys())): + # WranglerLogger.debug("Projects have no conflicts to check") return - _conflicts = list( - set([self.conflicts[p] for p in projects_to_check if p in self.conflicts]) - ) + _conflicts = [] + for p in project_names: + _conflicts += self.conflicts.get(p, []) _conflict_problems = [p for p in _conflicts if p in projects_to_check] if _conflict_problems: WranglerLogger.warning(f"Conflict Problems: \n{_conflict_problems}") _conf_dict = { k: v for k, v in self.conflicts.items() - if k in projects_to_check and not set(v).isdisjoint(set(_conflict_problems)) + if k in projects_to_check + and not set(v).isdisjoint(set(_conflict_problems)) } WranglerLogger.debug(f"Problematic Conflicts:\n{_conf_dict}") - raise ValueError(f"Found {len(_conflicts)} conflicts: {_conflict_problems}") + raise ScenarioConflictError( + f"Found {len(_conflicts)} conflicts: {_conflict_problems}" + ) def order_projects(self, project_list: Collection[str]) -> deque: """ @@ -463,7 +505,7 @@ def order_projects(self, project_list: Collection[str]) -> deque: if not set(_ordered_projects) == set(project_list): _missing = list(set(project_list) - set(_ordered_projects)) - raise ValueError(f"Project sort resulted in missing projects:_missing") + raise ValueError(f"Project sort resulted in missing projects:{_missing}") project_deque = deque(_ordered_projects) @@ -511,7 +553,9 @@ def _apply_change(self, change: dict) -> None: change["category"] not in ProjectCard.TRANSIT_CATEGORIES + ProjectCard.ROADWAY_CATEGORIES ): - raise ValueError(f"Don't understand project category: {change['category']}") + raise ProjectCardError( + f"Don't understand project category: {change['category']}" + ) def _apply_project(self, project_name: str) -> None: """Applies project card to scenario. @@ -546,7 +590,8 @@ def apply_projects(self, project_list: Collection[str]): NOTE: does not check co-requisites b/c that isn't possible when applying a sin Args: - project_list: List of projects to be applied. All need to be in the planned project queue. + project_list: List of projects to be applied. All need to be in the planned project + queue. """ project_list = [p.lower() for p in project_list] @@ -707,7 +752,7 @@ def project_card_files_from_directory( project_card_files = [] if not Path(search_dir).exists(): - raise ValueError( + raise FileNotFoundError( "Cannot find specified directory to find project cards: {search_dir}" ) diff --git a/notebook/Scenario Building Example.ipynb b/notebook/Scenario Building Example.ipynb index 320268d3..b0837298 100644 --- a/notebook/Scenario Building Example.ipynb +++ b/notebook/Scenario Building Example.ipynb @@ -335,7 +335,7 @@ " \"4_simple_managed_lane.yml\",\n", " ]\n", "\n", - "project_cards_list = [\n", + "project_card_list = [\n", " ProjectCard.read(os.path.join(STPAUL_DIR, \"project_cards\", filename), validate=False)\n", " for filename in BUILD_CARD_FILENAMES\n", "]" @@ -375,7 +375,7 @@ "source": [ "my_scenario_build_alt1 = Scenario.create_scenario(\n", " base_scenario=my_scenario_nobuild.__dict__, \n", - " project_card_list=project_cards_list\n", + " project_card_list=project_card_list\n", ")\n", "\n", "my_scenario_build_alt1.applied_projects" diff --git a/notebook/Visual Checks.ipynb b/notebook/Visual Checks.ipynb index 2ffcc180..b724eb1c 100644 --- a/notebook/Visual Checks.ipynb +++ b/notebook/Visual Checks.ipynb @@ -435,7 +435,7 @@ " '4_simple_managed_lane.yml',\n", "]\n", "\n", - "project_cards_list = [\n", + "project_card_list = [\n", " wr.ProjectCard.read(os.path.join(STPAUL_DIR, \"project_cards\", filename), validate=False)\n", " for filename in BUILD_CARD_FILENAMES\n", "]" @@ -476,7 +476,7 @@ "source": [ "my_scenario = wr.Scenario.create_scenario(\n", " base_scenario=base_scenario, \n", - " project_cards_list=project_cards_list\n", + " project_card_list=project_card_list\n", ")\n", "my_scenario.apply_all_projects()" ] @@ -604,7 +604,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "wrangler", "language": "python", "name": "python3" }, @@ -618,7 +618,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.12 | packaged by conda-forge | (default, Oct 26 2021, 05:59:23) \n[Clang 11.1.0 ]" + }, + "vscode": { + "interpreter": { + "hash": "5cfb67e0b2744a84e81e5a9906808c277839f4126dccc23f819e7f035f52be10" + } } }, "nbformat": 4, diff --git a/notebook/change-functionality-bug.ipynb b/notebook/change-functionality-bug.ipynb index 7ed86f53..1036b2d7 100644 --- a/notebook/change-functionality-bug.ipynb +++ b/notebook/change-functionality-bug.ipynb @@ -125,7 +125,7 @@ "source": [ "build_scenario = Scenario.create_scenario(\n", " base_scenario=base_scenario,\n", - " project_cards_list=card_list,\n", + " project_card_list=card_list,\n", " validate_project_cards=False)" ] }, @@ -215,7 +215,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "wrangler", "language": "python", "name": "python3" }, @@ -229,7 +229,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.7.12 | packaged by conda-forge | (default, Oct 26 2021, 05:59:23) \n[Clang 11.1.0 ]" + }, + "vscode": { + "interpreter": { + "hash": "5cfb67e0b2744a84e81e5a9906808c277839f4126dccc23f819e7f035f52be10" + } } }, "nbformat": 4, diff --git a/scripts/build_scenario.py b/scripts/build_scenario.py index db96406e..c5c88f9d 100644 --- a/scripts/build_scenario.py +++ b/scripts/build_scenario.py @@ -58,17 +58,19 @@ ) # Create Scenaro Network - project_cards_list = [ + project_card_list = [ ProjectCard.read(filename, validate=False) for filename in project_cards_filenames ] + my_scenario = Scenario.create_scenario( base_scenario=base_scenario, - card_directory=card_directory, - tags=project_tags, - project_cards_list=project_cards_list, + card_search_directory=card_directory, + filter_tags=project_tags, + project_card_list=project_card_list, glob_search=glob_search, + validate = False, ) print("Applying these projects to the base scenario ...") diff --git a/tests/conftest.py b/tests/conftest.py index cb025895..d37077f2 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -8,33 +8,53 @@ pd.set_option("display.max_columns", 500) pd.set_option("display.width", 50000) -@pytest.fixture(scope="session",autouse=True) + +@pytest.fixture(scope="session", autouse=True) def test_logging(test_out_dir): from network_wrangler import setup_logging + setup_logging( - info_log_filename=os.path.join(test_out_dir,"tests.info.log"), - debug_log_filename=os.path.join(test_out_dir,"tests.debug.log"), + info_log_filename=os.path.join(test_out_dir, "tests.info.log"), + debug_log_filename=os.path.join(test_out_dir, "tests.debug.log"), ) + @pytest.fixture(scope="session") def base_dir(): return os.path.dirname(os.path.dirname(os.path.realpath(__file__))) + @pytest.fixture(scope="session") def example_dir(base_dir): return os.path.join(base_dir, "examples") + @pytest.fixture(scope="session") def test_dir(): return os.path.dirname(os.path.realpath(__file__)) + @pytest.fixture(scope="session") def test_out_dir(test_dir): - _test_out_dir = os.path.join(test_dir,"out") - if not os.path.exists(_test_out_dir): + _test_out_dir = os.path.join(test_dir, "out") + if not os.path.exists(_test_out_dir): os.mkdir(_test_out_dir) return _test_out_dir + +@pytest.fixture +def stpaul_base_scenario(stpaul_ex_dir, stpaul_net, stpaul_transit_net): + base_scenario = { + "road_net": copy.deepcopy(stpaul_net), + "transit_net": copy.deepcopy(stpaul_transit_net), + } + return base_scenario + +@pytest.fixture(scope="session") +def stpaul_card_dir(stpaul_ex_dir): + return os.path.join(stpaul_ex_dir, "project_cards") + + @pytest.fixture(scope="session") def stpaul_ex_dir(example_dir): return os.path.join(example_dir, "stpaul") @@ -65,6 +85,10 @@ def stpaul_net(stpaul_ex_dir): ) return net +@pytest.fixture(scope="module") +def stpaul_transit_net(stpaul_ex_dir): + from network_wrangler import TransitNetwork + return TransitNetwork.read(stpaul_ex_dir) @pytest.fixture(scope="module") def small_net(small_ex_dir): diff --git a/tests/test_roadway/test_changes/test_managed_lanes.py b/tests/test_roadway/test_changes/test_managed_lanes.py index 4671453f..76ad2e64 100644 --- a/tests/test_roadway/test_changes/test_managed_lanes.py +++ b/tests/test_roadway/test_changes/test_managed_lanes.py @@ -1,10 +1,6 @@ import copy import os -import pytest - -import pandas as pd - from network_wrangler import ProjectCard from network_wrangler import RoadwayNetwork from network_wrangler import WranglerLogger diff --git a/tests/test_roadway/test_model_roadway.py b/tests/test_roadway/test_model_roadway.py index 5e459f2c..196a1a58 100644 --- a/tests/test_roadway/test_model_roadway.py +++ b/tests/test_roadway/test_model_roadway.py @@ -28,12 +28,12 @@ def test_add_adhoc_managed_lane_field(request, small_net): Makes sure new fields can be added to the network for managed lanes that get moved there. """ WranglerLogger.info(f"--Starting: {request.node.name}") - + AD_HOC_VALUE = 22.5 SELECTED_LINK_INDEX = 1 - + net = copy.deepcopy(small_net) - + net.links_df["ML_my_ad_hoc_field"] = 0 net.links_df["ML_my_ad_hoc_field"].iloc[SELECTED_LINK_INDEX] = AD_HOC_VALUE net.links_df["ML_lanes"] = 0 diff --git a/tests/test_roadway/test_selections.py b/tests/test_roadway/test_selections.py index b78d9eb6..25f879d6 100644 --- a/tests/test_roadway/test_selections.py +++ b/tests/test_roadway/test_selections.py @@ -99,7 +99,6 @@ def test_select_roadway_features_from_projectcard(request, stpaul_net, stpaul_ex ] -@pytest.mark.menow @pytest.mark.parametrize("variable_query", variable_queries) def test_query_roadway_property_by_time_group( request, variable_query, stpaul_net, stpaul_ex_dir @@ -211,3 +210,105 @@ def test_find_segment(request, stpaul_net): WranglerLogger.debug(f"seg_df:\n{seg_df}") WranglerLogger.info(f"--Finished: {request.node.name}") + +# selection, answer +query_tests = [ + # TEST 1 + ( + # SELECTION 1 + { + "selection": { + "links": [{"name": ["6th", "Sixth", "sixth"]}], + "A": {"osm_node_id": "187899923"}, # start searching for segments at A + "B": {"osm_node_id": "187865924"}, # end at B + }, + "ignore": [], + }, + # ANSWER 1 + '((name.str.contains("6th") or ' + + 'name.str.contains("Sixth") or ' + + 'name.str.contains("sixth")) and ' + + "(drive_access==1))", + ), + # TEST 2 + ( + # SELECTION 2 + { + "selection": { + "links": [{"name": ["6th", "Sixth", "sixth"]}], + "A": {"osm_node_id": "187899923"}, # start searching for segments at A + "B": {"osm_node_id": "187865924"}, # end at B + }, + "ignore": ["name"], + }, + # ANSWER 1 + "((drive_access==1))", + ), + # TEST 3 + ( + # SELECTION 3 + { + "selection": { + "links": [ + { + "name": ["6th", "Sixth", "sixth"] + }, # find streets that have one of the various forms of 6th + {"lanes": [1, 2]}, # only select links that are either 1 or 2 lanes + { + "bike_access": [1] + }, # only select links that are marked for biking + ], + "A": {"osm_node_id": "187899923"}, # start searching for segments at A + "B": {"osm_node_id": "187865924"}, # end at B + }, + "ignore": [], + }, + # ANSWER 3 + '((name.str.contains("6th") or ' + + 'name.str.contains("Sixth") or ' + + 'name.str.contains("sixth")) and ' + + "(lanes==1 or lanes==2) and " + + "(bike_access==1) and (drive_access==1))", + ), + # TEST 4 + ( + # SELECTION 4 + { + "selection": { + "links": [ + { + "name": ["6th", "Sixth", "sixth"] + }, # find streets that have one of the various forms of 6th + {"model_link_id": [134574]}, + {"lanes": [1, 2]}, # only select links that are either 1 or 2 lanes + { + "bike_access": [1] + }, # only select links that are marked for biking + ], + "A": {"osm_node_id": "187899923"}, # start searching for segments at A + "B": {"osm_node_id": "187865924"}, # end at B + }, + "ignore": [], + }, + # ANSWER 4 + "((model_link_id==134574))", + ), +] + + +@pytest.mark.parametrize("test_spec", query_tests) +def test_query_builder(request, test_spec): + WranglerLogger.info(f"--Starting: {request.node.name}") + selection, answer = test_spec + + sel_query = ProjectCard.build_selection_query( + selection=selection["selection"], + unique_ids=RoadwayNetwork.UNIQUE_MODEL_LINK_IDENTIFIERS, + ignore=selection["ignore"], + ) + + print("\nsel_query:\n", sel_query) + print("\nanswer:\n", answer) + assert sel_query == answer + + WranglerLogger.info(f"--Finished: {request.node.name}") \ No newline at end of file diff --git a/tests/test_scenario.py b/tests/test_scenario.py index 18c8ff46..a4db8824 100644 --- a/tests/test_scenario.py +++ b/tests/test_scenario.py @@ -1,11 +1,18 @@ import os import sys import subprocess + import pytest + from network_wrangler import ProjectCard from network_wrangler import RoadwayNetwork from network_wrangler import TransitNetwork from network_wrangler import Scenario +from network_wrangler.scenario import ( + ScenarioConflictError, + ScenarioCorequisiteError, + ScenarioPrerequisiteError, +) from network_wrangler.logger import WranglerLogger """ @@ -13,303 +20,189 @@ To run with print statments, use `pytest -s tests/test_scenario.py` """ -STPAUL_DIR = os.path.join( - os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "examples", "stpaul" -) -SCRATCH_DIR = os.path.join(os.getcwd(), "scratch") - -STPAUL_SHAPE_FILE = os.path.join(STPAUL_DIR, "shape.geojson") -STPAUL_LINK_FILE = os.path.join(STPAUL_DIR, "link.json") -STPAUL_NODE_FILE = os.path.join(STPAUL_DIR, "node.geojson") +def test_project_card_read(request, stpaul_card_dir): + WranglerLogger.info(f"--Starting: {request.node.name}") -def test_project_card_read(request): - print("\n--Starting:", request.node.name) - in_dir = os.path.join( - os.path.dirname(os.path.dirname(os.path.realpath(__file__))), - "examples", - "stpaul", - "project_cards", - ) - in_file = os.path.join(in_dir, "1_simple_roadway_attribute_change.yml") + in_file = os.path.join(stpaul_card_dir, "1_simple_roadway_attribute_change.yml") project_card = ProjectCard.read(in_file) - WranglerLogger.info(project_card) - print(str(project_card)) + WranglerLogger.debug(project_card) assert project_card.category == "Roadway Property Change" print("--Finished:", request.node.name) -def test_project_card_write(request): - print("\n--Starting:", request.node.name) - in_dir = os.path.join(STPAUL_DIR, "project_cards") - in_file = os.path.join(in_dir, "1_simple_roadway_attribute_change.yml") - outfile = os.path.join(SCRATCH_DIR, "t_simple_roadway_attribute_change.yml") +def test_project_card_write(request, stpaul_card_dir, scratch_dir): + WranglerLogger.info(f"--Starting: {request.node.name}") + + in_file = os.path.join(stpaul_card_dir, "1_simple_roadway_attribute_change.yml") + outfile = os.path.join(scratch_dir, "t_simple_roadway_attribute_change.yml") project_card = ProjectCard.read(in_file) project_card.write(outfile) test_card = ProjectCard.read(in_file) for k, v in project_card.__dict__.items(): assert v == test_card.__dict__[k] + WranglerLogger.info(f"--Finished: {request.node.name}") -def test_scenario_conflicts(request): - project_cards_list = [] - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "a_test_project_card.yml") - ) - ) - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "b_test_project_card.yml") - ) + +def test_scenario_conflicts(request, stpaul_card_dir): + WranglerLogger.info(f"--Starting: {request.node.name}") + + project_a = ProjectCard( + {"project": "project a", "dependencies": {"conflicts": ["project b"]}} ) - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "c_test_project_card.yml") - ) + project_b = ProjectCard( + { + "project": "project b", + } ) + project_card_list = [project_a, project_b] scen = Scenario.create_scenario( - base_scenario={}, project_cards_list=project_cards_list + base_scenario={}, project_card_list=project_card_list, validate=False ) - print(str(scen), "\n") + # should raise an error whenever calling queued projects or when applying them. + with pytest.raises(ScenarioConflictError) as e_info: + WranglerLogger.info(scen.queued_projects) - scen.check_scenario_conflicts() - if scen.has_conflict_error: - print("Conflicting project found for scenario!") + with pytest.raises(ScenarioConflictError) as e_info: + scen.apply_all_projects() - print("Conflict checks done:", scen.conflicts_checked) - print("--Finished:", request.node.name) + WranglerLogger.info(f"--Finished: {request.node.name}") -def test_scenario_requisites(request): - print("\n--Starting:", request.node.name) - base_scenario = {} +def test_scenario_corequisites(request): + WranglerLogger.info(f"--Starting: {request.node.name}") - project_cards_list = [] - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "a_test_project_card.yml") - ) - ) - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "b_test_project_card.yml") - ) + project_a = ProjectCard( + { + "project": "project a", + "dependencies": {"corequisites": ["project b", "project c"]}, + } ) - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "c_test_project_card.yml") - ) + project_b = ProjectCard( + { + "project": "project b", + } ) + project_card_list = [project_a, project_b] scen = Scenario.create_scenario( - base_scenario=base_scenario, project_cards_list=project_cards_list + base_scenario={}, project_card_list=project_card_list, validate=False ) - print(str(scen), "\n") + # should raise an error whenever calling queued projects or when applying them. + with pytest.raises(ScenarioCorequisiteError) as e_info: + WranglerLogger.info(scen.queued_projects) - scen.check_scenario_requisites() - if scen.has_requisite_error: - print("Missing pre- or co-requisite projects found for scenario!") + with pytest.raises(ScenarioCorequisiteError) as e_info: + scen.apply_all_projects() + WranglerLogger.info(f"--Finished: {request.node.name}") - print("Requisite checks done:", scen.requisites_checked) - print("--Finished:", request.node.name) +@pytest.mark.menow +def test_scenario_prerequisites(request): + """Shouldn't be able to apply projects if they don't have their pre-requisites applied first.""" + WranglerLogger.info(f"--Starting: {request.node.name}") -def test_project_sort(request): - print("\n--Starting:", request.node.name) - base_scenario = {} - - project_cards_list = [] - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "a_test_project_card.yml") - ) + project_a = ProjectCard( + {"project": "project a", "dependencies": {"prerequisites": ["project b"]}} ) - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "b_test_project_card.yml") - ) + + project_b = ProjectCard( + {"project": "project b", "dependencies": {"prerequisites": ["project c"]}} ) - project_cards_list.append( - ProjectCard.read( - os.path.join(STPAUL_DIR, "project_cards", "c_test_project_card.yml") - ) + + project_c = ProjectCard({"project": "project c"}) + + project_d = ProjectCard( + {"project": "project d", "dependencies": {"prerequisites": ["project b"]}} ) + expected_project_queue = ["project c", "project b", "project a", "project d"] scen = Scenario.create_scenario( - base_scenario=base_scenario, project_cards_list=project_cards_list + base_scenario={}, project_card_list=[project_a], validate=False ) - print("\n> Prerequisites:") - import pprint - pprint.pprint(scen.prerequisites) - print("\nUnordered Projects:", scen.get_project_names()) - scen.check_scenario_conflicts() - scen.check_scenario_requisites() + # should raise an error whenever calling queued projects or when applying them. + with pytest.raises(ScenarioPrerequisiteError) as e_info: + WranglerLogger.info(scen.queued_projects) - scen.order_project_cards() - print("Ordered Projects:", scen.get_project_names()) - print("--Finished:", request.node.name) + with pytest.raises(ScenarioPrerequisiteError) as e_info: + scen.apply_all_projects() + + # add other projects... + scen.add_project_cards([project_b, project_c, project_d], validate=False) + # if apply a project singuarly, it should also fail if it doesn't have prereqs + with pytest.raises(ScenarioPrerequisiteError) as e_info: + scen.apply_projects(["project b"]) -def test_managed_lane_project_card(request): - print("\n--Starting:", request.node.name) + WranglerLogger.info(f"--Finished: {request.node.name}") - print("Reading project card ...") - project_card_name = "5_managed_lane.yml" - project_card_path = os.path.join( - os.getcwd(), "examples", "stpaul", "project_cards", project_card_name + +@pytest.mark.failing +def test_project_sort(request): + """Make sure projects sort correctly before being applied.""" + WranglerLogger.info(f"--Starting: {request.node.name}") + project_a = ProjectCard( + {"project": "project a", "dependencies": {"prerequisites": ["project b"]}} ) - project_card = ProjectCard.read(project_card_path) - print(project_card) - print("--Finished:", request.node.name) + project_b = ProjectCard( + {"project": "project b", "dependencies": {"prerequisites": ["project c"]}} + ) + project_c = ProjectCard({"project": "project c"}) -# selection, answer -query_tests = [ - # TEST 1 - ( - # SELECTION 1 - { - "selection": { - "links": [{"name": ["6th", "Sixth", "sixth"]}], - "A": {"osm_node_id": "187899923"}, # start searching for segments at A - "B": {"osm_node_id": "187865924"}, # end at B - }, - "ignore": [], - }, - # ANSWER 1 - '((name.str.contains("6th") or ' - + 'name.str.contains("Sixth") or ' - + 'name.str.contains("sixth")) and ' - + "(drive_access==1))", - ), - # TEST 2 - ( - # SELECTION 2 - { - "selection": { - "links": [{"name": ["6th", "Sixth", "sixth"]}], - "A": {"osm_node_id": "187899923"}, # start searching for segments at A - "B": {"osm_node_id": "187865924"}, # end at B - }, - "ignore": ["name"], - }, - # ANSWER 1 - "((drive_access==1))", - ), - # TEST 3 - ( - # SELECTION 3 - { - "selection": { - "links": [ - { - "name": ["6th", "Sixth", "sixth"] - }, # find streets that have one of the various forms of 6th - {"lanes": [1, 2]}, # only select links that are either 1 or 2 lanes - { - "bike_access": [1] - }, # only select links that are marked for biking - ], - "A": {"osm_node_id": "187899923"}, # start searching for segments at A - "B": {"osm_node_id": "187865924"}, # end at B - }, - "ignore": [], - }, - # ANSWER 3 - '((name.str.contains("6th") or ' - + 'name.str.contains("Sixth") or ' - + 'name.str.contains("sixth")) and ' - + "(lanes==1 or lanes==2) and " - + "(bike_access==1) and (drive_access==1))", - ), - # TEST 4 - ( - # SELECTION 4 - { - "selection": { - "links": [ - { - "name": ["6th", "Sixth", "sixth"] - }, # find streets that have one of the various forms of 6th - {"model_link_id": [134574]}, - {"lanes": [1, 2]}, # only select links that are either 1 or 2 lanes - { - "bike_access": [1] - }, # only select links that are marked for biking - ], - "A": {"osm_node_id": "187899923"}, # start searching for segments at A - "B": {"osm_node_id": "187865924"}, # end at B - }, - "ignore": [], - }, - # ANSWER 4 - "((model_link_id==134574))", - ), -] - - -@pytest.mark.parametrize("test_spec", query_tests) -def test_query_builder(request, test_spec): - selection, answer = test_spec - - sel_query = ProjectCard.build_selection_query( - selection=selection["selection"], - unique_ids=RoadwayNetwork.UNIQUE_MODEL_LINK_IDENTIFIERS, - ignore=selection["ignore"], + project_d = ProjectCard( + {"project": "project d", "dependencies": {"prerequisites": ["project b"]}} ) - print("\nsel_query:\n", sel_query) - print("\nanswer:\n", answer) - assert sel_query == answer + expected_project_queue = ["project c", "project b", "project a", "project d"] - print("--Finished:", request.node.name) + scen = Scenario.create_scenario( + base_scenario={}, + project_card_list=[project_a, project_b, project_c, project_d], + validate=False, + ) + WranglerLogger.debug(f"scen.queued_projects:{scen.queued_projects}") + assert list(scen.queued_projects) == expected_project_queue -def test_apply_summary_wrappers(request): - print("\n--Starting:", request.node.name) + WranglerLogger.info(f"--Finished: {request.node.name}") - card_filenames = [ +@pytest.mark.menow +def test_apply_summary_wrappers(request, stpaul_card_dir,stpaul_base_scenario): + WranglerLogger.info(f"--Starting: {request.node.name}") + + card_files = [ "3_multiple_roadway_attribute_change.yml", "multiple_changes.yml", "4_simple_managed_lane.yml", ] - project_card_directory = os.path.join(STPAUL_DIR, "project_cards") - - project_cards_list = [ - ProjectCard.read(os.path.join(project_card_directory, filename), validate=False) - for filename in card_filenames + project_card_path_list = [ + os.path.join(stpaul_card_dir, filename) + for filename in card_files ] - base_scenario = { - "road_net": RoadwayNetwork.read( - link_file=STPAUL_LINK_FILE, - node_file=STPAUL_NODE_FILE, - shape_file=STPAUL_SHAPE_FILE, - fast=True, - ), - "transit_net": TransitNetwork.read(STPAUL_DIR), - } + my_scenario = Scenario.create_scenario( - base_scenario=base_scenario, project_cards_list=project_cards_list + base_scenario=stpaul_base_scenario, project_card_file_list=project_card_path_list ) my_scenario.apply_all_projects() my_scenario.scenario_summary() - print("--Finished:", request.node.name) + WranglerLogger.info(f"--Finished: {request.node.name}") def test_scenario_building_from_script(request): - print("\n--Starting:", request.node.name) + WranglerLogger.info(f"--Starting: {request.node.name}") config_file = os.path.join(os.getcwd(), "examples", "config_1.yml") # config_file = os.path.join(os.getcwd(),"example","config_2.yml") @@ -325,4 +218,4 @@ def test_scenario_building_from_script(request): p = subprocess.Popen([sys.executable, script_to_run, config_file]) p.communicate() # wait for the subprocess call to finish - print("--Finished:", request.node.name) + WranglerLogger.info(f"--Finished: {request.node.name}") From f4d9b3ad4c3f31e92652d8bfdcaddc984234a414 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Thu, 23 Mar 2023 13:38:22 -0700 Subject: [PATCH 12/15] import copy --- tests/conftest.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/conftest.py b/tests/conftest.py index d37077f2..a8ee0871 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,3 +1,4 @@ +import copy import os import pandas as pd From b6f074797b68c7efc02f11ffed0fbcdd4b9ad6d0 Mon Sep 17 00:00:00 2001 From: Elizabeth Sall Date: Thu, 23 Mar 2023 13:40:54 -0700 Subject: [PATCH 13/15] fix import --- scripts/build_scenario.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/scripts/build_scenario.py b/scripts/build_scenario.py index c5c88f9d..5110caad 100644 --- a/scripts/build_scenario.py +++ b/scripts/build_scenario.py @@ -5,6 +5,7 @@ from network_wrangler import ProjectCard from network_wrangler import Scenario +from network_wrangler.scenario import create_base_scenario warnings.filterwarnings("ignore") @@ -48,7 +49,7 @@ project_cards_filenames = [] # Create Base Network - base_scenario = Scenario.create_base_scenario( + base_scenario = create_base_scenario( highway_dir=base_network_dir, base_shape_name=base_shape_name, base_link_name=base_link_name, From 086d30a597e9a332192b35a47f0cd5abe6b13d48 Mon Sep 17 00:00:00 2001 From: Lisa Zorn Date: Thu, 30 Mar 2023 13:33:48 -0700 Subject: [PATCH 14/15] Add project card path to the debug statement --- network_wrangler/projectcard.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/network_wrangler/projectcard.py b/network_wrangler/projectcard.py index a0b08d6f..1281e3dd 100644 --- a/network_wrangler/projectcard.py +++ b/network_wrangler/projectcard.py @@ -104,7 +104,7 @@ def read_wrangler_card(path_to_card: str) -> dict: Returns: Attribute Dictionary for Project Card """ - WranglerLogger.debug("Reading Wrangler-Style Project Card") + WranglerLogger.debug(f"Reading Wrangler-Style Project Card {path_to_card}") with open(path_to_card, "r") as cardfile: delim = cardfile.readline() @@ -128,7 +128,7 @@ def read_yml(path_to_card: str) -> dict: Returns: Attribute Dictionary for Project Card """ - WranglerLogger.debug("Reading YAML-Style Project Card") + WranglerLogger.debug(f"Reading YAML-Style Project Card {path_to_card}") with open(path_to_card, "r") as cardfile: attribute_dictionary = yaml.safe_load(cardfile.read()) From 912a25495f021999381d05c5409b6a3a7bd6bd0f Mon Sep 17 00:00:00 2001 From: Lisa Zorn Date: Thu, 30 Mar 2023 13:35:08 -0700 Subject: [PATCH 15/15] The suffix includes the period; drop the period for this check --- network_wrangler/scenario.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/network_wrangler/scenario.py b/network_wrangler/scenario.py index 4a0fa749..ce330ea8 100644 --- a/network_wrangler/scenario.py +++ b/network_wrangler/scenario.py @@ -757,9 +757,10 @@ def project_card_files_from_directory( ) if glob_search: - WranglerLogger.debug(f"Finding project cards using glob search: {glob_search}") + WranglerLogger.debug(f"Finding project cards using glob search: {glob_search} in {search_dir}") for f in glob.iglob(os.path.join(search_dir, glob_search)): - if not Path(f).suffix in ProjectCard.FILE_TYPES: + # Path.suffix returns string starting with . + if not Path(f).suffix[1:] in ProjectCard.FILE_TYPES: continue else: project_card_files.append(f)