Use append instead of += [stuff]

Author: ben-edna

dfetch_hub/example_gui/gui.py

@@ -139,7 +139,7 @@ def update_autocomplete(value: str) -> None:
                         fuzz.ratio(value, project.src),
                     )
                     if ratio > 30 or url > 20 or repo_path > 20 or src > 20:
-                        sorted_list += [(ratio, project)]
+                        sorted_list.append((ratio, project))
                     sorted_list.sort(key=lambda i: i[0], reverse=True)
                 for ratio, project in sorted_list:
                     add_project_to_page(project)

dfetch_hub/project/export.py

@@ -34,7 +34,7 @@ def __init__(self, entries: Optional[List[Entry]] = None):
             self._entries = []
 
     def add_entry(self, entry: Entry) -> None:
-        self._entries += [entry]
+        self._entries.append(entry)
 
     @property
     def entries(self) -> List[Entry]:

dfetch_hub/project/project_finder.py

@@ -51,7 +51,7 @@ def filter_exclusions(self, paths: Union[List[str], Set[str]]) -> List[str]:
                     if not path_allowed:
                         break
                 if path_allowed and path not in filtered_paths:
-                    filtered_paths += [path]
+                    filtered_paths.append(path)
             else:
                 filtered_paths = list(paths)
         return filtered_paths
@@ -66,7 +66,7 @@ def add_exclusion(self, exclusion: Optional[str]) -> None:
         if exclusion:
             if not self._exclusions:
                 self._exclusions = []
-            self._exclusions += [exclusion]
+            self._exclusions.append(exclusion)
             print(f"exclusions are {self.exclusions}")
 
     def filter_projects(self) -> None:
@@ -163,7 +163,7 @@ def _projects_from_paths(
             project = RemoteProject(name, base_url, repo_path, src, vcs)
             project.versions.vcs = vcs
             project.add_versions(branches, tags)
-            projects += [project]
+            projects.append(project)
         return projects
 
 

dfetch_hub/project/project_parser.py

@@ -20,18 +20,17 @@ def __init__(self) -> None:
     def add_project(self, new_project: RemoteProject) -> None:
         """add a project"""
         if new_project not in self._projects:
-            self._projects += [new_project]
+            self._projects.append(new_project)
 
     def get_projects(self) -> List[RemoteProject]:
         """get all projects"""
         return self._projects
 
     def get_projects_as_yaml(self) -> str:
         """get yaml representation of projects"""
-        yaml_str = ""
-        yaml_obj: Dict[str, Any] = {"projects": []}
-        for project in self._projects:
-            yaml_obj["projects"] += [project.as_yaml()]
+        yaml_obj: Dict[str, List] = {
+            "projects": [project.as_yaml() for project in self._projects]
+        }
         yaml_str = yaml.dump(yaml_obj)
         return yaml_str
 

dfetch_hub/project/project_sources.py

@@ -18,10 +18,7 @@ def __init__(self, args: Union[Namespace, Dict[str, str]]):
 
     def add_exclusion(self, exclusion_regex: str) -> None:
         """add exclusion to project source"""
-        if not self.exclusions:
-            self.exclusions = [exclusion_regex]
-        else:
-            self.exclusions += [exclusion_regex]
+        self.exclusions.append(exclusion_regex)
 
     def as_yaml(self) -> Dict[str, Any]:
         """get yaml representation"""
@@ -55,7 +52,7 @@ def __init__(self) -> None:
 
     def add_remote(self, source: RemoteSource) -> None:
         """add source"""
-        self._sources += [source]
+        self._sources.append(source)
 
     def get_remotes(self) -> List[RemoteSource]:
         """get list of sources"""

dfetch_hub/project/remote_datasource.py

@@ -36,13 +36,13 @@ def add_tags(self, tags: Sequence[Tuple[str, str]]) -> None:
         """add tags"""
         for hash_val, tag_name in tags:
             if tag_name not in [tag.name for tag in self.tags]:
-                self.tags += [RemoteRef(tag_name, hash_val)]
+                self.tags.append(RemoteRef(tag_name, hash_val))
 
     def add_branches(self, branches: Sequence[Tuple[str, str]]) -> None:
         """add branches"""
         for hash_val, branch_name in branches:
             if branch_name not in [branch.name for branch in self.branches]:
-                self.branches += [RemoteRef(branch_name, hash_val)]
+                self.branches.append(RemoteRef(branch_name, hash_val))
 
     @property
     def default(self) -> str: