pypaperless 2.2.0__tar.gz → 2.3.0__tar.gz

{pypaperless-2.2.0/pypaperless.egg-info → pypaperless-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypaperless
-Version: 2.2.0
+Version: 2.3.0
 Summary: Little api wrapper for the paperless(-ngx) dms.
 Author-email: Tobias Schulz <public.dev@tbsch.de>
 License: MIT License
@@ -19,18 +19,22 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp
+Requires-Dist: aiohttp==3.9.1
+Requires-Dist: awesomeversion==23.11.0
+Requires-Dist: yarl==1.9.4
 Provides-Extra: test
 Requires-Dist: black==23.12.1; extra == "test"
 Requires-Dist: codespell==2.2.6; extra == "test"
 Requires-Dist: mypy==1.8.0; extra == "test"
-Requires-Dist: ruff==0.1.9; extra == "test"
-Requires-Dist: pytest==7.4.3; extra == "test"
-Requires-Dist: pytest-asyncio==0.23.2; extra == "test"
+Requires-Dist: ruff==0.1.11; extra == "test"
+Requires-Dist: pytest==7.4.4; extra == "test"
+Requires-Dist: pytest-asyncio==0.23.3; extra == "test"
 Requires-Dist: pytest-aiohttp==1.0.5; extra == "test"
 Requires-Dist: pytest-cov==4.1.0; extra == "test"
 Requires-Dist: pre-commit==3.6.0; extra == "test"
 Requires-Dist: pylint==3.0.3; extra == "test"
+Requires-Dist: fastapi==0.108.0; extra == "test"
+Requires-Dist: httpx==0.26.0; extra == "test"
 
 # PyPaperless
 

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/__init__.py

@@ -6,7 +6,17 @@ from contextlib import asynccontextmanager
 from typing import Any
 
 import aiohttp
-
+from awesomeversion import AwesomeVersion
+from yarl import URL
+
+from .const import (
+    PAPERLESS_V1_8_0,
+    PAPERLESS_V1_17_0,
+    PAPERLESS_V2_0_0,
+    PAPERLESS_V2_3_0,
+    ControllerPath,
+    PaperlessFeature,
+)
 from .controllers import (
     ConsumptionTemplatesController,
     CorrespondentsController,
@@ -22,17 +32,20 @@ from .controllers import (
     TagsController,
     TasksController,
     UsersController,
+    WorkflowActionsController,
+    WorkflowsController,
+    WorkflowTriggersController,
 )
-from .errors import BadRequestException, DataNotExpectedException
-from .models.shared import ResourceType
+from .errors import BadRequestException, ControllerConfusion, DataNotExpectedException
+from .util import create_url_from_input
 
 
-class Paperless:  # pylint: disable=too-many-instance-attributes
+class Paperless:  # pylint: disable=too-many-instance-attributes,too-many-public-methods
     """Retrieves and manipulates data from and to paperless via REST."""
 
     def __init__(
         self,
-        host: str,
+        url: str | URL,
         token: str,
         request_opts: dict[str, Any] | None = None,
         session: aiohttp.ClientSession | None = None,
@@ -41,18 +54,19 @@ class Paperless:  # pylint: disable=too-many-instance-attributes
         Initialize the Paperless api instance.
 
         Parameters:
-        * host: the hostname or IP-address of Paperless as string.
+        * host: the hostname or IP-address of Paperless as string, or yarl.URL object.
         * token: provide an api token created in Paperless Django settings.
         * session: provide an existing aiohttp ClientSession.
         """
-        self._host = host
+        self._url = create_url_from_input(url)
         self._token = token
         self._request_opts = request_opts
         self._session = session
         self._initialized = False
-        self.logger = logging.getLogger(f"{__package__}[{host}]")
+        self.logger = logging.getLogger(f"{__package__}[{self._url.host}]")
 
-        # endpoints
+        self.features: PaperlessFeature = PaperlessFeature(0)
+        # api controllers
         self._consumption_templates: ConsumptionTemplatesController | None = None
         self._correspondents: CorrespondentsController | None = None
         self._custom_fields: CustomFieldsController | None = None
@@ -67,11 +81,14 @@ class Paperless:  # pylint: disable=too-many-instance-attributes
         self._tags: TagsController | None = None
         self._tasks: TasksController | None = None
         self._users: UsersController | None = None
+        self._workflows: WorkflowsController | None = None
+        self._workflow_actions: WorkflowActionsController | None = None
+        self._workflow_triggers: WorkflowTriggersController | None = None
 
     @property
-    def host(self) -> str | None:
-        """Return the hostname of Paperless."""
-        return self._host
+    def url(self) -> URL:
+        """Return the url of Paperless."""
+        return self._url
 
     @property
     def is_initialized(self) -> bool:
@@ -148,33 +165,95 @@ class Paperless:  # pylint: disable=too-many-instance-attributes
         """Gateway to users."""
         return self._users
 
+    @property
+    def workflows(self) -> WorkflowsController | None:
+        """Gateway to workflows."""
+        return self._workflows
+
+    @property
+    def workflow_actions(self) -> WorkflowActionsController | None:
+        """Gateway to workflow actions."""
+        return self._workflow_actions
+
+    @property
+    def workflow_triggers(self) -> WorkflowTriggersController | None:
+        """Gateway to workflow triggers."""
+        return self._workflow_triggers
+
     async def initialize(self) -> None:
         """Initialize the connection to the api and fetch the endpoints."""
         self.logger.info("Fetching api endpoints.")
 
-        res = await self.request_json("get", "")
-
-        self._consumption_templates = ConsumptionTemplatesController(
-            self, res.pop(ResourceType.CONSUMPTION_TEMPLATES)
+        async with self.generate_request("get", f"{self._url}") as res:
+            version = AwesomeVersion(
+                res.headers.get("x-version") if "x-version" in res.headers else "0.0.0"
+            )
+
+            if version >= PAPERLESS_V1_8_0:
+                self.features |= PaperlessFeature.CONTROLLER_STORAGE_PATHS
+            if version >= PAPERLESS_V1_17_0:
+                self.features |= PaperlessFeature.FEATURE_DOCUMENT_NOTES
+            if version >= PAPERLESS_V2_0_0:
+                self.features |= (
+                    PaperlessFeature.CONTROLLER_SHARE_LINKS
+                    | PaperlessFeature.CONTROLLER_CONSUMPTION_TEMPLATES
+                    | PaperlessFeature.CONTROLLER_CUSTOM_FIELDS
+                )
+            if version >= PAPERLESS_V2_3_0:
+                self.features |= (
+                    PaperlessFeature.CONTROLLER_CONFIGS | PaperlessFeature.CONTROLLER_WORKFLOWS
+                )
+                self.features ^= PaperlessFeature.CONTROLLER_CONSUMPTION_TEMPLATES
+
+            paths = await res.json()
+
+        self._correspondents = CorrespondentsController(
+            self, paths.pop(ControllerPath.CORRESPONDENTS)
+        )
+        self._documents = DocumentsController(self, paths.pop(ControllerPath.DOCUMENTS))
+        self._document_types = DocumentTypesController(
+            self, paths.pop(ControllerPath.DOCUMENT_TYPES)
         )
-        self._correspondents = CorrespondentsController(self, res.pop(ResourceType.CORRESPONDENTS))
-        self._custom_fields = CustomFieldsController(self, res.pop(ResourceType.CUSTOM_FIELDS))
-        self._documents = DocumentsController(self, res.pop(ResourceType.DOCUMENTS))
-        self._document_types = DocumentTypesController(self, res.pop(ResourceType.DOCUMENT_TYPES))
-        self._groups = GroupsController(self, res.pop(ResourceType.GROUPS))
-        self._mail_accounts = MailAccountsController(self, res.pop(ResourceType.MAIL_ACCOUNTS))
-        self._mail_rules = MailRulesController(self, res.pop(ResourceType.MAIL_RULES))
-        self._saved_views = SavedViewsController(self, res.pop(ResourceType.SAVED_VIEWS))
-        self._share_links = ShareLinksController(self, res.pop(ResourceType.SHARE_LINKS))
-        self._storage_paths = StoragePathsController(self, res.pop(ResourceType.STORAGE_PATHS))
-        self._tags = TagsController(self, res.pop(ResourceType.TAGS))
-        self._tasks = TasksController(self, res.pop(ResourceType.TASKS))
-        self._users = UsersController(self, res.pop(ResourceType.USERS))
+        self._groups = GroupsController(self, paths.pop(ControllerPath.GROUPS))
+        self._mail_accounts = MailAccountsController(self, paths.pop(ControllerPath.MAIL_ACCOUNTS))
+        self._mail_rules = MailRulesController(self, paths.pop(ControllerPath.MAIL_RULES))
+        self._saved_views = SavedViewsController(self, paths.pop(ControllerPath.SAVED_VIEWS))
+        self._tags = TagsController(self, paths.pop(ControllerPath.TAGS))
+        self._tasks = TasksController(self, paths.pop(ControllerPath.TASKS))
+        self._users = UsersController(self, paths.pop(ControllerPath.USERS))
+
+        try:
+            if PaperlessFeature.CONTROLLER_STORAGE_PATHS in self.features:
+                self._storage_paths = StoragePathsController(
+                    self, paths.pop(ControllerPath.STORAGE_PATHS)
+                )
+            if PaperlessFeature.CONTROLLER_CONSUMPTION_TEMPLATES in self.features:
+                self._consumption_templates = ConsumptionTemplatesController(
+                    self, paths.pop(ControllerPath.CONSUMPTION_TEMPLATES)
+                )
+            if PaperlessFeature.CONTROLLER_CUSTOM_FIELDS in self.features:
+                self._custom_fields = CustomFieldsController(
+                    self, paths.pop(ControllerPath.CUSTOM_FIELDS)
+                )
+            if PaperlessFeature.CONTROLLER_SHARE_LINKS in self.features:
+                self._share_links = ShareLinksController(
+                    self, paths.pop(ControllerPath.SHARE_LINKS)
+                )
+            if PaperlessFeature.CONTROLLER_WORKFLOWS in self.features:
+                self._workflows = WorkflowsController(self, paths.pop(ControllerPath.WORKFLOWS))
+                self._workflow_actions = WorkflowActionsController(
+                    self, paths.pop(ControllerPath.WORKFLOW_ACTIONS)
+                )
+                self._workflow_triggers = WorkflowTriggersController(
+                    self, paths.pop(ControllerPath.WORKFLOW_TRIGGERS)
+                )
+        except KeyError as exc:
+            raise ControllerConfusion(exc) from exc
 
         self._initialized = True
 
-        if len(res) > 0:
-            self.logger.debug("Unused endpoints: %s", ", ".join(res))
+        if len(paths) > 0:
+            self.logger.debug("Unused paths: %s", ", ".join(paths))
         self.logger.info("Initialized.")
 
     async def close(self) -> None:
@@ -194,8 +273,7 @@ class Paperless:  # pylint: disable=too-many-instance-attributes
         if not isinstance(self._session, aiohttp.ClientSession):
             self._session = aiohttp.ClientSession()
 
-        url = path if path.startswith("http") else f"http://{self.host}/api/{path}"
-        url = url.rstrip("/") + "/"  # check and add trailing slash
+        path = path.rstrip("/") + "/"  # check and add trailing slash
 
         if isinstance(self._request_opts, dict):
             kwargs.update(self._request_opts)
@@ -208,7 +286,27 @@ class Paperless:  # pylint: disable=too-many-instance-attributes
             }
         )
 
-        async with self._session.request(method, url, **kwargs) as res:
+        # convert form to FormData, if dict
+        if "form" in kwargs:
+            payload = kwargs.pop("form")
+            if not isinstance(payload, dict):
+                raise TypeError()
+            form = aiohttp.FormData()
+
+            # we just convert data, no nesting dicts
+            for key, value in payload.items():
+                if isinstance(value, str | bytes):
+                    form.add_field(key, value)
+                elif isinstance(value, list):
+                    for list_value in value:
+                        form.add_field(key, f"{list_value}")
+                else:
+                    form.add_field(key, f"{value}")
+
+            kwargs["data"] = form
+
+        # request data
+        async with self._session.request(method, path, **kwargs) as res:
             yield res
 
     async def request_json(

pypaperless-2.3.0/pypaperless/const.py

@@ -0,0 +1,65 @@
+"""PyPaperless constants."""
+
+from enum import IntFlag, StrEnum
+
+from awesomeversion import AwesomeVersion
+
+PAPERLESS_V1_8_0 = AwesomeVersion("1.8.0")
+PAPERLESS_V1_17_0 = AwesomeVersion("1.17.0")
+PAPERLESS_V2_0_0 = AwesomeVersion("2.0.0")
+PAPERLESS_V2_3_0 = AwesomeVersion("2.3.0")
+
+
+CTRL_CONSUMPTION_TEMPLATES = "consumption_templates"
+CTRL_CORRESPONDENTS = "correspondents"
+CTRL_CUSTOM_FIELDS = "custom_fields"
+CTRL_DOCUMENTS = "documents"
+CTRL_DOCUMENT_TYPES = "document_types"
+CTRL_GROUPS = "groups"
+CTRL_MAIL_ACCOUNTS = "mail_accounts"
+CTRL_MAIL_RULES = "mail_rules"
+CTRL_SAVED_VIEWS = "saved_views"
+CTRL_SHARE_LINKS = "share_links"
+CTRL_STORAGE_PATHS = "storage_paths"
+CTRL_TAGS = "tags"
+CTRL_TASKS = "tasks"
+CTRL_USERS = "users"
+CTRL_WORKFLOW_ACTIONS = "workflow_actions"
+CTRL_WORKFLOWS = "workflows"
+CTRL_WORKFLOW_TRIGGERS = "workflow_triggers"
+CTRL_UNKNOWN = "unknown"
+
+
+class PaperlessFeature(IntFlag):
+    """Supported features."""
+
+    CONTROLLER_STORAGE_PATHS = 1
+    FEATURE_DOCUMENT_NOTES = 2
+    CONTROLLER_SHARE_LINKS = 4
+    CONTROLLER_CUSTOM_FIELDS = 8
+    CONTROLLER_CONSUMPTION_TEMPLATES = 16
+    CONTROLLER_WORKFLOWS = 32
+    CONTROLLER_CONFIGS = 64
+
+
+class ControllerPath(StrEnum):
+    """Represent paths of api endpoints."""
+
+    CONSUMPTION_TEMPLATES = CTRL_CONSUMPTION_TEMPLATES
+    CORRESPONDENTS = CTRL_CORRESPONDENTS
+    CUSTOM_FIELDS = CTRL_CUSTOM_FIELDS
+    DOCUMENTS = CTRL_DOCUMENTS
+    DOCUMENT_TYPES = CTRL_DOCUMENT_TYPES
+    GROUPS = CTRL_GROUPS
+    MAIL_ACCOUNTS = CTRL_MAIL_ACCOUNTS
+    MAIL_RULES = CTRL_MAIL_RULES
+    SAVED_VIEWS = CTRL_SAVED_VIEWS
+    SHARE_LINKS = CTRL_SHARE_LINKS
+    STORAGE_PATHS = CTRL_STORAGE_PATHS
+    TAGS = CTRL_TAGS
+    TASKS = CTRL_TASKS
+    USERS = CTRL_USERS
+    WORKFLOWS = CTRL_WORKFLOWS
+    WORKFLOW_ACTIONS = CTRL_WORKFLOW_ACTIONS
+    WORKFLOW_TRIGGERS = CTRL_WORKFLOW_TRIGGERS
+    UNKNOWN = CTRL_UNKNOWN

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/controllers/__init__.py

@@ -13,6 +13,9 @@ from .default import (
     StoragePathsController,
     TagsController,
     UsersController,
+    WorkflowActionsController,
+    WorkflowsController,
+    WorkflowTriggersController,
 )
 from .documents import DocumentsController
 from .tasks import TasksController
@@ -32,4 +35,7 @@ __all__ = [
     "TagsController",
     "TasksController",
     "UsersController",
+    "WorkflowActionsController",
+    "WorkflowsController",
+    "WorkflowTriggersController",
 ]

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/controllers/default.py

@@ -13,6 +13,9 @@ from pypaperless.models import (
     StoragePath,
     Tag,
     User,
+    Workflow,
+    WorkflowAction,
+    WorkflowTrigger,
 )
 
 from .base import (
@@ -174,3 +177,36 @@ class UsersController(
     """Represent Paperless users resource."""
 
     _resource = User
+
+
+class WorkflowsController(
+    BaseController[Workflow],
+    PaginationMixin[Workflow],
+    ListMixin[Workflow],
+    OneMixin[Workflow],
+):
+    """Represent Paperless workflows resource."""
+
+    _resource = Workflow
+
+
+class WorkflowActionsController(
+    BaseController[WorkflowAction],
+    PaginationMixin[WorkflowAction],
+    ListMixin[WorkflowAction],
+    OneMixin[WorkflowAction],
+):
+    """Represent Paperless workflow actions resource."""
+
+    _resource = WorkflowAction
+
+
+class WorkflowTriggersController(
+    BaseController[WorkflowTrigger],
+    PaginationMixin[WorkflowTrigger],
+    ListMixin[WorkflowTrigger],
+    OneMixin[WorkflowTrigger],
+):
+    """Represent Paperless workflow triggers resource."""
+
+    _resource = WorkflowTrigger

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/controllers/documents.py

@@ -2,8 +2,7 @@
 
 from typing import TYPE_CHECKING
 
-import aiohttp
-
+from pypaperless.const import PaperlessFeature
 from pypaperless.models import (
     Document,
     DocumentMetaInformation,
@@ -114,32 +113,17 @@ class DocumentsController(  # pylint: disable=too-many-ancestors
         """Override initialize controller. Also initialize service controllers."""
         super().__init__(paperless, path)
 
-        self.notes = DocumentNotesService(self)
         self.files = DocumentFilesService(self)
+        self.notes: DocumentNotesService | None = None
+
+        if PaperlessFeature.FEATURE_DOCUMENT_NOTES in self._paperless.features:
+            self.notes = DocumentNotesService(self)
 
     async def create(self, obj: DocumentPost) -> str:
         """Create a new document. Raise on failure."""
-        form = aiohttp.FormData()
-        form.add_field("document", obj.document)
-
-        for field in (
-            "title",
-            "created",
-            "correspondent",
-            "document_type",
-            "archive_serial_number",
-        ):
-            if getattr(obj, field):
-                form.add_field(field, getattr(obj, field))
-
-        if isinstance(obj.tags, list):
-            for tag in obj.tags:
-                form.add_field("tags", f"{tag}")
-
         url = f"{self.path}/post_document/"
-
         # result is a string in this case
-        res = str(await self._paperless.request_json("post", url, data=form))
+        res: str = await self._paperless.request_json("post", url, form=dataclass_to_dict(obj))
         return res
 
     async def meta(self, obj: _DocumentOrIdType) -> DocumentMetaInformation:

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/controllers/tasks.py

@@ -29,11 +29,13 @@ class TasksController(BaseController[Task]):
         for item in res:
             yield item
 
-    async def one(self, idx: str) -> Task:
+    async def one(self, idx: str) -> Task | None:
         """Request exactly one task item by pk."""
         params = {
             "task_id": idx,
         }
         res = await self._paperless.request_json("get", self.path, params=params)
-        data: Task = dataclass_from_dict(self.resource, res.pop())
-        return data
+        if len(res) > 0:
+            data: Task = dataclass_from_dict(self.resource, res.pop())
+            return data
+        return None

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/errors.py

@@ -11,3 +11,7 @@ class BadRequestException(PaperlessException):
 
 class DataNotExpectedException(PaperlessException):
     """Raise when expecting a type and receiving something else."""
+
+
+class ControllerConfusion(PaperlessException):
+    """Raise when Paperless version does not match to controllers."""

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/models/__init__.py

@@ -1,9 +1,6 @@
 """Models for Paperless resources."""
 
-from .consumption_templates import ConsumptionTemplate
-from .correspondents import Correspondent, CorrespondentPost
 from .custom_fields import CustomField, CustomFieldPost
-from .document_types import DocumentType, DocumentTypePost
 from .documents import (
     Document,
     DocumentMetadata,
@@ -13,14 +10,22 @@ from .documents import (
     DocumentPost,
 )
 from .groups import Group
-from .mail_accounts import MailAccount
-from .mail_rules import MailRule
+from .mails import MailAccount, MailRule
+from .matching import (
+    Correspondent,
+    CorrespondentPost,
+    DocumentType,
+    DocumentTypePost,
+    StoragePath,
+    StoragePathPost,
+    Tag,
+    TagPost,
+)
 from .saved_views import SavedView, SavedViewFilterRule
 from .share_links import ShareLink, ShareLinkPost
-from .storage_paths import StoragePath, StoragePathPost
-from .tags import Tag, TagPost
 from .tasks import Task
 from .users import User
+from .workflows import ConsumptionTemplate, Workflow, WorkflowAction, WorkflowTrigger
 
 __all__ = [
     "ConsumptionTemplate",
@@ -49,4 +54,7 @@ __all__ = [
     "TagPost",
     "Task",
     "User",
+    "Workflow",
+    "WorkflowAction",
+    "WorkflowTrigger",
 ]

pypaperless-2.3.0/pypaperless/models/base.py

@@ -0,0 +1,9 @@
+"""Base models."""
+
+
+class PaperlessModel:  # pylint: disable=too-few-public-methods
+    """Base class that represents a Paperless model."""
+
+
+class PaperlessPost(PaperlessModel):  # pylint: disable=too-few-public-methods
+    """Base class that represents a Paperless POST model."""

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/models/custom_fields.py

@@ -1,10 +1,29 @@
 """Model for custom field resource."""
 
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any
 
 from .base import PaperlessModel, PaperlessPost
-from .shared import CustomFieldType
+
+
+class CustomFieldType(Enum):
+    """Enum with custom field types."""
+
+    STRING = "string"
+    BOOLEAN = "boolean"
+    INTEGER = "integer"
+    FLOAT = "float"
+    MONETARY = "monetary"
+    DATE = "date"
+    URL = "url"
+    DOCUMENT_LINK = "documentlink"
+    UNKNOWN = "unknown"
+
+    @classmethod
+    def _missing_(cls: type, value: object) -> "CustomFieldType":  # noqa ARG003
+        """Set default member on unknown value."""
+        return CustomFieldType.UNKNOWN
 
 
 @dataclass(kw_only=True)

{pypaperless-2.2.0 → pypaperless-2.3.0}/pypaperless/models/documents.py

@@ -80,7 +80,7 @@ class Document(PaperlessModel):  # pylint: disable=too-many-instance-attributes
 
 
 @dataclass(kw_only=True)
-class DocumentPost(PaperlessPost):
+class DocumentPost(PaperlessPost):  # pylint: disable=too-many-instance-attributes
     """Attributes to send when creating a document on the Paperless api."""
 
     document: bytes
@@ -88,5 +88,6 @@ class DocumentPost(PaperlessPost):
     created: datetime | None = None
     correspondent: int | None = None
     document_type: int | None = None
+    storage_path: int | None = None
     tags: list[int] | None = None
     archive_serial_number: int | None = None

pypaperless-2.2.0/pypaperless/models/mail_rules.py → pypaperless-2.3.0/pypaperless/models/mails.py

@@ -1,10 +1,27 @@
-"""Model for mail rule resource."""
+"""Model for mail resources."""
 
 from dataclasses import dataclass
 
 from .base import PaperlessModel
 
 
+@dataclass(kw_only=True)
+class MailAccount(PaperlessModel):  # pylint: disable=too-many-instance-attributes
+    """Represent a mail account resource on the Paperless api."""
+
+    id: int | None = None
+    name: str | None = None
+    imap_server: str | None = None
+    imap_port: int | None = None
+    imap_security: int | None = None
+    username: str | None = None
+    password: str | None = None
+    character_set: str | None = None
+    is_token: bool | None = None
+    owner: int | None = None
+    user_can_change: bool | None = None
+
+
 @dataclass(kw_only=True)
 class MailRule(PaperlessModel):  # pylint: disable=too-many-instance-attributes
     """Represent a mail rule resource on the Paperless api."""