def query_removed_dams(request: Request, ):
"""Return dams that were removed for conservation"""
log_request(request)
df = unpack_domains(get_removed_dams())
return csv_response(df)
def query_barriers(request: Request,
extractor: StateRecordExtractor = Depends()):
"""Return subset of barriers based on state abbreviations.
Query parameters:
id: list of state abbreviations
"""
log_request(request)
df = extractor.extract(barriers)[SB_PUBLIC_EXPORT_FIELDS].copy()
df = df.sort_values(by="HasNetwork", ascending=False)
df = unpack_domains(df)
log.info(f"public query selected {len(df.index)} barriers")
return csv_response(df)
"is_manualreviewed_error",
"is_reconned",
"is_error",
"invasive",
"is_estimated",
"is_estimated_manualreviewed",
"is_estimated_reconned",
"is_estimated_reconned_or_manualreviewed",
"is_estimated_error",
"on_protectedland",
"on_loop",
]
].reset_index()
)
# archive["ProtectedLand"] = archive.ProtectedLand.astype("bool")
archive = unpack_domains(archive)
archive.to_csv(out_dir / f"{barrier_type}_{version}_frontiers_archive.csv", index=False)
# status_fields += ["ProtectedLand"]
summary_fields += ["OwnerType"]
states = sorted(x for x in df.State.unique() if x)
huc2 = sorted(x for x in df.HUC2.unique() if x)
df = df.reset_index()
with pd.ExcelWriter(
out_dir / f"{barrier_type}_{version}_summary_for_frontiers_manuscript.xlsx"
) as xlsx:
def download_dams(
request: Request,
id: str,
layer: Layers = "State",
extractor: DamsRecordExtractor = Depends(),
custom: bool = False,
unranked=False,
sort: Scenarios = "NCWC",
format: Formats = "csv",
):
"""Download subset of dams or small barriers data.
If `unranked` is `True`, all barriers in the summary units are downloaded.
Path parameters:
<layer> : one of LAYERS
<format> : "csv"
Query parameters:
* id: list of ids
* custom: bool (default: False); set to true to perform custom ranking of subset defined here
* unranked: bool (default: False); set to true to include unranked barriers in output
* sort: str, one of 'NC', 'WC', 'NCWC'
* filters are defined using a lowercased version of column name and a comma-delimited list of values
"""
log_request(request)
filename = f"aquatic_barrier_ranks_{date.today().isoformat()}.{format}"
# See if we already already cached the response;
# we only do this for unfiltered states and the entire region (ranked or unranked)
cache_filename = None
has_filters = any(q for q in request.query_params
if q in DAM_FILTER_FIELD_MAP)
if layer == "State" and format == "csv" and id and not (has_filters
or custom):
state_hash = sha1(id.encode("UTF8")).hexdigest()
suffix = "_ranked" if not unranked else ""
cache_filename = CACHE_DIRECTORY / f"{state_hash}{suffix}_dams.zip"
if cache_filename and cache_filename.exists():
return zip_file_response(cache_filename,
filename.replace(".csv", ".zip"))
df = extractor.extract(dams).copy()
# include unranked dams - these are joined back later
if unranked:
full_df = df.copy()
# can only calculate ranks for those that have networks and are not excluded from ranking
df = df.loc[df.Ranked]
# calculate custom ranks
if custom:
df = df.join(calculate_tiers(df))
if unranked:
# join back to full dataset
tier_cols = df.columns.difference(full_df.columns)
df = full_df.join(df[tier_cols], how="left")
df[tier_cols] = df[tier_cols].fillna(-1).astype("int8")
log.info(f"selected {len(df):,} dams for download")
cols = [c for c in DAM_EXPORT_FIELDS if c in set(df.columns)]
df = df[cols]
# Sort by tier
if f"{sort}_tier" in df.columns:
sort_field = f"{sort}_tier"
else:
sort_field = f"SE_{sort}_tier"
df = df.sort_values(by=["HasNetwork", sort_field], ascending=[False, True])
df = unpack_domains(df)
### Get metadata
readme = get_readme(
filename=filename,
barrier_type="dams",
fields=df.columns,
url=request.base_url,
layer=extractor.layer,
ids=extractor.ids,
)
terms = get_terms(url=request.base_url)
if format == "csv":
return zip_csv_response(
df,
filename=filename,
extra_str={
"README.txt": readme,
"TERMS_OF_USE.txt": terms
},
extra_path={"SARP_logo.png": LOGO_PATH},
cache_filename=cache_filename,
)
raise NotImplementedError("Other formats not yet supported")