141 lines
4.3 KiB
Python
141 lines
4.3 KiB
Python
#!/usr/bin/env python
|
|
import asyncio
|
|
import email.policy
|
|
import importlib.util
|
|
import logging
|
|
import os
|
|
import ssl
|
|
from dataclasses import dataclass
|
|
from email.message import EmailMessage
|
|
from imaplib import IMAP4
|
|
from logging import debug
|
|
from logging import error
|
|
from logging import info
|
|
from logging import warning
|
|
from os import getenv
|
|
from pprint import pprint
|
|
from typing import cast
|
|
|
|
from model import Transaction
|
|
from parsers import TransactionParsingFailed
|
|
|
|
|
|
CONFIG_PATH = getenv("CONFIG_PATH", "/data/config.py")
|
|
ACTUAL_PATH = "./cli.js"
|
|
TIMEOUT = 30
|
|
|
|
|
|
async def ticker(interval: float):
|
|
while True:
|
|
yield
|
|
await asyncio.sleep(interval)
|
|
|
|
|
|
def load_config_module(path: str):
|
|
spec = importlib.util.spec_from_file_location("config", path)
|
|
config = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(config)
|
|
return config
|
|
|
|
|
|
@dataclass
|
|
class AppConfig:
|
|
@staticmethod
|
|
def from_environ() -> "AppConfig":
|
|
return AppConfig(
|
|
imap_server=getenv("IMAP_SERVER"),
|
|
imap_port=int(getenv("IMAP_PORT", 143)),
|
|
imap_user=getenv("IMAP_USER"),
|
|
imap_pass=getenv("IMAP_PASS"),
|
|
imap_mailbox=getenv("IMAP_MAILBOX", "INBOX"),
|
|
imap_interval=float(getenv("IMAP_INTERVAL", 300)),
|
|
imap_starttls=bool(getenv("IMAP_STARTTLS", True)),
|
|
)
|
|
|
|
imap_server: str
|
|
imap_user: str
|
|
imap_pass: str
|
|
imap_port: int = 143
|
|
imap_mailbox: str = "INBOX"
|
|
imap_interval: int = 300
|
|
imap_starttls: bool = True
|
|
|
|
|
|
class App:
|
|
def __init__(self, app_config: AppConfig, parser_config_path: str):
|
|
config_mod = load_config_module(parser_config_path)
|
|
self._parsers = config_mod.PARSERS
|
|
self._config = app_config
|
|
|
|
async def submit_transaction(self, t: Transaction):
|
|
cmd = (
|
|
ACTUAL_PATH
|
|
+ f' -a "{t.account}"'
|
|
+ f' -p "{t.payee}"'
|
|
+ f' -m "{t.amount}"'
|
|
+ f' -d "{t.date}"'
|
|
f' -n "{t.notes}"'
|
|
)
|
|
debug("Actual command: %s", cmd)
|
|
proc = await asyncio.create_subprocess_shell(
|
|
cmd=cmd,
|
|
env=os.environ,
|
|
stderr=asyncio.subprocess.STDOUT,
|
|
stdout=asyncio.subprocess.PIPE,
|
|
)
|
|
stdout, stderr = await proc.communicate()
|
|
if proc.returncode != 0:
|
|
error("Submitting to actual failed: %s", stdout)
|
|
|
|
async def process_message(self, msg_b: bytes):
|
|
debug("parsing message")
|
|
msg = cast(
|
|
EmailMessage, email.message_from_bytes(msg_b, policy=email.policy.default)
|
|
)
|
|
pprint(msg)
|
|
info(
|
|
"Found message from %s to %s subject %s",
|
|
msg.get("From", "<unknown>"),
|
|
msg.get("To", "<unknown>"),
|
|
msg.get("Subject", "<no subject>"),
|
|
)
|
|
|
|
for parser in self._parsers:
|
|
debug("Running parser %s", type(parser).__name__)
|
|
try:
|
|
if parser.match(msg):
|
|
info("Parser %s claimed message", type(parser).__name__)
|
|
trans = parser.extract(msg)
|
|
info("Submitting transaction to Actual: %s", trans)
|
|
await self.submit_transaction(trans)
|
|
except TransactionParsingFailed as e:
|
|
warning("Unable to parse message %s", e)
|
|
except Exception as e:
|
|
warning("Unexpected exception %s", e)
|
|
|
|
async def poll_imap(self):
|
|
info("polling mailbox")
|
|
with IMAP4(self._config.imap_server, self._config.imap_port, TIMEOUT) as M:
|
|
if self._config.imap_starttls:
|
|
context = ssl.create_default_context()
|
|
M.starttls(context)
|
|
M.login(self._config.imap_user, self._config.imap_pass)
|
|
M.select(self._config.imap_mailbox)
|
|
status, m_set = M.search(None, "UNSEEN")
|
|
|
|
for msg_id in m_set[0].split():
|
|
debug("Retrieving msg id %s", msg_id)
|
|
status, msg = M.fetch(msg_id, "(RFC822)")
|
|
await self.process_message(msg[0][1])
|
|
|
|
async def run(self):
|
|
async for tick in ticker(self._config.imap_interval):
|
|
await self.poll_imap()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
logging.basicConfig(level=getenv("LOG_LEVEL", "INFO"))
|
|
app_config = AppConfig.from_environ()
|
|
app = App(app_config, CONFIG_PATH)
|
|
asyncio.run(app.run())
|