pylint fixes

comic/admin.py

@@ -49,4 +49,4 @@ class ComicStatusAdmin(admin.ModelAdmin):
 @admin.register(UserMisc)
 class UserMiscAdmin(admin.ModelAdmin):
     list_display = ('user', 'feed_id', 'allowed_to_read')
-    list_filter = ('user',)
+    list_filter = ('user',)

comic/errors.py

@@ -1,2 +1,2 @@
 class NotCompatibleArchive(Exception):
-    pass
+    pass

comic/feeds.py

@@ -13,8 +13,8 @@ class RecentComicsAPI(Feed):
     description = "Recently added Comics"
     user: User
 
-    def get_object(self, request: HttpRequest, user_selector: str, *args, **kwargs) -> UserMisc:
-        user_misc = get_object_or_404(UserMisc, feed_id=user_selector)
+    def get_object(self, request: HttpRequest, *args, **kwargs) -> UserMisc:
+        user_misc = get_object_or_404(UserMisc, feed_id=kwargs["user_selector"])
         self.user = user_misc.user
         return user_misc.user
 

comic/models.py

@@ -13,7 +13,7 @@ import rarfile
 from PIL import Image, UnidentifiedImageError
 from PIL.Image import Image as Image_type
 from django.conf import settings
-from django.contrib.auth.models import User, AbstractUser
+from django.contrib.auth.models import User
 from django.core.files.uploadedfile import InMemoryUploadedFile
 from django.db import models
 from django.db.models import UniqueConstraint
@@ -54,7 +54,7 @@ class Directory(models.Model):
         ordering = ['name']
 
     def __str__(self):
-        return "Directory: {0}; {1}".format(self.name, self.parent)
+        return f"Directory: {self.name}; {self.parent}"
 
     @property
     def title(self) -> str:
@@ -81,25 +81,25 @@ class Directory(models.Model):
         path_items = self.get_path_items()
         path_items.reverse()
         if len(path_items) >= 2:
+            # pylint: disable=unnecessary-lambda
             return reduce(lambda x, y: Path(x, y), path_items)
-        else:
-            return Path(path_items[0])
+        return Path(path_items[0])
 
-    def get_path_items(self, p: Optional[List] = None) -> List[Path]:
-        if p is None:
-            p = []
-        p.append(self.name)
+    def get_path_items(self, path_items: Optional[List] = None) -> List[Path]:
+        if path_items is None:
+            path_items = []
+        path_items.append(self.name)
         if self.parent:
-            self.parent.get_path_items(p)
-        return p
+            self.parent.get_path_items(path_items)
+        return path_items
 
-    def get_path_objects(self, p=None) -> List["Directory"]:
-        if p is None:
-            p = []
-        p.append(self)
+    def get_path_objects(self, path_items=None) -> List["Directory"]:
+        if path_items is None:
+            path_items = []
+        path_items.append(self)
         if self.parent:
-            self.parent.get_path_objects(p)
-        return p
+            self.parent.get_path_objects(path_items)
+        return path_items
 
 
 class ComicBook(models.Model):
@@ -135,8 +135,7 @@ class ComicBook(models.Model):
         base_dir = settings.COMIC_BOOK_VOLUME
         if self.directory:
             return Path(base_dir, self.directory.get_path(), self.file_name)
-        else:
-            return Path(base_dir, self.file_name)
+        return Path(base_dir, self.file_name)
 
     def get_image(self, page: int) -> Union[Tuple[io.BytesIO, Image_type], Tuple[bool, bool]]:
         base_dir = settings.COMIC_BOOK_VOLUME
@@ -147,6 +146,7 @@ class ComicBook(models.Model):
         try:
             archive = rarfile.RarFile(archive_path)
         except rarfile.NotRarFile:
+            # pylint: disable=consider-using-with
             archive = zipfile.ZipFile(archive_path)
         except zipfile.BadZipfile:
             return False, False
@@ -171,9 +171,9 @@ class ComicBook(models.Model):
             img, content_type = self.get_image(page_index)
             pil_data = Image.open(img)
         else:
-            for x in range(ComicPage.objects.filter(Comic=self).count()):
+            for page_number in range(ComicPage.objects.filter(Comic=self).count()):
                 try:
-                    img, content_type = self.get_image(x)
+                    img, content_type = self.get_image(page_number)
                     pil_data = Image.open(img)
                     break
                 except UnidentifiedImageError:
@@ -248,8 +248,7 @@ class ComicBook(models.Model):
     def get_archive_path(self) -> Path:
         if self.directory:
             return Path(settings.COMIC_BOOK_VOLUME, self.directory.get_path(), self.file_name)
-        else:
-            return Path(settings.COMIC_BOOK_VOLUME, self.file_name)
+        return Path(settings.COMIC_BOOK_VOLUME, self.file_name)
 
     def get_archive(self) -> Tuple[Union[rarfile.RarFile, zipfile.ZipFile, fitz.Document], str]:
         archive_path = self.get_archive_path

comic/processing.py

@@ -61,8 +61,8 @@ def generate_directory(user: User, directory=None):
 
 
 def clean_directories(directories, dir_path, directory=None):
-    dir_db_set = set([Path(settings.COMIC_BOOK_VOLUME, x.path) for x in directories])
-    dir_list = set([x for x in sorted(dir_path.glob('*')) if x.is_dir()])
+    dir_db_set = set(Path(settings.COMIC_BOOK_VOLUME, x.path) for x in directories)
+    dir_list = set(x for x in sorted(dir_path.glob('*')) if x.is_dir())
     # Create new directories db instances
     for new_directory in dir_list - dir_db_set:
         models.Directory(name=new_directory.name, parent=directory).save()
@@ -73,8 +73,8 @@ def clean_directories(directories, dir_path, directory=None):
 
 
 def clean_files(files, user, dir_path, directory=None):
-    file_list = set([x for x in sorted(dir_path.glob('*')) if x.is_file()])
-    files_db_set = set([Path(dir_path, x.file_name) for x in files])
+    file_list = set(x for x in sorted(dir_path.glob('*')) if x.is_file())
+    files_db_set = set(Path(dir_path, x.file_name) for x in files)
 
     # Parse new comics
     books_to_add = []

comic/rest.py

@@ -44,7 +44,7 @@ class ClassificationSerializer(serializers.Serializer):
         raise serializers.ValidationError('Invalid Classification sent.')
 
 
-class UserViewSet(viewsets.ModelViewSet):
+class UserViewSet(viewsets.ModelViewSet):  # pylint: disable=too-many-ancestors
     """
     API endpoint that allows users to be viewed or edited.
     """
@@ -82,8 +82,7 @@ class UserViewSet(viewsets.ModelViewSet):
             misc.allowed_to_read = serializer.data['classification']
             misc.save()
             return Response(data={'classification': misc.allowed_to_read})
-        else:
-            return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
+        return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
 
 
 class BrowseFileField(serializers.FileField):
@@ -217,19 +216,20 @@ class ReadViewSet(viewsets.GenericViewSet):
     @swagger_auto_schema(responses={status.HTTP_200_OK: ReadSerializer()})
     def retrieve(self, request: Request, selector: UUID) -> Response:
         comic = get_object_or_404(models.ComicBook, selector=selector)
-        misc, _ = models.UserMisc.objects.get_or_create(user=request.user)
+        _, _ = models.UserMisc.objects.get_or_create(user=request.user)
         pages = models.ComicPage.objects.filter(Comic=comic)
         comic_status, _ = models.ComicStatus.objects.get_or_create(comic=comic, user=request.user)
         comic_list = list(models.ComicBook.objects.filter(directory=comic.directory).order_by('file_name'))
         comic_index = comic_list.index(comic)
         try:
             prev_comic = {'route': 'browse', 'selector': comic.directory.selector} if comic_index == 0 else \
-                {'route': 'read', 'selector': comic_list[comic_index-1].selector}
+                {'route': 'read', 'selector': comic_list[comic_index - 1].selector}
         except AttributeError:
             prev_comic = {'route': 'browse'}
         try:
-            next_comic = {'route': 'browse', 'selector': comic.directory.selector} if comic_index+1 == len(comic_list) \
-                else {'route': 'read', 'selector': comic_list[comic_index+1].selector}
+            next_comic = {'route': 'browse', 'selector': comic.directory.selector} \
+                if comic_index + 1 == len(comic_list) \
+                else {'route': 'read', 'selector': comic_list[comic_index + 1].selector}
         except AttributeError:
             next_comic = {'route': 'browse'}
         data = {
@@ -269,22 +269,21 @@ class ReadViewSet(viewsets.GenericViewSet):
         serializer = self.get_serializer(data=request.data)
 
         if serializer.is_valid():
-            comic_status, _ = models.ComicStatus.objects.annotate(page_count=Count('comic__comicpage'))\
+            comic_status, _ = models.ComicStatus.objects.annotate(page_count=Count('comic__comicpage')) \
                 .get_or_create(comic_id=selector, user=request.user)
             comic_status.last_read_page = serializer.data['page']
             comic_status.unread = False
-            if comic_status.page_count-1 == comic_status.last_read_page:
+            if comic_status.page_count - 1 == comic_status.last_read_page:
                 comic_status.finished = True
             else:
                 comic_status.finished = False
 
             comic_status.save()
             return Response(self.get_serializer(comic_status).data)
-        else:
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 
 
-class PassthroughRenderer(renderers.BaseRenderer):
+class PassthroughRenderer(renderers.BaseRenderer):  # pylint: disable=too-few-public-methods
     """
         Return data as-is. View should supply a Response.
     """
@@ -373,7 +372,7 @@ class ActionViewSet(viewsets.GenericViewSet):
             comic_status = comic_status.annotate(total_pages=Count('comic__comicpage'))
             status_to_update = []
             for c_status in comic_status:
-                c_status.last_read_page = c_status.total_pages-1
+                c_status.last_read_page = c_status.total_pages - 1
                 c_status.unread = False
                 c_status.finished = True
                 status_to_update.append(c_status)
@@ -388,37 +387,33 @@ class ActionViewSet(viewsets.GenericViewSet):
                 status_to_update.append(obj)
             models.ComicStatus.objects.bulk_update(status_to_update, ['unread', 'finished', 'last_read_page'])
             return Response({'status': 'marked_read'})
-        else:
-            return Response(serializer.errors,
-                            status=status.HTTP_400_BAD_REQUEST)
+        return Response(serializer.errors,
+                        status=status.HTTP_400_BAD_REQUEST)
 
     @action(detail=False, methods=['PUT'])
     def mark_unread(self, request):
         serializer = ActionSerializer(data=request.data)
         if serializer.is_valid():
-            serializer = ActionSerializer(data=request.data)
-            if serializer.is_valid():
-                comics = self.get_comics(serializer.data['selectors'])
-                comic_status = models.ComicStatus.objects.filter(comic__selector__in=comics, user=request.user)
-                status_to_update = []
-                for c_status in comic_status:
-                    c_status.last_read_page = 0
-                    c_status.unread = True
-                    c_status.finished = False
-                    status_to_update.append(c_status)
-                    comics.remove(str(c_status.comic_id))
-                for new_status in comics:
-                    comic = models.ComicBook.objects.get(selector=new_status)
-                    obj, _ = models.ComicStatus.objects.get_or_create(comic=comic, user=request.user)
-                    obj.unread = True
-                    obj.finished = False
-                    obj.last_read_page = 0
-                    status_to_update.append(obj)
-                models.ComicStatus.objects.bulk_update(status_to_update, ['unread', 'finished', 'last_read_page'])
-                return Response({'status': 'marked_unread'})
-        else:
-            return Response(serializer.errors,
-                            status=status.HTTP_400_BAD_REQUEST)
+            comics = self.get_comics(serializer.data['selectors'])
+            comic_status = models.ComicStatus.objects.filter(comic__selector__in=comics, user=request.user)
+            status_to_update = []
+            for c_status in comic_status:
+                c_status.last_read_page = 0
+                c_status.unread = True
+                c_status.finished = False
+                status_to_update.append(c_status)
+                comics.remove(str(c_status.comic_id))
+            for new_status in comics:
+                comic = models.ComicBook.objects.get(selector=new_status)
+                obj, _ = models.ComicStatus.objects.get_or_create(comic=comic, user=request.user)
+                obj.unread = True
+                obj.finished = False
+                obj.last_read_page = 0
+                status_to_update.append(obj)
+            models.ComicStatus.objects.bulk_update(status_to_update, ['unread', 'finished', 'last_read_page'])
+            return Response({'status': 'marked_unread'})
+        return Response(serializer.errors,
+                        status=status.HTTP_400_BAD_REQUEST)
 
     def get_comics(self, selectors):
         data = set()
@@ -461,8 +456,8 @@ class PasswordResetSerializer(serializers.Serializer):
             return data
         try:
             validate_password(data)
-        except ValidationError as e:
-            raise serializers.ValidationError(e)
+        except ValidationError as err:
+            raise serializers.ValidationError(err)
         return data
 
     def validate(self, attrs):
@@ -489,8 +484,7 @@ class AccountViewSet(viewsets.GenericViewSet):
             request.user.set_password(serializer.data['new_password'])
             request.user.save()
             return Response(AccountSerializer(request.user).data)
-        else:
-            return Response({"errors": serializer.errors}, status.HTTP_400_BAD_REQUEST)
+        return Response({"errors": serializer.errors}, status.HTTP_400_BAD_REQUEST)
 
     def list(self, request):
         serializer = self.get_serializer(request.user)
@@ -509,8 +503,7 @@ class AccountViewSet(viewsets.GenericViewSet):
             request.user.save()
             account = AccountSerializer(request.user)
             return Response(account.data)
-        else:
-            return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
+        return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
 
     @swagger_auto_schema(responses={status.HTTP_200_OK: RSSSerializer()})
     @action(methods=['get'], detail=False, serializer_class=RSSSerializer)
@@ -524,7 +517,6 @@ class AccountViewSet(viewsets.GenericViewSet):
 
 
 class DirectorySerializer(serializers.ModelSerializer):
-
     class Meta:
         model = models.Directory
         fields = ['selector', 'classification']
@@ -540,7 +532,7 @@ class DirectoryViewSet(mixins.UpdateModelMixin, viewsets.GenericViewSet):
     lookup_field = 'selector'
 
     @swagger_auto_schema(responses={200: DirectorySerializer(many=True)})
-    def update(self, request: Request, selector: UUID) -> Response:
+    def update(self, request: Request, selector: UUID) -> Response: # pylint: disable=arguments-differ
         """
         This will set the classification of a directory and all it's children.
         """
@@ -563,8 +555,7 @@ class DirectoryViewSet(mixins.UpdateModelMixin, viewsets.GenericViewSet):
             data = models.Directory.objects.filter(directory__in=to_update)
             response = self.get_serializer(data, many=True)
             return Response(response.data)
-        else:
-            return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
+        return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
 
     def partial_update(self, request, *args, **kwargs):
         """
@@ -607,7 +598,5 @@ class InitialSetup(viewsets.GenericViewSet):
                 admin.set_password(serializer.data['password'])
                 admin.save()
                 return Response(serializer.data, status.HTTP_201_CREATED)
-            else:
-                return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
-        else:
-            return Response({}, status.HTTP_400_BAD_REQUEST)
+            return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
+        return Response({}, status.HTTP_400_BAD_REQUEST)

comic/util.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
+from typing import Optional
 
-from .models import ComicBook, Directory
+from comic.models import ComicBook, Directory
 
 
 @dataclass()
@@ -9,12 +10,7 @@ class Breadcrumb:
     selector: str = ''
 
 
-def generate_breadcrumbs_from_path(directory=False, book=False):
-    """
-
-    :type directory: Directory
-    :type book: ComicBook
-    """
+def generate_breadcrumbs_from_path(directory: Optional[Directory] = None, book: Optional[ComicBook] = None):
     output = [Breadcrumb()]
     if directory:
         folders = directory.get_path_objects()