feat/check-aws: feat: test and update aws connection within app (#11)

laszukdawid · web-flow · commit 9bb60dc76ee2 · 2025-10-14T02:43:05.000-07:00
* feat/check-aws: feat: test and update aws connection within app

* feat/check-aws: fix: address some comments
diff --git a/Makefile b/Makefile
@@ -1,5 +1,8 @@
+PYTHON = uv run python
+PIP = uv pip
+
 build:
-	python -m build
+	${PYTHON} -m build
 
 clean:
 	find cracker -name "*.pyc" -exec rm {} +
@@ -8,20 +11,20 @@ clean:
 	rm -r build dist  2> /dev/null || true
 
 format-code:
-	python -m isort cracker
-	python -m black cracker
+	${PYTHON} -m isort cracker
+	${PYTHON} -m black cracker
 
 upgrade:
-	pip install --upgrade pip setuptools
+	${PIP} install --upgrade pip setuptools
 
 install: upgrade
-	pip install -e .
+	${PIP} install -e .
 
 install-all: upgrade
-	pip install -e .[dev,build]
+	${PIP} install -e .[dev,build]
 
 publish:
-	python -m twine upload -r cracker dist/*
+	${PYTHON} -m twine upload -r cracker dist/*
 
 test:
-	python -m pytest -v
+	${PYTHON} -m pytest -v
diff --git a/cracker/__init__.py b/cracker/__init__.py
@@ -1 +1 @@
-__version__ = "0.8.1"
+__version__ = "0.9.0"
diff --git a/cracker/config/default.yaml b/cracker/config/default.yaml
@@ -6,7 +6,7 @@ cracker:
 speakers:
   polly:
     voice: Joanna
-    profile_name: polly
+    profile_name: default
 
   espeak:
     voice: English
diff --git a/cracker/cracker.py b/cracker/cracker.py
@@ -35,6 +35,8 @@ def __init__(self, app: QApplication):
         self.gui = MainWindow(self.config, speakers=self.SPEAKER)
         self.gui.speaker = self.speaker
         self.gui.player = self.player
+        # Pass speaker reference to config window
+        self.gui.config_window.speaker = self.speaker
 
         self.key_manager = KeyBoardManager(self.app)
 
diff --git a/cracker/cracker_gui.py b/cracker/cracker_gui.py
@@ -44,7 +44,7 @@ def __init__(self, config: Configuration, speakers: SpeakersType):
         self.speaker: Optional[AbstractSpeaker] = None
         self.player: Optional[QMediaPlayer] = None
 
-        self.config_window = ConfigWindow()
+        self.config_window = ConfigWindow(speaker=None)
 
     def init(self):
         self.set_action()
@@ -224,6 +224,8 @@ def change_speaker(self, speaker_name: str):
         self.config.speaker = speaker_name
         self.config.load_speaker_config(speaker_name)
         self.init_values()
+        # Update config window with new speaker reference
+        self.config_window.speaker = self.speaker
 
     def change_volume(self, volume):
         """Volume should be on a percentage scale"""
diff --git a/cracker/speaker/polly.py b/cracker/speaker/polly.py
@@ -1,9 +1,11 @@
+import logging
 import os
-from typing import List
+from typing import List, Optional
 
 import boto3
 from PyQt5.QtCore import QUrl
 from PyQt5.QtMultimedia import QMediaContent, QMediaPlaylist
+from PyQt5.QtWidgets import QMessageBox
 
 from cracker.config import Configuration
 from cracker.mp3_helper import create_filename, save_mp3
@@ -27,32 +29,116 @@ class Polly(AbstractSpeaker):
 
     def __init__(self, player):
         self._cached_ssml = SSML()
-        self._cached_filepath = ""
+        self._cached_filepaths = []
         self._cached_voice = ""
 
         self.config = Configuration()
-        aws_profile = self.config.read_config()["polly"]["profile_name"]
-        self._logger.debug("Using AWS profile: %s", aws_profile)
-        self._connect_aws(aws_profile)
+        self.client = None
+        self._connection_error = None
+        polly_config = self.config.read_config()["polly"]
+        aws_profile = polly_config["profile_name"]
+        aws_region = polly_config.get("region_name", None)
+        self._logger.debug("Using AWS profile: %s, region: %s", aws_profile, aws_region)
+        try:
+            self.client = self._connect_aws(aws_profile, aws_region)
+        except Exception as e:
+            self._logger.error("Error connecting to AWS: %s", e)
+            self._connection_error = str(e)
+
         self.player = player
 
     def __del__(self):
         try:
-            os.remove(self._cached_filepath)
+            for filepath in self._cached_filepaths:
+                os.remove(filepath)
         except (OSError, TypeError):
             pass
 
-    def _connect_aws(self, profile_name: str):
+    @staticmethod
+    def _connect_aws(
+        profile_name: Optional[str] = None, region_name: Optional[str] = None
+    ):
+        """Connect to AWS and create Polly client"""
         try:
-            session = boto3.Session(profile_name=profile_name)
-            self.client = session.client("polly")
+            session = boto3.Session(profile_name=profile_name, region_name=region_name)
+            return session.client("polly")
         except Exception as e:
-            self._logger.exception(
-                "Unable to connect to AWS with the profile '%s'. " "Please verify that configuration file exists.",
+            logging.exception(
+                "Unable to connect to AWS with the profile '%s' and region '%s'. "
+                "Please verify that configuration file exists.",
                 profile_name,
+                region_name,
             )
             raise e
 
+    def reload_client(self):
+        """Reload the AWS Polly client with updated configuration"""
+        self._logger.info("Reloading AWS Polly client with updated configuration")
+        polly_config = self.config.read_config()["polly"]
+        aws_profile = polly_config["profile_name"]
+        aws_region = polly_config.get("region_name", None)
+
+        self._logger.debug(
+            "Reloading with AWS profile: %s, region: %s", aws_profile, aws_region
+        )
+
+        try:
+            self.client = self._connect_aws(aws_profile, aws_region)
+            self._connection_error = None  # Clear any previous error
+            self._logger.info("Successfully reloaded AWS Polly client")
+        except Exception as e:
+            self._logger.error("Error reloading AWS client: %s", e)
+            self._connection_error = str(e)
+            raise
+
+    @staticmethod
+    def test_connection(
+        profile_name: Optional[str] = None, region_name: Optional[str] = None
+    ):
+        """
+        Test AWS Polly connection with given profile and region.
+
+        Args:
+            profile_name: AWS profile name to use
+            region_name: AWS region name to use (optional)
+
+        Returns:
+            tuple: (success: bool, message: str)
+        """
+        try:
+            # Create session and client
+            client = Polly._connect_aws(profile_name, region_name)
+
+            # Try to describe voices - this is a lightweight API call to verify connectivity
+            response = client.describe_voices()
+
+            # Count available voices
+            voice_count = len(response.get("Voices", []))
+
+            # Get the actual region being used
+            actual_region = client.meta.region_name
+
+            success_message = (
+                f"Profile: {profile_name or 'default'}\n"
+                f"Region: {actual_region}\n"
+                f"Available voices: {voice_count}"
+            )
+
+            return True, success_message
+
+        except Exception as e:
+            error_message = (
+                f"Failed to connect to AWS Polly.\n\n"
+                f"Profile: {profile_name or 'default'}\n"
+                f"Region: {region_name or 'default'}\n\n"
+                f"Error: {str(e)}\n\n"
+                f"Please verify:\n"
+                f"1. Your AWS profile is configured correctly\n"
+                f"2. You are logged into AWS\n"
+                f"3. Your credentials have access to AWS Polly"
+            )
+            return False, error_message
+
     def save_cache(self, ssml: SSML, filepaths: List[str], voice):
         self._cached_ssml = ssml
         self._cached_filepaths = filepaths
@@ -75,24 +161,61 @@ def read_text(self, text: str, **config) -> None:
             self._logger.debug("Playing cached file")
             filepaths = self._cached_filepaths
         else:
-            self._logger.debug("Re_cached_textquest from Polly")
+            self._logger.debug("Request from Polly")
             filepaths = []
             # TODO: This should obviously be asynchronous!
-            for idx, parted_text in enumerate(split_text):
-                parted_ssml = SSML(parted_text, rate=rate, volume=volume)
-                response = self.ask_polly(str(parted_ssml), voice)
-                filename = create_filename(AbstractSpeaker.TMP_FILEPATH, idx)
-                saved_filepath = save_mp3(response["AudioStream"].read(), filename)
-                filepaths.append(saved_filepath)
-            self.save_cache(ssml, filepaths, voice)
+            try:
+                for idx, parted_text in enumerate(split_text):
+                    parted_ssml = SSML(parted_text, rate=rate, volume=volume)
+                    response = self.ask_polly(str(parted_ssml), voice)
+                    filename = create_filename(AbstractSpeaker.TMP_FILEPATH, idx)
+                    saved_filepath = save_mp3(response["AudioStream"].read(), filename)
+                    filepaths.append(saved_filepath)
+                self.save_cache(ssml, filepaths, voice)
+            except (RuntimeError, Exception) as e:
+                self._logger.error("Failed to read text with Polly: %s", e)
+                return  # Exit gracefully without crashing
         self.play_files(filepaths)
         return
 
+    def _show_error_dialog(self, message: str, details: str = ""):
+        """Shows an error dialog to the user"""
+        msg_box = QMessageBox()
+        msg_box.setIcon(QMessageBox.Critical)
+        msg_box.setWindowTitle("AWS Polly Connection Error")
+        msg_box.setText(message)
+        if details:
+            msg_box.setInformativeText(details)
+        msg_box.setStandardButtons(QMessageBox.Ok)
+        msg_box.exec_()
+
     def ask_polly(self, ssml_text: str, voice: str):
         """Connects to Polly and returns path to save mp3"""
-        speech = self.create_speech(ssml_text, voice)
-        response = self.client.synthesize_speech(**speech)
-        return response
+        if self.client is None or self._connection_error:
+            error_msg = (
+                "Unable to connect to AWS Polly. Please check your AWS configuration.\n\n"
+                "Please verify:\n"
+                "1. Your AWS profile is configured correctly\n"
+                "2. You are logged into AWS\n"
+                "3. Your credentials have access to AWS Polly"
+            )
+            self._logger.error("Attempted to use Polly without valid AWS connection")
+            self._show_error_dialog(
+                error_msg, f"Error details: {self._connection_error}"
+            )
+            raise RuntimeError("AWS Polly client not initialized")
+
+        try:
+            speech = self.create_speech(ssml_text, voice)
+            response = self.client.synthesize_speech(**speech)
+            return response
+        except Exception as e:
+            error_msg = (
+                "An error occurred while trying to synthesize speech with AWS Polly."
+            )
+            self._logger.error("Error calling Polly synthesize_speech: %s", e)
+            self._show_error_dialog(error_msg, f"Error details: {str(e)}")
+            raise
 
     @staticmethod
     def create_speech(ssml_text: str, voice: str):
diff --git a/cracker/view/config_window.py b/cracker/view/config_window.py
@@ -10,10 +10,11 @@
 class ConfigWindow(QWidget):
     _logger = logging.getLogger(__name__)
 
-    def __init__(self):
+    def __init__(self, speaker=None):
         super().__init__()
 
         self.config = Configuration()
+        self.speaker = speaker
         self.setWindowTitle("Configuration")
 
         self.tabs = QTabWidget()
@@ -52,6 +53,15 @@ def confirm_action(self):
         self._logger.debug("Confirm action")
         self.config.regex_config = self.parser_tab.confirm_action()
         self.speakers_tab.confirm_action()
+
+        # Reload Polly client if speaker is Polly and it has a reload method
+        if self.speaker and hasattr(self.speaker, "reload_client"):
+            try:
+                self._logger.debug("Reloading Polly client with updated configuration")
+                self.speaker.reload_client()
+            except Exception as e:
+                self._logger.error("Failed to reload Polly client: %s", e)
+
         self.hide()
 
     def clearLayout(layout):
diff --git a/cracker/view/speaker_config_tab.py b/cracker/view/speaker_config_tab.py
@@ -1,6 +1,6 @@
 import logging
 
-from PyQt5.QtWidgets import QGridLayout, QLabel, QLineEdit, QWidget
+from PyQt5.QtWidgets import QGridLayout, QLabel, QLineEdit, QMessageBox, QPushButton, QWidget
 
 from cracker.config import Configuration
 
@@ -39,6 +39,50 @@ def __init__(self):
         self._layout.addWidget(self.aws_region_label, 2, 0)
         self._layout.addWidget(self.aws_region_input, 2, 1)
 
+        # Test connection button
+        self.test_connection_btn = QPushButton("Test Connection")
+        self.test_connection_btn.released.connect(self.test_connection)
+        self._layout.addWidget(self.test_connection_btn, 3, 0, 1, 2)
+
+    def test_connection(self):
+        """Test AWS Polly connection with the entered profile and region"""
+        self._logger.info("Testing AWS Polly connection")
+
+        profile_name = self.aws_profile_input.text() or "default"
+        region_name = self.aws_region_input.text() or None
+
+        from cracker.speaker.polly import Polly
+
+        try:
+            # Test the connection
+            success, message = Polly.test_connection(profile_name, region_name)
+
+            # Show result dialog
+            msg_box = QMessageBox()
+            if success:
+                msg_box.setIcon(QMessageBox.Information)
+                msg_box.setWindowTitle("Connection Successful")
+                msg_box.setText("Successfully connected to AWS Polly!")
+                msg_box.setInformativeText(message)
+            else:
+                msg_box.setIcon(QMessageBox.Warning)
+                msg_box.setWindowTitle("Connection Failed")
+                msg_box.setText("Failed to connect to AWS Polly")
+                msg_box.setInformativeText(message)
+
+            msg_box.setStandardButtons(QMessageBox.Ok)
+            msg_box.exec_()
+
+        except Exception as e:
+            self._logger.error("Error testing connection: %s", e)
+            msg_box = QMessageBox()
+            msg_box.setIcon(QMessageBox.Critical)
+            msg_box.setWindowTitle("Connection Test Error")
+            msg_box.setText("An unexpected error occurred while testing the connection")
+            msg_box.setInformativeText(str(e))
+            msg_box.setStandardButtons(QMessageBox.Ok)
+            msg_box.exec_()
+
     def confirm_action(self):
         self._logger.info("Confirming action")
 
diff --git a/pyproject.toml b/pyproject.toml
diff --git a/uv.lock b/uv.lock

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-__version__ = "0.8.1"`
	`1`	`+__version__ = "0.9.0"`