Initial plan

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/renovate.json

@@ -1,5 +1,6 @@
 {
     "extends": [
-        "config:base"
+        "config:base",
+        "github>nikdoof/renovate-config:python"
     ]
 }

.github/workflows/build-container.yaml

@@ -12,11 +12,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
       - name: Login to GHCR
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         if: github.event_name != 'pull_request'
         with:
           registry: ghcr.io
@@ -24,7 +24,7 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and push
         id: docker_build
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v6
         with:
           push: true
           tags: |

.github/workflows/lint.yaml

@@ -1,6 +1,6 @@
 name: Lint
 
-'on':
+"on":
   push:
     branches:
       - main
@@ -9,13 +9,26 @@ name: Lint
       - main
 
 jobs:
-  run-linters:
-    name: Run linters
+  lint:
     runs-on: ubuntu-latest
-
+    strategy:
+      matrix:
+        python-version: ["3.9"]
     steps:
-      - name: Check out Git repository
-        uses: actions/checkout@v3
-
-      - name: wemake-python-styleguide
-        uses: wemake-services/wemake-python-styleguide@0.16.1
+      - uses: actions/checkout@v4
+      - name: Install Task
+        uses: arduino/setup-task@v2
+        with:
+          version: 3.x
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          virtualenvs-create: true
+          virtualenvs-in-project: true
+      - name: Lint with ruff
+        run: |
+          task python:lint

.github/workflows/release-chart.yaml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -21,12 +21,12 @@ jobs:
           git config user.name "$GITHUB_ACTOR"
           git config user.email "$GITHUB_ACTOR@users.noreply.github.com"
       - name: Install Helm
-        uses: azure/setup-helm@v1
+        uses: azure/setup-helm@v4
         with:
           version: v3.6.3
 
       - name: Run chart-releaser
-        uses: helm/chart-releaser-action@v1.2.1
+        uses: helm/chart-releaser-action@v1.7.0
         env:
           CR_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
           CR_RELEASE_NAME_TEMPLATE: "smsbot-helm-chart-{{ .Version }}"

.github/workflows/release.yaml

@@ -1,4 +1,3 @@
----
 name: Release
 on:
   push:
@@ -10,18 +9,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - uses: actions/setup-python@v4
-      - run: pip install -r requirements-dev.txt
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
 
-      - name: Build Assets
-        run: python setup.py sdist bdist_wheel
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          virtualenvs-create: true
+          virtualenvs-in-project: true
+
+      - name: Build Release
+        run: poetry build
 
       - name: Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           name: "Version ${{ github.ref_name }}"
-          generate_release_notes: true
           files: |
-            dist/*
+            dist/*

Dockerfile

@@ -1,5 +1,21 @@
-FROM python:3.10-alpine
-WORKDIR /app
-COPY . /app
-RUN pip install .
-ENTRYPOINT smsbot
+FROM python:3.9-alpine AS base
+
+# Builder
+FROM base AS builder
+
+ENV POETRY_VERSION=2.1.1
+
+RUN apk add build-base unzip wget python3-dev libffi-dev rust cargo openssl-dev && pip install "poetry==$POETRY_VERSION" && poetry self add poetry-plugin-bundle
+WORKDIR /src
+COPY poetry.lock pyproject.toml README.md /src/
+COPY smsbot /src/smsbot
+RUN poetry bundle venv /runtime
+
+
+# Final container
+FROM base AS runtime
+
+COPY --from=builder /runtime /runtime
+ENV PATH=/runtime/bin:$PATH
+EXPOSE 80/tcp
+CMD ["smsbot"]

README.md

@@ -22,3 +22,16 @@ All configuration is provided via environment variables
 | SMSBOT_OWNER_ID            | No        | ID of the owner of this bot                                                 |
 | SMSBOT_TELEGRAM_BOT_TOKEN  | Yes       | Your Bot Token for Telegram                                                 |
 | SMSBOT_TWILIO_AUTH_TOKEN   | No        | Twilio auth token, used to validate any incoming webhook calls              |
+
+## Setup
+
+To configure SMSBot, you'll need a Twilio account, either paid or trial is fine. 
+
+* Setup a number in the location you want.
+* Under Phone Numbers -> Manage -> Active Numbers, click the number you want to setup.
+* In the "Voice & Fax" section, update the "A Call Comes In" to the URL of your SMSBot instance, with the endpoint being `/call`, e.g. `http://mymachine.test.com/call`
+* In the "Messaging" section, update the "A Message Comes In" to the URL of your SMSBot instance, with the endpoint being `/message`, e.g. `http://mymachine.test.com/message`
+
+Your bot should now receive messages, on Telegram you need to start a chat or invite it into any channels you want, then update the `SMSBOT_DEFAULT_SUBSCRIBERS` values with their IDs.
+
+**Note**: You cannot send test messages from your Twilio account to your Twilio numbers, they'll be silently dropped or fail with an "Invalid Number" error.

Taskfile.yaml

@@ -0,0 +1,17 @@
+version: 3
+tasks:
+  python:env:
+    cmds:
+      - poetry install --with=dev,github
+  python:lint:
+    desc: Lint Python files
+    deps:
+      - python:env
+    cmds:
+      - poetry run ruff check --output-format=github --select=E9,F63,F7,F82 --target-version=py39 .
+      - poetry run ruff check --output-format=github --target-version=py39 .
+
+  docker:build:
+    desc: Build the container using Docker
+    cmds:
+      - docker build . -t smsbot:latest

charts/smsbot/Chart.yaml

@@ -1,8 +1,8 @@
 apiVersion: v2
-appVersion: 0.0.3
+appVersion: 0.0.5
 description: A simple Telegram bot to receive SMS messages.
 name: smsbot
-version: 0.0.3
+version: 0.0.6
 kubeVersion: ">=1.19.0-0"
 keywords:
 - smsbot
@@ -15,4 +15,4 @@ maintainers:
 dependencies:
 - name: common
   repository: https://library-charts.k8s-at-home.com
-  version: 4.3.0
+  version: 4.5.2

charts/smsbot/values.yaml

@@ -11,7 +11,7 @@ image:
   # -- image pull policy
   pullPolicy: IfNotPresent
   # -- image tag
-  tag: 0.0.3
+  tag: 0.0.5
 
 # -- environment variables.
 # @default -- See below

pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "smsbot"
+version = "0.0.6"
+description = "A simple Telegram bot to receive SMS messages."
+authors = [{ name = "Andrew Williams", email = "andy@tensixtyone.com" }]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.9,<3.10"
+dependencies = [
+    "flask (>=3.1.0,<4.0.0)",
+    "waitress (>=3.0.2,<4.0.0)",
+    "twilio (>=9.4.6,<10.0.0)",
+    "python-telegram-bot (<20)",
+    "prometheus-client (>=0.21.1,<0.22.0)",
+]
+
+[tool.poetry]
+packages = [{ include = "smsbot" }]
+
+[tool.poetry.scripts]
+smsbot = "smsbot.cli:main"
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+ruff = "^0.12.0"
+pytest-mock = "^3.12.0"
+pytest-flask = "^1.3.0"
+
+[tool.poetry.group.github]
+optional = true
+
+[tool.poetry.group.github.dependencies]
+pytest-github-actions-annotate-failures = "^0.3.0"

requirements.txt

@@ -1,4 +0,0 @@
-flask
-waitress
-twilio
-python-telegram-bot

setup.cfg

@@ -1,35 +0,0 @@
-[metadata]
-name = smsbot
-version = 0.0.3
-description = A simple Telegram bot to receive SMS messages.
-long_description = file: README.md, LICENSE
-license = MIT
-license_file = LICENSE
-classifiers =
-    Framework :: Flask
-    License :: OSI Approved :: MIT License
-    Programming Language :: Python :: 3
-    Programming Language :: Python :: 3.9
-
-[options]
-zip_safe = False
-include_package_data = True
-packages = smsbot
-install_requires =
-    flask
-    waitress
-    twilio
-    python-telegram-bot
-
-[options.entry_points]
-console_scripts =
-        smsbot = smsbot.cli:main
-
-[flake8]
-format = wemake
-ignore = D,E501,WPS432,WPS323,WPS2,S104,WPS412,WPS100
-max-line-length = 120
-exclude = setup.py,env,build
-
-[darglint]
-docstring_style=sphinx

setup.py

@@ -1,3 +0,0 @@
-from setuptools import setup
-
-setup()

smsbot/__main__.py

@@ -1,4 +1,4 @@
 from smsbot.cli import main
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

smsbot/cli.py

@@ -1,37 +1,47 @@
+import argparse
 import logging
 import os
-import sys
-
-import pkg_resources
 
 from smsbot.telegram import TelegramSmsBot
+from smsbot.utils import get_smsbot_version
 from smsbot.webhook_handler import TwilioWebhookHandler
 
-pkg_version = pkg_resources.require('smsbot')[0].version
-
 
 def main():
-    logging.basicConfig(level=logging.INFO)
-    logging.info('smsbot v%s', pkg_version)
+    parser = argparse.ArgumentParser("smsbot")
+    parser.add_argument(
+        "--listen-host", default=os.environ.get("SMSBOT_LISTEN_HOST") or "0.0.0.0"
+    )
+    parser.add_argument(
+        "--listen-port", default=os.environ.get("SMSBOT_LISTEN_PORT") or "80"
+    )
+    parser.add_argument(
+        "--telegram-bot-token", default=os.environ.get("SMSBOT_TELEGRAM_BOT_TOKEN")
+    )
+    parser.add_argument("--owner-id", default=os.environ.get("SMSBOT_OWNER_ID"))
+    parser.add_argument(
+        "--default-subscribers", default=os.environ.get("SMSBOT_DEFAULT_SUBSCRIBERS")
+    )
+    parser.add_argument("--log-level", default="INFO")
+    args = parser.parse_args()
 
-    listen_host = os.environ.get('SMSBOT_LISTEN_HOST') or '0.0.0.0'
-    listen_port = int(os.environ.get('SMSBOT_LISTEN_PORT') or '80')
-
-    token = os.environ.get('SMSBOT_TELEGRAM_BOT_TOKEN')
-    if not token:
-        logging.error('Telegram Bot token missing')
-        sys.exit(1)
+    # TODO: Replace for Py >=3.11
+    logging.basicConfig(level=logging.getLevelName(args.log_level))
+    logging.info("smsbot v%s", get_smsbot_version())
+    logging.debug("Arguments: %s", args)
 
     # Start bot
-    telegram_bot = TelegramSmsBot(token)
+    telegram_bot = TelegramSmsBot(args.telegram_bot_token)
 
     # Set the owner ID if configured
-    if 'SMSBOT_OWNER_ID' in os.environ:
-        telegram_bot.set_owner(os.environ.get('SMSBOT_OWNER_ID'))
+    if args.owner_id:
+        telegram_bot.set_owner(args.owner_id)
+    else:
+        logging.warning("No Owner ID is set, which is not a good idea...")
 
     # Add default subscribers
-    if 'SMSBOT_DEFAULT_SUBSCRIBERS' in os.environ:
-        for chat_id in os.environ.get('SMSBOT_DEFAULT_SUBSCRIBERS').split(','):
+    if args.default_subscribers:
+        for chat_id in args.default_subscribers.split(","):
             telegram_bot.add_subscriber(chat_id)
 
     telegram_bot.start()
@@ -39,4 +49,4 @@ def main():
     # Start webhooks
     webhooks = TwilioWebhookHandler()
     webhooks.set_bot(telegram_bot)
-    webhooks.serve(host=listen_host, port=listen_port)
+    webhooks.serve(host=args.listen_host, port=args.listen_port)

smsbot/telegram.py

@@ -1,63 +1,102 @@
 import logging
 
+from prometheus_client import Counter, Summary
 from telegram.ext import CommandHandler, Updater
 
 from smsbot.utils import get_smsbot_version
 
+REQUEST_TIME = Summary(
+    "telegram_request_processing_seconds", "Time spent processing request"
+)
+COMMAND_COUNT = Counter("telegram_command_count", "Total number of commands processed")
+
 
 class TelegramSmsBot(object):
-
-    def __init__(self, token, owner=None, subscribers=None):
+    def __init__(
+        self, telegram_token, allow_subscribing=False, owner=None, subscribers=None
+    ):
         self.logger = logging.getLogger(self.__class__.__name__)
-        self.bot_token = token
-        self.owner_id = owner
+        self.bot_token = telegram_token
         self.subscriber_ids = subscribers or []
+        self.set_owner(owner)
 
-    def start(self):
-        self.logger.info('Starting bot...')
         self.updater = Updater(self.bot_token, use_context=True)
-        self.updater.dispatcher.add_handler(CommandHandler('help', self.help_handler))
-        self.updater.dispatcher.add_handler(CommandHandler('start', self.help_handler))
-        self.updater.dispatcher.add_handler(CommandHandler('subscribe', self.subscribe_handler))
-        self.updater.dispatcher.add_handler(CommandHandler('unsubscribe', self.unsubscribe_handler))
+        self.updater.dispatcher.add_handler(CommandHandler("help", self.help_handler))
+        self.updater.dispatcher.add_handler(CommandHandler("start", self.help_handler))
+
+        if allow_subscribing:
+            self.updater.dispatcher.add_handler(
+                CommandHandler("subscribe", self.subscribe_handler)
+            )
+            self.updater.dispatcher.add_handler(
+                CommandHandler("unsubscribe", self.unsubscribe_handler)
+            )
+
         self.updater.dispatcher.add_error_handler(self.error_handler)
 
+    def start(self):
+        self.logger.info("Starting bot...")
         self.updater.start_polling()
         self.bot = self.updater.bot
-        self.logger.info('Bot Ready')
+        self.logger.info("Bot Ready")
 
     def stop(self):
         self.updater.stop()
 
+    @REQUEST_TIME.time()
     def help_handler(self, update, context):
         """Send a message when the command /help is issued."""
-        self.logger.info('/help command received in chat: %s', update.message.chat)
-        update.message.reply_markdown('Smsbot v{0}\n\n/help\n/subscribe\n/unsubscribe'.format(get_smsbot_version()))
+        self.logger.info("/help command received in chat: %s", update.message.chat)
 
+        commands = []
+        for command in self.updater.dispatcher.handlers[0]:
+            commands.extend(["/{0}".format(cmd) for cmd in command.command])
+
+        update.message.reply_markdown(
+            "Smsbot v{0}\n\n{1}".format(get_smsbot_version(), "\n".join(commands))
+        )
+        COMMAND_COUNT.inc()
+
+    @REQUEST_TIME.time()
     def subscribe_handler(self, update, context):
-        self.logger.info('/subscribe command received')
-        if update.message.chat['id'] not in self.subscriber_ids:
-            self.logger.info('{0} subscribed'.format(update.message.chat['username']))
-            self.subscriber_ids.append(update.message.chat['id'])
-            self.send_owner('{0} has subscribed'.format(update.message.chat['username']))
-            update.message.reply_markdown('You have been subscribed to SMS notifications')
+        self.logger.info("/subscribe command received")
+        if update.message.chat["id"] not in self.subscriber_ids:
+            self.logger.info("{0} subscribed".format(update.message.chat["username"]))
+            self.subscriber_ids.append(update.message.chat["id"])
+            self.send_owner(
+                "{0} has subscribed".format(update.message.chat["username"])
+            )
+            update.message.reply_markdown(
+                "You have been subscribed to SMS notifications"
+            )
         else:
-            update.message.reply_markdown('You are already subscribed to SMS notifications')
+            update.message.reply_markdown(
+                "You are already subscribed to SMS notifications"
+            )
+        COMMAND_COUNT.inc()
 
+    @REQUEST_TIME.time()
     def unsubscribe_handler(self, update, context):
-        self.logger.info('/unsubscribe command received')
-        if update.message.chat['id'] in self.subscriber_ids:
-            self.logger.info('{0} unsubscribed'.format(update.message.chat['username']))
-            self.subscriber_ids.remove(update.message.chat['id'])
-            self.send_owner('{0} has unsubscribed'.format(update.message.chat['username']))
-            update.message.reply_markdown('You have been unsubscribed to SMS notifications')
+        self.logger.info("/unsubscribe command received")
+        if update.message.chat["id"] in self.subscriber_ids:
+            self.logger.info("{0} unsubscribed".format(update.message.chat["username"]))
+            self.subscriber_ids.remove(update.message.chat["id"])
+            self.send_owner(
+                "{0} has unsubscribed".format(update.message.chat["username"])
+            )
+            update.message.reply_markdown(
+                "You have been unsubscribed to SMS notifications"
+            )
         else:
-            update.message.reply_markdown('You are not subscribed to SMS notifications')
+            update.message.reply_markdown("You are not subscribed to SMS notifications")
+        COMMAND_COUNT.inc()
 
     def error_handler(self, update, context):
         """Log Errors caused by Updates."""
         self.logger.warning('Update "%s" caused error "%s"', update, context.error)
-        self.send_owner('Update "%{0}" caused error "{1}"'.format(update, context.error))
+        self.send_owner(
+            'Update "%{0}" caused error "{1}"'.format(update, context.error)
+        )
 
     def send_message(self, message, chat_id):
         self.bot.sendMessage(text=message, chat_id=chat_id)
@@ -72,6 +111,8 @@ class TelegramSmsBot(object):
 
     def set_owner(self, chat_id):
         self.owner_id = chat_id
+        if self.owner_id and self.owner_id not in self.subscriber_ids:
+            self.subscriber_ids.append(self.owner_id)
 
     def add_subscriber(self, chat_id):
         self.subscriber_ids.append(chat_id)

smsbot/utils.py

@@ -1,5 +1,5 @@
-import pkg_resources
+from importlib.metadata import version
 
 
 def get_smsbot_version():
-    return pkg_resources.require('smsbot')[0].version
+    return version("smsbot")

smsbot/webhook_handler.py

@@ -1,23 +1,31 @@
-
 import os
 from functools import wraps
 
 from flask import Flask, abort, current_app, request
+from prometheus_client import Counter, Summary, make_wsgi_app
 from twilio.request_validator import RequestValidator
 from waitress import serve
+from werkzeug.middleware.dispatcher import DispatcherMiddleware
 
 from smsbot.utils import get_smsbot_version
 
+REQUEST_TIME = Summary("webhook_request_processing_seconds", "Time spent processing request")
+MESSAGE_COUNT = Counter("webhook_message_count", "Total number of messages processed")
+CALL_COUNT = Counter("webhook_call_count", "Total number of calls processed")
+
 
 def validate_twilio_request(func):
     """Validates that incoming requests genuinely originated from Twilio"""
+
     @wraps(func)
     def decorated_function(*args, **kwargs):  # noqa: WPS430
         # Create an instance of the RequestValidator class
-        twilio_token = os.environ.get('SMSBOT_TWILIO_AUTH_TOKEN')
+        twilio_token = os.environ.get("SMSBOT_TWILIO_AUTH_TOKEN")
 
         if not twilio_token:
-            current_app.logger.warning('Twilio request validation skipped due to SMSBOT_TWILIO_AUTH_TOKEN missing')
+            current_app.logger.warning(
+                "Twilio request validation skipped due to SMSBOT_TWILIO_AUTH_TOKEN missing"
+            )
             return func(*args, **kwargs)
 
         validator = RequestValidator(twilio_token)
@@ -27,7 +35,7 @@ def validate_twilio_request(func):
         request_valid = validator.validate(
             request.url,
             request.form,
-            request.headers.get('X-TWILIO-SIGNATURE', ''),
+            request.headers.get("X-TWILIO-SIGNATURE", ""),
         )
 
         # Continue processing the request if it's valid, return a 403 error if
@@ -35,44 +43,67 @@ def validate_twilio_request(func):
         if request_valid or current_app.debug:
             return func(*args, **kwargs)
         return abort(403)
+
     return decorated_function
 
 
 class TwilioWebhookHandler(object):
-
     def __init__(self):
         self.app = Flask(self.__class__.__name__)
-        self.app.add_url_rule('/', 'index', self.index, methods=['GET'])
-        self.app.add_url_rule('/health', 'health', self.health, methods=['GET'])
-        self.app.add_url_rule('/message', 'message', self.message, methods=['POST'])
-        self.app.add_url_rule('/call', 'call', self.call, methods=['POST'])
+        self.app.add_url_rule("/", "index", self.index, methods=["GET"])
+        self.app.add_url_rule("/health", "health", self.health, methods=["GET"])
+        self.app.add_url_rule("/message", "message", self.message, methods=["POST"])
+        self.app.add_url_rule("/call", "call", self.call, methods=["POST"])
+
+        # Add prometheus wsgi middleware to route /metrics requests
+        self.app.wsgi_app = DispatcherMiddleware(
+            self.app.wsgi_app,
+            {
+                "/metrics": make_wsgi_app(),
+            },
+        )
 
     def set_bot(self, bot):  # noqa: WPS615
         self.bot = bot
 
     def index(self):
-        return ''
+        return ""
 
+    @REQUEST_TIME.time()
     def health(self):
-        return '<h1>Smsbot v{0}</h1><p><b>Owner</b>: {1}</p><p><b>Subscribers</b>: {2}</p>'.format(get_smsbot_version(), self.bot.owner_id, self.bot.subscriber_ids)
+        return {
+            "version": get_smsbot_version(),
+            "owner": self.bot.owner_id,
+            "subscribers": self.bot.subscriber_ids,
+        }
 
+    @REQUEST_TIME.time()
     @validate_twilio_request
     def message(self):
-        current_app.logger.info('Received SMS from {From}: {Body}'.format(**request.values.to_dict()))
+        current_app.logger.info(
+            "Received SMS from {From}: {Body}".format(**request.values.to_dict())
+        )
 
-        message = 'From: {From}\n\n{Body}'.format(**request.values.to_dict())
+        message = "From: {From}\n\n{Body}".format(**request.values.to_dict())
         self.bot.send_subscribers(message)
 
         # Return a blank response
-        return '<response></response>'
+        MESSAGE_COUNT.inc()
+        return "<response></response>"
 
+    @REQUEST_TIME.time()
     @validate_twilio_request
     def call(self):
-        current_app.logger.info('Received Call from {From}'.format(**request.values.to_dict()))
-        self.bot.send_subscribers('Received Call from {From}, rejecting.'.format(**request.values.to_dict()))
+        current_app.logger.info(
+            "Received Call from {From}".format(**request.values.to_dict())
+        )
+        self.bot.send_subscribers(
+            "Received Call from {From}, rejecting.".format(**request.values.to_dict())
+        )
 
         # Always reject calls
-        return '<Response><Reject/></Response>'
+        CALL_COUNT.inc()
+        return "<Response><Reject/></Response>"
 
-    def serve(self, host='0.0.0.0', port=80, debug=False):
+    def serve(self, host="0.0.0.0", port=80, debug=False):
         serve(self.app, host=host, port=port)