From 730410c5e1bc2a2a412269f182fd635c4245a651 Mon Sep 17 00:00:00 2001 From: Matt Weiden <538456+mweiden@users.noreply.github.com> Date: Tue, 12 May 2020 13:19:38 -0700 Subject: [PATCH] Autoformat python to fix lint errors (#1470) * Autoformat python to fix lint errors * Fix lint errors not caught by black --- server/app/app.py | 2 +- server/common/app_config.py | 10 ++++----- server/data_anndata/anndata_adaptor.py | 10 ++++----- server/data_common/data_adaptor.py | 11 ++++----- server/data_common/matrix_loader.py | 4 ++-- server/data_cxg/cxg_adaptor.py | 4 ++-- server/eb/app.py | 6 ++--- server/eb/check_requirements.py | 12 +++------- server/test/test_api.py | 16 ++++++------- server/test/test_writable_annotation.py | 30 ++++++++++++------------- 10 files changed, 50 insertions(+), 55 deletions(-) diff --git a/server/app/app.py b/server/app/app.py index d22a6731..80aefc7f 100644 --- a/server/app/app.py +++ b/server/app/app.py @@ -105,7 +105,7 @@ def get_data_adaptor(dataset=None): raise DatasetAccessError("Invalid dataset {dataset}") if datapath is None: - return common_rest.abort_and_log(HTTPStatus.BAD_REQUEST, f"Invalid dataset NONE", loglevel=logging.INFO) + return common_rest.abort_and_log(HTTPStatus.BAD_REQUEST, "Invalid dataset NONE", loglevel=logging.INFO) cache_manager = current_app.matrix_data_cache_manager return cache_manager.data_adaptor(datapath, config) diff --git a/server/common/app_config.py b/server/common/app_config.py index b228fee2..8e01419d 100644 --- a/server/common/app_config.py +++ b/server/common/app_config.py @@ -279,13 +279,13 @@ class AppConfig(object): if self.server__csp_directives is not None: for k, v in self.server__csp_directives.items(): if not isinstance(k, str): - raise ConfigurationError(f"CSP directive names must be a string.") + raise ConfigurationError("CSP directive names must be a string.") if isinstance(v, list): for policy in v: if not isinstance(policy, str): - raise ConfigurationError(f"CSP directive value must be a string or list of strings.") + raise ConfigurationError("CSP directive value must be a string or list of strings.") elif not isinstance(v, str): - raise ConfigurationError(f"CSP directive value must be a string or list of strings.") + raise ConfigurationError("CSP directive value must be a string or list of strings.") # scripts can be string (filename) or dict (attributes). Convert string to dict. scripts = [] @@ -476,8 +476,8 @@ class AppConfig(object): with self.matrix_data_cache_manager.data_adaptor(self.single_dataset__datapath, self) as data_adaptor: if self.diffexp__enable and data_adaptor.parameters.get("diffexp_may_be_slow", False): context["messagefn"]( - f"CAUTION: due to the size of your dataset, " - f"running differential expression may take longer or fail." + "CAUTION: due to the size of your dataset, " + "running differential expression may take longer or fail." ) max_workers = self.diffexp__alg_cxg__max_workers diff --git a/server/data_anndata/anndata_adaptor.py b/server/data_anndata/anndata_adaptor.py index fe7bda4f..60113b6d 100644 --- a/server/data_anndata/anndata_adaptor.py +++ b/server/data_anndata/anndata_adaptor.py @@ -183,13 +183,13 @@ class AnndataAdaptor(DataAdaptor): def _validate_and_initialize(self): if anndata_version_is_pre_070() and self.config.adaptor__anndata_adaptor__backed: warnings.warn( - f"Use of --backed mode with anndata versions older than 0.7 will have serious " + "Use of --backed mode with anndata versions older than 0.7 will have serious " "performance issues. Please update to at least anndata 0.7 or later." ) # var and obs column names must be unique if not self.data.obs.columns.is_unique or not self.data.var.columns.is_unique: - raise KeyError(f"All annotation column names must be unique.") + raise KeyError("All annotation column names must be unique.") self._alias_annotation_names() self._validate_data_types() @@ -222,8 +222,8 @@ class AnndataAdaptor(DataAdaptor): X0 = self.data.X[0, 0:1] if sparse.isspmatrix(X0) and not sparse.isspmatrix_csc(X0): warnings.warn( - f"Anndata data matrix is sparse, but not a CSC (columnar) matrix. " - f"Performance may be improved by using CSC." + "Anndata data matrix is sparse, but not a CSC (columnar) matrix. " + "Performance may be improved by using CSC." ) if self.data.X.dtype != "float32": warnings.warn( @@ -295,7 +295,7 @@ class AnndataAdaptor(DataAdaptor): valid_layouts.append(layout) if len(valid_layouts) == 0: - raise PrepareError(f"No valid layout data.") + raise PrepareError("No valid layout data.") # cap layouts to MAX_LAYOUTS return layouts[0:MAX_LAYOUTS] diff --git a/server/data_common/data_adaptor.py b/server/data_common/data_adaptor.py index 7aa5d452..cd542cc0 100644 --- a/server/data_common/data_adaptor.py +++ b/server/data_common/data_adaptor.py @@ -230,18 +230,19 @@ class DataAdaptor(metaclass=ABCMeta): # all labels must have a name, which must be unique and not used in obs column names if not labels_df.columns.is_unique: - raise KeyError(f"All column names specified in user annotations must be unique.") + raise KeyError("All column names specified in user annotations must be unique.") # the label index must be unique, and must have same values the anndata obs index if not labels_df.index.is_unique: - raise KeyError(f"All row index values specified in user annotations must be unique.") + raise KeyError("All row index values specified in user annotations must be unique.") obs_columns = self.get_obs_columns() duplicate_columns = list(set(labels_df.columns) & set(obs_columns)) if len(duplicate_columns) > 0: raise KeyError( - f"Labels file may not contain column names which overlap " f"with h5ad obs columns {duplicate_columns}" + "Labels file may not contain column names which overlap " + f"with h5ad obs columns {duplicate_columns}" ) # labels must have same count as obs annotations @@ -351,13 +352,13 @@ class DataAdaptor(metaclass=ABCMeta): """ embeddings = self.get_embedding_names() if fields is None or len(fields) == 0 else fields layout_data = [] - with ServerTiming.time(f"layout.query"): + with ServerTiming.time("layout.query"): for ename in embeddings: embedding = self.get_embedding_array(ename, 2) normalized_layout = DataAdaptor.normalize_embedding(embedding) layout_data.append(pd.DataFrame(normalized_layout, columns=[f"{ename}_0", f"{ename}_1"])) - with ServerTiming.time(f"layout.encode"): + with ServerTiming.time("layout.encode"): if layout_data: df = pd.concat(layout_data, axis=1, copy=False) else: diff --git a/server/data_common/matrix_loader.py b/server/data_common/matrix_loader.py index 7ee0184a..fae95b5a 100644 --- a/server/data_common/matrix_loader.py +++ b/server/data_common/matrix_loader.py @@ -228,7 +228,7 @@ class MatrixDataLoader(object): self.matrix_data_type = self.__matrix_data_type() if not self.__matrix_data_type_allowed(app_config): - raise DatasetAccessError(f"Dataset does not have an allowed type.") + raise DatasetAccessError("Dataset does not have an allowed type.") if self.matrix_data_type == MatrixDataType.H5AD: from server.data_anndata.anndata_adaptor import AnndataAdaptor @@ -272,7 +272,7 @@ class MatrixDataLoader(object): def pre_load_validation(self): if self.matrix_data_type == MatrixDataType.UNKNOWN: - raise DatasetAccessError(f"Dataset does not have a recognized type: .h5ad or .cxg") + raise DatasetAccessError("Dataset does not have a recognized type: .h5ad or .cxg") self.matrix_type.pre_load_validation(self.location) def file_size(self): diff --git a/server/data_cxg/cxg_adaptor.py b/server/data_cxg/cxg_adaptor.py index 3bab6987..accab96a 100644 --- a/server/data_cxg/cxg_adaptor.py +++ b/server/data_cxg/cxg_adaptor.py @@ -264,7 +264,7 @@ class CxgAdaptor(DataAdaptor): # function to get the embedding # this function to iterate through embeddings. def get_embedding_names(self): - with ServerTiming.time(f"layout.lsuri"): + with ServerTiming.time("layout.lsuri"): pemb = self.get_path("emb") embeddings = [os.path.basename(p) for (p, t) in self.lsuri(pemb) if t == "array"] if len(embeddings) == 0: @@ -311,7 +311,7 @@ class CxgAdaptor(DataAdaptor): A = self.open_array(ax) schema_hints = json.loads(A.meta["cxg_schema"]) if "cxg_schema" in A.meta else {} if type(schema_hints) is not dict: - raise TypeError(f"Array schema was malformed.") + raise TypeError("Array schema was malformed.") cols = [] for attr in A.schema: diff --git a/server/eb/app.py b/server/eb/app.py index c493a9b9..2b6f3951 100644 --- a/server/eb/app.py +++ b/server/eb/app.py @@ -156,7 +156,7 @@ try: dataroot = os.getenv("CXG_DATAROOT") if dataroot: - logging.info(f"Configuration from CXG_DATAROOT") + logging.info("Configuration from CXG_DATAROOT") app_config.update(multi_dataset__dataroot=dataroot) secret_name = os.getenv("CXG_AWS_SECRET_NAME") @@ -171,7 +171,7 @@ try: if not secret_region_name: secret_region_name = discover_s3_region_name(config_file) if not secret_region_name: - logging.error(f"Could not determine the AWS Secret Manager region") + logging.error("Could not determine the AWS Secret Manager region") sys.exit(1) flask_secret_key = get_flask_secret_key(secret_region_name, secret_name) @@ -188,7 +188,7 @@ try: if not app_config.server__flask_secret_key: logging.critical( - f"flask_secret_key is not provided. Either set in config file, CXG_SECRET_KEY environment variable, " + "flask_secret_key is not provided. Either set in config file, CXG_SECRET_KEY environment variable, " "or in AWS Secret Manager" ) sys.exit(1) diff --git a/server/eb/check_requirements.py b/server/eb/check_requirements.py index 67d7ab8b..008afede 100644 --- a/server/eb/check_requirements.py +++ b/server/eb/check_requirements.py @@ -29,16 +29,12 @@ def check(expected, custom): # cdict must only have exact requirements (==) for cname, cspecs in cdict.items(): if len(cspecs) != 1 or cspecs[0][0] != "==": - print( - f"Error, spec must be an exact requirement {custom}: {cname} {str(cspecs)}" - ) + print(f"Error, spec must be an exact requirement {custom}: {cname} {str(cspecs)}") okay = False for ename, especs in edict.items(): if ename not in cdict: - print( - f"Error, missing requirement from {custom}: {ename} {str(especs)}" - ) + print(f"Error, missing requirement from {custom}: {ename} {str(especs)}") okay = False continue @@ -46,9 +42,7 @@ def check(expected, custom): for espec in especs: rokay = check_version(cver, espec[0], Version(espec[1])) if not rokay: - print( - f"Error, failed requirement from {custom}: {ename} {espec}, {cver}" - ) + print(f"Error, failed requirement from {custom}: {ename} {espec}, {cver}") okay = False if okay: diff --git a/server/test/test_api.py b/server/test/test_api.py index cd9a4329..319a5847 100644 --- a/server/test/test_api.py +++ b/server/test/test_api.py @@ -185,14 +185,14 @@ class EndPoints(object): self.assertEqual(result.status_code, HTTPStatus.BAD_REQUEST) def test_data_mimetype_error(self): - endpoint = f"data/var" + endpoint = "data/var" header = {"Accept": "xxx"} url = f"{self.URL_BASE}{endpoint}" result = self.session.put(url, headers=header) self.assertEqual(result.status_code, HTTPStatus.NOT_ACCEPTABLE) def test_fbs_default(self): - endpoint = f"data/var" + endpoint = "data/var" url = f"{self.URL_BASE}{endpoint}" result = self.session.put(url) self.assertEqual(result.status_code, HTTPStatus.BAD_REQUEST) @@ -202,21 +202,21 @@ class EndPoints(object): self.assertEqual(result.headers["Content-Type"], "application/octet-stream") def test_data_put_fbs(self): - endpoint = f"data/var" + endpoint = "data/var" url = f"{self.URL_BASE}{endpoint}" header = {"Accept": "application/octet-stream"} result = self.session.put(url, headers=header) self.assertEqual(result.status_code, HTTPStatus.BAD_REQUEST) def test_data_get_fbs(self): - endpoint = f"data/var" + endpoint = "data/var" url = f"{self.URL_BASE}{endpoint}" header = {"Accept": "application/octet-stream"} result = self.session.get(url, headers=header) self.assertEqual(result.status_code, HTTPStatus.BAD_REQUEST) def test_data_put_filter_fbs(self): - endpoint = f"data/var" + endpoint = "data/var" url = f"{self.URL_BASE}{endpoint}" header = {"Accept": "application/octet-stream"} filter = {"filter": {"var": {"index": [0, 1, 4]}}} @@ -233,8 +233,8 @@ class EndPoints(object): def test_data_get_filter_fbs(self): index_col_name = self.schema["schema"]["annotations"]["var"]["index"] + endpoint = "data/var" query = f"var:{index_col_name}=SIK1" - endpoint = f"data/var" url = f"{self.URL_BASE}{endpoint}?{query}" header = {"Accept": "application/octet-stream"} result = self.session.get(url, headers=header) @@ -245,7 +245,7 @@ class EndPoints(object): self.assertEqual(df["n_cols"], 1) def test_data_put_single_var(self): - endpoint = f"data/var" + endpoint = "data/var" url = f"{self.URL_BASE}{endpoint}" header = {"Accept": "application/octet-stream"} index_col_name = self.schema["schema"]["annotations"]["var"]["index"] @@ -306,7 +306,7 @@ class EndPointsAnnotations(EndPoints): query = "annotation-collection-name=test_annotations" url = f"{self.URL_BASE}{endpoint}?{query}" n_rows = self.data.get_shape()[0] - fbs = make_fbs({"cat_A": pd.Series(["label_A" for l in range(0, n_rows)], dtype="category")}) + fbs = make_fbs({"cat_A": pd.Series(["label_A"] * n_rows, dtype="category")}) result = self.session.put(url, data=fbs) self.assertEqual(result.status_code, HTTPStatus.OK) self.assertEqual(result.headers["Content-Type"], "application/json") diff --git a/server/test/test_writable_annotation.py b/server/test/test_writable_annotation.py index 693bc373..d4cf15b4 100644 --- a/server/test/test_writable_annotation.py +++ b/server/test/test_writable_annotation.py @@ -27,7 +27,7 @@ class WritableAnnotationTest(unittest.TestCase): def test_error_checks(self): # verify that the expected errors are generated n_rows = self.data.get_shape()[0] - fbs_bad = make_fbs({"louvain": pd.Series(["undefined" for l in range(0, n_rows)], dtype="category")}) + fbs_bad = make_fbs({"louvain": pd.Series(["undefined"] * n_rows, dtype="category")}) # ensure we catch attempt to overwrite non-writable data with self.assertRaises(KeyError): @@ -38,8 +38,8 @@ class WritableAnnotationTest(unittest.TestCase): n_rows = self.data.get_shape()[0] fbs = make_fbs( { - "cat_A": pd.Series(["label_A" for l in range(0, n_rows)], dtype="category"), - "cat_B": pd.Series(["label_B" for l in range(0, n_rows)], dtype="category"), + "cat_A": pd.Series(["label_A"] * n_rows, dtype="category"), + "cat_B": pd.Series(["label_B"] * n_rows, dtype="category"), } ) res = self.annotation_put_fbs(fbs) @@ -49,14 +49,14 @@ class WritableAnnotationTest(unittest.TestCase): self.assertEqual(df.shape, (n_rows, 2)) self.assertEqual(set(df.columns), {"cat_A", "cat_B"}) self.assertTrue(self.data.original_obs_index.equals(df.index)) - self.assertTrue(np.all(df["cat_A"] == ["label_A" for l in range(0, n_rows)])) - self.assertTrue(np.all(df["cat_B"] == ["label_B" for l in range(0, n_rows)])) + self.assertTrue(np.all(df["cat_A"] == ["label_A"] * n_rows)) + self.assertTrue(np.all(df["cat_B"] == ["label_B"] * n_rows)) # verify complete overwrite on second attempt, AND rotation occurs fbs = make_fbs( { - "cat_A": pd.Series(["label_A1" for l in range(0, n_rows)], dtype="category"), - "cat_C": pd.Series(["label_C" for l in range(0, n_rows)], dtype="category"), + "cat_A": pd.Series(["label_A1"] * n_rows, dtype="category"), + "cat_C": pd.Series(["label_C"] * n_rows, dtype="category"), } ) res = self.annotation_put_fbs(fbs) @@ -64,8 +64,8 @@ class WritableAnnotationTest(unittest.TestCase): self.assertTrue(path.exists(self.annotations.output_file)) df = pd.read_csv(self.annotations.output_file, index_col=0, header=0, comment="#") self.assertEqual(set(df.columns), {"cat_A", "cat_C"}) - self.assertTrue(np.all(df["cat_A"] == ["label_A1" for l in range(0, n_rows)])) - self.assertTrue(np.all(df["cat_C"] == ["label_C" for l in range(0, n_rows)])) + self.assertTrue(np.all(df["cat_A"] == ["label_A1"] * n_rows)) + self.assertTrue(np.all(df["cat_C"] == ["label_C"] * n_rows)) # rotation name, ext = path.splitext(self.annotations.output_file) @@ -79,8 +79,8 @@ class WritableAnnotationTest(unittest.TestCase): n_rows = self.data.get_shape()[0] fbs = make_fbs( { - "cat_A": pd.Series(["label_A" for l in range(0, n_rows)], dtype="category"), - "cat_B": pd.Series(["label_B" for l in range(0, n_rows)], dtype="category"), + "cat_A": pd.Series(["label_A"] * n_rows, dtype="category"), + "cat_B": pd.Series(["label_B"] * n_rows, dtype="category"), } ) for i in range(0, 11): @@ -100,8 +100,8 @@ class WritableAnnotationTest(unittest.TestCase): n_rows = self.data.get_shape()[0] fbs = make_fbs( { - "cat_A": pd.Series(["label_A" for l in range(0, n_rows)], dtype="category"), - "cat_B": pd.Series(["label_B" for l in range(0, n_rows)], dtype="category"), + "cat_A": pd.Series(["label_A"] * n_rows, dtype="category"), + "cat_B": pd.Series(["label_B"] * n_rows, dtype="category"), } ) @@ -123,8 +123,8 @@ class WritableAnnotationTest(unittest.TestCase): [obs_index_col_name, "n_genes", "percent_mito", "n_counts", "louvain", "cat_A", "cat_B"], ) col_idx = annotations["col_idx"] - self.assertEqual(annotations["columns"][col_idx.index("cat_A")], ["label_A" for l in range(0, n_rows)]) - self.assertEqual(annotations["columns"][col_idx.index("cat_B")], ["label_B" for l in range(0, n_rows)]) + self.assertEqual(annotations["columns"][col_idx.index("cat_A")], ["label_A"] * n_rows) + self.assertEqual(annotations["columns"][col_idx.index("cat_B")], ["label_B"] * n_rows) # verify the schema was updated all_col_schema = {c["name"]: c for c in schema["annotations"]["obs"]["columns"]}