def build_coastline(**kwargs): env = Env() kwargs["ti"].xcom_push(key="build_name", value=env.build_name) run_generation( env, ( sd.StageDownloadAndConvertPlanet(), sd.StageCoastline(use_old_if_fail=False), sd.StageCleanup(), ), ) env.finish()
def update_planet(**kwargs): env = Env() kwargs["ti"].xcom_push(key="build_name", value=env.build_name) if settings.DEBUG: env.add_skipped_stage(sd.StageUpdatePlanet) run_generation( env, ( sd.StageDownloadAndConvertPlanet(), sd.StageUpdatePlanet(), sd.StageCleanup(), ), ) env.finish()
def build_epilog(**kwargs): build_name = kwargs["ti"].xcom_pull(key="build_name") params = MapsGenerationDAG.get_params(**kwargs) params.update({"build_name": build_name}) env = Env(**params) run_generation_from_first_stage( env, ( sd.StageCountriesTxt(), sd.StageExternalResources(), sd.StageLocalAds(), sd.StageStatistics(), sd.StageCleanup(), ), ) env.finish()
def main(): root = logging.getLogger() root.addHandler(logging.NullHandler()) options = parse_options() # Processing of 'continue' option. # If 'continue' is set maps generation is continued from the last build # that is found automatically. build_name = None if options["continue"] is None or options["continue"]: d = find_last_build_dir(options["continue"]) if d is None: raise ContinueError( "The build cannot continue: the last build " "directory was not found." ) build_name = d # Processing of 'countries' option. # There is processing 'countries' and 'without_countries' options. # Option 'without_countries' has more priority than 'countries'. # Options 'countries' and 'without_countries' can include '*'. # For example: '--countries="UK*, Japan"*' means # '--countries="UK_England_East Midlands, UK_England_East of England_Essex, ..., # Japan_Chubu Region_Aichi_Nagoya, Japan_Chubu Region_Aichi_Toyohashi, ..."'. countries_line = "" without_countries_line = "" if "COUNTRIES" in os.environ: countries_line = os.environ["COUNTRIES"] if options["countries"]: countries_line = options["countries"] else: countries_line = "*" if options["without_countries"]: without_countries_line = options["without_countries"] all_countries = get_all_countries_list(PathProvider.borders_path()) def end_star_compare(prefix, full): return full.startswith(prefix) def compare(a, b): return a == b def get_countries_set_from_line(line): countries = [] used_countries = set() countries_list = [] if os.path.isfile(line): with open(line) as f: countries_list = [x.strip() for x in f] elif line: countries_list = [x.strip() for x in line.replace(";", ",").split(",")] for country_item in countries_list: cmp = compare _raw_country = country_item[:] if _raw_country and _raw_country[-1] == "*": _raw_country = _raw_country.replace("*", "") cmp = end_star_compare for country in all_countries: if cmp(_raw_country, country): used_countries.add(country_item) countries.append(country) countries = unique(countries) diff = set(countries_list) - used_countries if diff: raise ValidationError(f"Bad input countries {', '.join(diff)}") return set(countries) countries = get_countries_set_from_line(countries_line) without_countries = get_countries_set_from_line(without_countries_line) countries -= without_countries countries = list(countries) if not countries: countries = all_countries # Processing of 'order' option. # It defines an order of countries generation using a file from 'order' path. if options["order"]: ordered_countries = [] countries = set(countries) with open(options["order"]) as file: for c in file: if c.strip().startswith("#"): continue c = c.split("\t")[0].strip() if c in countries: ordered_countries.append(c) countries.remove(c) if countries: raise ValueError( f"{options['order']} does not have an order " f"for {countries}." ) countries = ordered_countries # Processing of 'skip' option. skipped_stages = set() if options["skip"]: for s in options["skip"].replace(";", ",").split(","): stage = s.strip() if not stages.stages.is_valid_stage_name(stage): raise SkipError(f"{stage} not found.") skipped_stages.add(stages.get_stage_type(stage)) if settings.PLANET_URL != settings.DEFAULT_PLANET_URL: skipped_stages.add(sd.StageUpdatePlanet) if sd.StageCoastline in skipped_stages: if any(x in WORLDS_NAMES for x in options["countries"]): raise SkipError( f"You can not skip {stages.get_stage_name(sd.StageCoastline)}" f" if you want to generate {WORLDS_NAMES}." f" You can exclude them with --without_countries option." ) if not settings.NEED_PLANET_UPDATE: skipped_stages.add(sd.StageUpdatePlanet) # Make env and run maps generation. env = Env( countries=countries, production=options["production"], build_name=build_name, skipped_stages=skipped_stages, ) from_stage = None if options["from_stage"]: from_stage = f"{options['from_stage']}" if options["coasts"]: generate_coasts(env, from_stage) else: generate_maps(env, from_stage) env.finish()