review-request 0.1.0__tar.gz

review_request-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 King Kong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

review_request-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: review-request
+Version: 0.1.0
+Summary: Slack and GitHub integration for automating code review requests
+Author: King Kong
+License: MIT License
+        
+        Copyright (c) 2026 King Kong
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: slack-sdk
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Requires-Dist: validators
+Requires-Dist: pydantic-settings
+Requires-Dist: python-multipart
+Requires-Dist: aiohttp
+Requires-Dist: pydantic
+Requires-Dist: cachetools
+Requires-Dist: pytz
+Requires-Dist: tenacity
+Requires-Dist: rollbar
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file

review_request-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "review-request"
+version = "0.1.0"
+description = "Slack and GitHub integration for automating code review requests"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.11"
+authors = [{ name = "King Kong" }]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "fastapi",
+    "uvicorn",
+    "slack-sdk",
+    "python-dotenv",
+    "requests",
+    "validators",
+    "pydantic-settings",
+    "python-multipart",
+    "aiohttp",
+    "pydantic",
+    "cachetools",
+    "pytz",
+    "tenacity",
+    "rollbar",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-cov",
+    "pytest-asyncio",
+    "black",
+    "ruff",
+    "mypy",
+]
+
+[project.scripts]
+pr-reminder = "review_request.scripts.pr_reminder:run"
+jira-overdue-reminder = "review_request.scripts.jira_overdue_reminder:run"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = "-v --strict-markers --cov=review_request --cov-report=term-missing"
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+]
+
+[tool.black]
+line-length = 88
+target-version = ["py311"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+ignore_missing_imports = true

review_request-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

review_request-0.1.0/src/review_request/__init__.py

@@ -0,0 +1,3 @@
+"""review-request: Slack and GitHub integration for automating code review requests."""
+
+__version__ = "0.1.0"

review_request-0.1.0/src/review_request/api/jira_sprint.py

@@ -0,0 +1,178 @@
+"""API endpoints for Jira sprint webhooks."""
+
+import logging
+from fastapi import APIRouter, Request, HTTPException
+from fastapi.responses import JSONResponse
+
+from review_request.serializers.jira_sprint_webhook import (
+    JiraSprintWebhook,
+    SprintNotificationRequest,
+)
+from review_request.services.jira_sprint_notification_service import (
+    JiraSprintNotificationService,
+    SprintNotificationError,
+)
+from review_request.config.settings import settings
+from review_request.services.rollbar_service import RollbarService
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.post("/webhook")
+async def jira_sprint_webhook(
+    request: Request,
+    channel_id: str,
+) -> JSONResponse:
+    try:
+        webhook_data = await request.json()
+        webhook_event = webhook_data.get("webhookEvent", "")
+
+        logger.info(f"Received Jira webhook: {webhook_event}")
+
+        if webhook_event != "sprint_closed":
+            logger.info(f"Ignoring non-sprint-closed event: {webhook_event}")
+            return JSONResponse(
+                status_code=200,
+                content={
+                    "status": "ignored",
+                    "message": f"Event type '{webhook_event}' is not processed",
+                },
+            )
+
+        try:
+            validated_webhook = JiraSprintWebhook(**webhook_data)
+        except Exception as validation_error:
+            logger.error(f"Webhook validation failed: {validation_error}")
+            RollbarService.report_error(
+                exc=validation_error,
+                request=request,
+                extra_data={
+                    "operation": "webhook_validation",
+                    "webhook_event": webhook_event,
+                },
+                level="warning",
+            )
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid webhook payload: {str(validation_error)}",
+            )
+
+        sprint = validated_webhook.sprint
+
+        logger.info(
+            f"Processing sprint completion: {sprint.name} (State: {sprint.state})"
+        )
+
+        service = JiraSprintNotificationService(slack_token=settings.bot_token)
+
+        result = await service.process_webhook(
+            channel_id=channel_id,
+            webhook_data=webhook_data,
+        )
+
+        return JSONResponse(
+            status_code=200,
+            content={
+                "status": "success",
+                "message": "Sprint completion notification sent",
+                "sprint_name": sprint.name,
+                "channel_id": channel_id,
+                "slack_response": result,
+            },
+        )
+
+    except SprintNotificationError as e:
+        logger.error(f"Sprint notification error: {str(e)}")
+
+        RollbarService.report_error(
+            exc=e,
+            request=request,
+            extra_data={
+                "operation": "sprint_webhook",
+                "channel_id": channel_id,
+            },
+        )
+
+        raise HTTPException(
+            status_code=500, detail=f"Failed to send notification: {str(e)}"
+        )
+
+    except Exception as e:
+        logger.error(f"Unexpected error in sprint webhook: {str(e)}", exc_info=True)
+
+        RollbarService.report_error(
+            exc=e,
+            request=request,
+            extra_data={
+                "operation": "sprint_webhook",
+                "channel_id": channel_id,
+            },
+        )
+
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
+@router.post("/notify")
+async def send_sprint_notification(
+    request: Request,
+    notification_request: SprintNotificationRequest,
+) -> JSONResponse:
+    try:
+        logger.info(
+            f"Manual sprint notification requested for: "
+            f"{notification_request.sprint_name}"
+        )
+
+        service = JiraSprintNotificationService(slack_token=settings.bot_token)
+
+        result = await service.send_notification(
+            channel_id=notification_request.channel_id,
+            sprint_name=notification_request.sprint_name,
+            start_date=notification_request.start_date,
+            end_date=notification_request.end_date,
+            completed_by=notification_request.completed_by,
+        )
+
+        return JSONResponse(
+            status_code=200,
+            content={
+                "status": "success",
+                "message": "Sprint notification sent successfully",
+                "sprint_name": notification_request.sprint_name,
+                "channel_id": notification_request.channel_id,
+                "slack_response": result,
+            },
+        )
+
+    except SprintNotificationError as e:
+        logger.error(f"Failed to send manual notification: {str(e)}")
+
+        RollbarService.report_error(
+            exc=e,
+            request=request,
+            extra_data={
+                "operation": "manual_sprint_notification",
+                "sprint_name": notification_request.sprint_name,
+            },
+        )
+
+        raise HTTPException(
+            status_code=500, detail=f"Failed to send notification: {str(e)}"
+        )
+
+    except Exception as e:
+        logger.error(
+            f"Unexpected error in manual notification: {str(e)}", exc_info=True
+        )
+
+        RollbarService.report_error(
+            exc=e,
+            request=request,
+            extra_data={
+                "operation": "manual_sprint_notification",
+                "sprint_name": notification_request.sprint_name,
+            },
+        )
+
+        raise HTTPException(status_code=500, detail="Internal server error")

review_request-0.1.0/src/review_request/api/message.py

@@ -0,0 +1,94 @@
+from fastapi import APIRouter, Form, Request
+from review_request.services.send_message import SendMessage
+from review_request.serializers.conversation_response import ConversationResponse
+from review_request.services.rollbar_service import RollbarService
+from fastapi.responses import JSONResponse
+from typing import Union
+import logging
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.post("/", response_model=ConversationResponse)
+async def conversation(
+    request: Request,
+    token: str = Form(...),
+    team_id: str = Form(...),
+    team_domain: str = Form(...),
+    channel_id: str = Form(...),
+    channel_name: str = Form(...),
+    user_id: str = Form(...),
+    user_name: str = Form(...),
+    command: str = Form(...),
+    text: str = Form(...),
+    response_url: str = Form(...),
+    trigger_id: str = Form(...),
+) -> Union[ConversationResponse, JSONResponse]:
+    try:
+        RollbarService.add_person_data(user_id=user_id, username=user_name)
+        RollbarService.add_custom_data("team_id", team_id)
+        RollbarService.add_custom_data("channel_id", channel_id)
+        RollbarService.add_custom_data("command", command)
+
+        logger.info(
+            f"Processing request from user {user_id} ({user_name}) in channel {channel_name}"
+        )
+
+        message_service = SendMessage(user_id, text, channel_id)
+        await message_service.send()
+
+        logger.info(f"Successfully processed request from user {user_id}")
+
+        return ConversationResponse(
+            response_type="ephemeral",
+            text=":white_check_mark: Your request has been submitted successfully.",
+        )
+    except ValueError as e:
+        logger.warning(f"Validation error for user {user_id}: {str(e)}")
+
+        RollbarService.report_error(
+            exc=e,
+            request=request,
+            extra_data={
+                "user_id": user_id,
+                "user_name": user_name,
+                "channel_name": channel_name,
+                "error_type": "validation_error",
+            },
+            level="warning",
+        )
+
+        return JSONResponse(
+            status_code=200,
+            content=ConversationResponse(
+                response_type="ephemeral", text=":alert: " + str(e)
+            ).model_dump(),
+        )
+    except Exception as e:
+        logger.error(
+            f"Unexpected error processing request from user {user_id}: {str(e)}",
+            exc_info=True,
+        )
+
+        RollbarService.report_error(
+            exc=e,
+            request=request,
+            extra_data={
+                "user_id": user_id,
+                "user_name": user_name,
+                "channel_name": channel_name,
+                "error_type": "unexpected_error",
+            },
+        )
+
+        return JSONResponse(
+            status_code=200,
+            content=ConversationResponse(
+                response_type="ephemeral",
+                text=":alert: An unexpected error occurred. Please try again.",
+            ).model_dump(),
+        )
+    finally:
+        RollbarService.clear_person_data()
+        RollbarService.clear_custom_data()

review_request-0.1.0/src/review_request/config/settings.py

@@ -0,0 +1,101 @@
+from pydantic_settings import BaseSettings
+from dotenv import load_dotenv
+from typing import Dict, List, Any
+
+load_dotenv()
+
+
+class Settings(BaseSettings):
+    github_token: str = ""
+    bot_token: str = ""
+    channel_id: str = ""
+    slack_signing_secret: str = ""
+    rollbar_access_token: str = ""
+    environment: str = "development"
+    max_age_pr_days: int = 60
+    app_url: str = ""
+    jira_site: str = ""
+    jira_email: str = ""
+    jira_api_token: str = ""
+
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()
+
+SLACK_TEAM_MAPPINGS: Dict[str, str] = {
+    "@ai-hero-bot": "S0AQB912TSQ",
+    "@engineering-managers": "S05FPFUQKK6",
+    "@squad-yoshi": "S04FX4MPVHU",
+    "@hr-integrations": "S06ENMV00FJ",
+    "@squad-bounty-hunters": "S04SB339XED",
+    "@talent-seniors": "S085MRPUE5A",
+    "@squad-night-s-watch": "SQ0LZDLBY",
+    "@pre-payroll": "S03MB6L10AU",
+    "@core-security": "S063WTUH4J2",
+    "@QA team": "S0841B04Q68",
+    "@squad-ai-implementation-ml": "S08SJ45EP9V",
+    "@squad-eternals-ml": "S07F62YVB8S",
+    "@squad-alchemist-ml": "S089EMP46GM",
+    "@core-tech": "S063WTUH4J2",
+    "@hr-corepayroll": "S06ENMV00FJ",
+    "@squad-maplemoney": "S0AHBRANQQM",
+    "@squad-wasabi": "S092KN5DQLC",
+}
+
+GITHUB_REPOSITORIES: List[Dict[str, Any]] = [
+    {
+        "url": "https://github.com/Thinkei/ats",
+        "base_branch": "master",
+    },
+    {
+        "url": "https://github.com/Thinkei/employment-hero",
+        "base_branch": "master",
+    },
+    {
+        "url": "https://github.com/Thinkei/frontend-core",
+        "base_branch": "master",
+    },
+    {
+        "url": "https://github.com/Thinkei/career-page",
+        "base_branch": "master",
+    },
+    {
+        "url": "https://github.com/Thinkei/smart-match",
+        "base_branch": "main",
+    },
+]
+
+GITHUB_TEAM_REMINDER_MAPPING: List[Dict[str, Any]] = [
+    {
+        "channel_id": "C066UGGS2PJ",
+        "slack_group_id": "S06DU7PTYLW",
+        "github_team": "squad-eternals",
+        "max_age_pr_days": settings.max_age_pr_days,
+        "remind_date": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+    },
+    {
+        "channel_id": "C09Q56D8VGX",
+        "slack_group_id": "S01T1977RBK",
+        "github_team": "squad-helios",
+        "max_age_pr_days": settings.max_age_pr_days,
+        "remind_date": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+    },
+    {
+        "channel_id": "C07EU03AEEL",
+        "slack_group_id": "S07EBNZ4PRB",
+        "github_team": "squad-alchemist",
+        "max_age_pr_days": settings.max_age_pr_days,
+        "remind_date": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+    },
+]
+
+JIRA_TEAM_REMINDER_MAPPING: List[Dict[str, Any]] = [
+    {
+        "channel_id": "C066UGGS2PJ",
+        "slack_group_id": "S06DU7PTYLW",
+        "jira_jql": 'project = ET AND statusCategory = "In Progress" AND duedate < now() ORDER BY duedate ASC',
+        "remind_date": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
+    },
+]

review_request-0.1.0/src/review_request/decorators/base_message_decorator.py

@@ -0,0 +1,34 @@
+"""Abstract base class for message decorators."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List
+import random
+from .message_formatters import MessageFormatter
+
+
+class BaseMessageDecorator(ABC):
+    """Abstract base class for message decorators."""
+
+    def __init__(self, review_message: Dict[str, Any]) -> None:
+        self.review_message = review_message
+        self.formatter = MessageFormatter()
+
+    @abstractmethod
+    def get_templates(self) -> List[str]:
+        pass
+
+    @abstractmethod
+    def get_template_placeholders(self) -> Dict[str, Any]:
+        pass
+
+    def _select_random_template(self) -> str:
+        templates = self.get_templates()
+        return random.choice(templates)
+
+    def _format_template(self, template: str) -> str:
+        placeholders = self.get_template_placeholders()
+        return template.format(**placeholders)
+
+    def message(self) -> str:
+        selected_template = self._select_random_template()
+        return self._format_template(selected_template)

review_request-0.1.0/src/review_request/decorators/jira_overdue_message.py

@@ -0,0 +1,110 @@
+"""Jira Overdue Message Decorator."""
+
+from typing import Dict, Any, List
+from .base_message_decorator import BaseMessageDecorator
+
+
+class JiraOverdueMessageDecorator(BaseMessageDecorator):
+    """Decorator for generating Jira overdue reminder intro messages."""
+
+    def __init__(self, team_config: Dict[str, Any]) -> None:
+        self.team_config = team_config
+        self.slack_group_id = team_config.get("slack_group_id", "")
+        self.total_issues = team_config.get("total_issues", 0)
+        super().__init__({"type": "jira_overdue"})
+
+    def get_templates(self) -> List[str]:
+        return [
+            (
+                "Hey {team_mention} 👋\n"
+                "⏰ {total} Jira issues are past their due date…\n"
+                "Before they start a support group, let's move them forward."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🧟 {total} overdue issues shambling in 'In Progress'…\n"
+                "Only your action can lay them to rest."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🐢 {total} tasks moving slower than Monday mornings…\n"
+                "A tiny push today saves a big panic tomorrow."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🧀 {total} aging like cheese… and not the fancy kind.\n"
+                "Change the status before it gets… aromatic."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🚨 {total} overdue issues pinging the timeline radar\n"
+                "Let's clear the airspace."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "📦 {total} stories waiting in the delivery truck…\n"
+                "A quick update and they're on the road."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🕰️ {total} tickets time-traveled past their due date…\n"
+                "Send them back to the present with an update."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🔥 {total} smoldering tasks in 'In Progress'…\n"
+                "A quick status douses the flames."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🧩 {total} pieces waiting to click into Done…\n"
+                "One move from you completes the puzzle."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🌧️ {total} clouds hanging over the sprint…\n"
+                "Mark some sunshine with a status change."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "📣 {total} issues calling from the backlog hotline…\n"
+                "They'd like to speak to a human."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🛰️ {total} signals from overdue orbit…\n"
+                "Bring them back to Earth with an update."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🏃 {total} tasks stuck at mile 25…\n"
+                "A tiny push gets them over the finish line."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🔧 {total} work-in-progress needing a quick tune-up…\n"
+                "Tighten a bolt, change a status, done."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "📅 {total} dates came and went…\n"
+                "Let's not let the sprint retrospective do all the talking."
+            ),
+            (
+                "Hey {team_mention} 👋\n"
+                "🧭 {total} tasks looking for direction…\n"
+                "Point them to Done with a quick update."
+            ),
+        ]
+
+    def get_template_placeholders(self) -> Dict[str, Any]:
+        return {
+            "team_mention": self._format_team_mention(),
+            "total": f"*{self.total_issues}*",
+        }
+
+    def _format_team_mention(self) -> str:
+        return f"<!subteam^{self.slack_group_id}>!" if self.slack_group_id else "team"
+
+    def build_intro(self) -> str:
+        return self.message()