Blacking…

Signed-off-by: Cédric Foellmi <cedric@onekiloparsec.dev>

Author: onekiloparsec

arcsecond/api/config.py

@@ -11,10 +11,10 @@
 
 class ArcsecondConfig(object):
     def __init__(self, **kwargs):
-        self.__api_name = kwargs.get('api_name', 'cloud') or 'cloud'
+        self.__api_name = kwargs.get("api_name", "cloud") or "cloud"
         self.__verbose = kwargs.get("verbose", 0) or 0
-        if 'config' in kwargs.keys():
-            self.__config = kwargs.get('config')
+        if "config" in kwargs.keys():
+            self.__config = kwargs.get("config")
         else:
             self.__config = ConfigParser()
             self.__config.read(str(ArcsecondConfig.file_path()))

arcsecond/api/endpoint.py

@@ -28,7 +28,9 @@ def path(self):
 
     def _get_base_url(self):
         if not self.__config.api_server:
-            raise ArcsecondError(f"API server address for name \'{self.__config.api_name}\' is unknown/invalid.")
+            raise ArcsecondError(
+                f"API server address for name '{self.__config.api_name}' is unknown/invalid."
+            )
         url = self.__config.api_server
         if not url.endswith("/"):
             url += "/"
@@ -65,11 +67,7 @@ def read(self, id_name_uuid, headers=None):
 
     def create(self, json=None, files=None, headers=None):
         return self._perform_request(
-            self._list_url(),
-            "post",
-            json=json,
-            files=files,
-            headers=headers
+            self._list_url(), "post", json=json, files=files, headers=headers
         )
 
     def update(self, id_name_uuid, json=None, files=None, headers=None):
@@ -91,14 +89,14 @@ def _perform_request(self, url, method_name, json=None, files=None, headers=None
         headers = self._check_and_set_auth_key(headers or {}, url)
         method = getattr(httpx, method_name.lower())
 
-        kwargs = {'headers': headers, 'timeout': 60}
+        kwargs = {"headers": headers, "timeout": 60}
         if files and json:
             # Do NOT set json=json, keep data=json, to avoid overriding Content-Type with `application/json`.
             kwargs.update(files=files, data=json)
         elif json and not files:
             kwargs.update(json=json)
         elif files and not json:
-            raise ArcsecondError('Files but no json?')
+            raise ArcsecondError("Files but no json?")
 
         try:
             response = method(url, **kwargs)

arcsecond/cli.py

@@ -35,6 +35,7 @@ def main(ctx, version=False, v=False, h=False):
 def version():
     click.echo(__version__.__version__)
 
+
 # Read/set API server to use.
 main.add_command(api)
 

arcsecond/cloud/auth.py

@@ -110,7 +110,9 @@ def me(state):
     if not username:
         msg = f"Invalid/missing username: {username}. Make sure to login first: $ arcsecond login"
         raise ArcsecondError(msg)
-    response, error = ArcsecondAPI(ArcsecondConfig.from_state(state)).profiles.read(username)
+    response, error = ArcsecondAPI(ArcsecondConfig.from_state(state)).profiles.read(
+        username
+    )
     if error:
         click.echo(str(error))
     else:

arcsecond/cloud/uploader/allskycameraimages/context.py

@@ -10,11 +10,11 @@ class AllSkyCameraImageUploadContext(BaseUploadContext):
     """Upload context for all-sky camera image uploads"""
 
     def __init__(
-            self,
-            config,
-            input_camera_uuid,
-            org_subdomain=None,
-            custom_tags=None,
+        self,
+        config,
+        input_camera_uuid,
+        org_subdomain=None,
+        custom_tags=None,
     ):
         super().__init__(config, org_subdomain, custom_tags)
         self._input_camera_uuid = str(input_camera_uuid) if input_camera_uuid else None
@@ -23,7 +23,9 @@ def __init__(
     @property
     def upload_api_endpoint(self):
         return ArcsecondAPIEndpoint(
-            self.config, f"allskycameras/{self._input_camera_uuid}/images", self.subdomain
+            self.config,
+            f"allskycameras/{self._input_camera_uuid}/images",
+            self.subdomain,
         )
 
     def _validate_context_specific(self):

arcsecond/cloud/uploader/allskycameraimages/uploader.py

@@ -13,13 +13,11 @@ def _prepare_upload(self):
         pass
 
     def _get_upload_data(self, **kwargs):
-        fields = {
-            "camera": self._context.camera_uuid
-        }
-        clean_kwargs = {k: kwargs[k] for k in ('timestamp', 'camera') if k in kwargs}
+        fields = {"camera": self._context.camera_uuid}
+        clean_kwargs = {k: kwargs[k] for k in ("timestamp", "camera") if k in kwargs}
         fields.update(**clean_kwargs)
-        if 'timestamp' not in clean_kwargs:
-            raise ArcsecondError('Missing timestamp.')
+        if "timestamp" not in clean_kwargs:
+            raise ArcsecondError("Missing timestamp.")
         return fields
 
     def upload_file(self, timestamp, **kwargs):

arcsecond/cloud/uploader/context.py

@@ -85,7 +85,9 @@ def _validate_local_astronomer_credentials(self):
 
     def _validate_remote_organisation(self):
         click.echo(f" • Fetching details of organisation {self._subdomain}...")
-        _, error = ArcsecondAPI(self._config, self._subdomain).organisations.read(self._subdomain)
+        _, error = ArcsecondAPI(self._config, self._subdomain).organisations.read(
+            self._subdomain
+        )
         if error is not None:
             raise UnknownOrganisationError(self._subdomain, str(error))
 

arcsecond/cloud/uploader/datafiles/context.py

@@ -50,7 +50,9 @@ def _validate_input_dataset_uuid_or_name(self):
             click.echo(
                 f" • Looking for a dataset with name {self._input_dataset_uuid_or_name}..."
             )
-            datasets_list, error = endpoint.list(**{"name": self._input_dataset_uuid_or_name})
+            datasets_list, error = endpoint.list(
+                **{"name": self._input_dataset_uuid_or_name}
+            )
             if len(datasets_list) == 0:
                 click.echo(
                     f" • No dataset with name {self._input_dataset_uuid_or_name} found. It will be created."

arcsecond/cloud/uploader/datafiles/uploader.py

@@ -22,7 +22,9 @@ def _prepare_upload(self):
             self._logger.info(
                 f"{self.log_prefix} Creating dataset with name {dataset_name}..."
             )
-            endpoint = ArcsecondAPIEndpoint(self._context.config, 'datasets', self._context.subdomain)
+            endpoint = ArcsecondAPIEndpoint(
+                self._context.config, "datasets", self._context.subdomain
+            )
             dataset, error = endpoint.create(json=data)
 
             if error:
@@ -41,13 +43,18 @@ def _get_upload_data(self, **kwargs):
             "is_raw": str(self._context.is_raw_data),
         }
         if self._context.custom_tags and len(self._context.custom_tags) > 0:
-            raw_tags = self._context.custom_tags if isinstance(self._context.custom_tags, list) \
-                else self._context.custom_tags.split(',')
+            raw_tags = (
+                self._context.custom_tags
+                if isinstance(self._context.custom_tags, list)
+                else self._context.custom_tags.split(",")
+            )
             tags = [t.strip() for t in raw_tags if len(t.strip()) > 0]
             fields["tags"] = ",".join(tags)
-        clean_kwargs = {k: kwargs[k] for k in ('is_raw', 'tags', 'dataset') if k in kwargs}
-        if 'tags' in clean_kwargs and not clean_kwargs['tags']:
+        clean_kwargs = {
+            k: kwargs[k] for k in ("is_raw", "tags", "dataset") if k in kwargs
+        }
+        if "tags" in clean_kwargs and not clean_kwargs["tags"]:
             # Tags must really be provided only when non-blank/null/empty
-            del clean_kwargs['tags']
+            del clean_kwargs["tags"]
         fields.update(**clean_kwargs)
         return fields

arcsecond/cloud/uploader/uploader.py

@@ -55,10 +55,10 @@ class BaseFileUploader(Generic[ContextT], ABC):
     """Abstract base class for uploaders"""
 
     def __init__(
-            self,
-            context: ContextT,
-            file_path: str | Path,
-            display_progress=False,
+        self,
+        context: ContextT,
+        file_path: str | Path,
+        display_progress=False,
     ):
         self._context = context
         self._file_path = Path(file_path)
@@ -96,7 +96,9 @@ def _prepare_upload(self):
 
     def _get_upload_files(self, **kwargs):
         filename = os.path.basename(self._file_path)
-        self._file = UploadFileWithProgress(self._file_path, display_progress=self._display_progress)
+        self._file = UploadFileWithProgress(
+            self._file_path, display_progress=self._display_progress
+        )
         self._cleanup_resources.append(self._file)
         return {
             "file": (filename, self._file, "application/octet-stream"),
@@ -118,7 +120,9 @@ def _perform_upload(self, **kwargs):
 
         files = self._get_upload_files(**kwargs)
         data = self._get_upload_data(**kwargs)
-        self._uploaded_file, error = self._context.upload_api_endpoint.create(files=files, json=data)
+        self._uploaded_file, error = self._context.upload_api_endpoint.create(
+            files=files, json=data
+        )
 
         if not error:
             seconds = (datetime.now() - self._started).total_seconds()
@@ -128,7 +132,7 @@ def _perform_upload(self, **kwargs):
             return
 
         if "already exists in dataset" in str(
-                error
+            error
         ):  # VERY WEAK!!! But solution with HTTP 409 isn't nice either.
             self._status = [Status.SKIPPED, Substatus.ALREADY_SYNCED, None]
         else:
@@ -141,8 +145,9 @@ def _perform_upload(self, **kwargs):
     def _cleanup(self):
         for resource in self._cleanup_resources:
             try:
-                if hasattr(resource, "close") and \
-                        not getattr(resource, "closed", False):
+                if hasattr(resource, "close") and not getattr(
+                    resource, "closed", False
+                ):
                     resource.close()
             except Exception as e:
                 self._logger.error(f"{self.log_prefix} {str(e)}.")
@@ -159,7 +164,9 @@ def upload_file(self, **kwargs):
         try:
             self._prepare_upload()
         except Exception:
-            self._logger.info(f"{self.log_prefix} Upload preparation error. Trying again automatically in 1 second.")
+            self._logger.info(
+                f"{self.log_prefix} Upload preparation error. Trying again automatically in 1 second."
+            )
             # Just try again
             time.sleep(1)
             self._prepare_upload()
@@ -170,7 +177,9 @@ def upload_file(self, **kwargs):
             self._perform_upload(**kwargs)
         except UploadRemoteFileError:
             # Just try again
-            self._logger.info(f"{self.log_prefix} Upload error. Trying again automatically in 1 second.")
+            self._logger.info(
+                f"{self.log_prefix} Upload error. Trying again automatically in 1 second."
+            )
             time.sleep(1)
             self._perform_upload(**kwargs_copy)
         finally: