redditadmin 0.0.6__py3-none-any.whl → 0.1.1__py3-none-any.whl

redditadmin/core.py

@@ -1,43 +1,36 @@
 import logging
 import os
 import signal
-import sys
 import time
-from abc import ABC, abstractmethod
+from abc import ABCMeta, abstractmethod
 from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
 from typing import List
 
-from .utility.botcredentials import BotCredentials
-from .utility.exceptions import BotInitializationError, InvalidBotCredentialsError
+from .utility.botcredentials import InvalidBotCredentialsError, BotCredentials,\
+    BotCredentialsImplementation
+from .utility.miscellaneous import BotInitializationError
 from .plugin.asynchronouspluginsexecutor import AsynchronousPluginsExecutor
-from .plugin.exceptions import PluginsExecutorInitializationError
 from .plugin.plugin import Plugin
-from .plugin.pluginsexecutor import PluginsExecutor
-from .plugin.redditinterfacefactory import RedditInterfaceFactory
+from .plugin.pluginsexecutor import PluginsExecutor, PluginsExecutorInitializationError
+from .plugin.redditinterfacefactory import RedditInterfaceFactory, DefaultRedditInterfaceFactory
 
 
-class RedditAdmin(ABC):
-    """Type encapsulating a RedditAdmin instance"""
-
-    def __init__(self, *args):
-        pass
+class RedditAdmin(metaclass=ABCMeta):
+    """Encapsulates RedditAdmin bot"""
 
     @abstractmethod
     def run(self, bot_credentials: BotCredentials, listen: bool = False):
         """Run the bot"""
-
-        raise NotImplementedError
+        ...
 
     @abstractmethod
-    def stop(self):
+    def stop(self, wait: bool):
         """Shutdown the bot"""
+        ...
 
-        raise NotImplementedError
 
-
-class RedditAdminImplementation(RedditAdmin):
-    """Reddit Admin Bot"""
+class _RedditAdminImplementation(RedditAdmin):
 
     __plugins: List[Plugin]
     __pluginsExecutor: PluginsExecutor
@@ -106,7 +99,7 @@ class RedditAdminImplementation(RedditAdmin):
         # Setting the default console logging level global variable
         self.__defaultConsoleLoggingLevel = console_handler.level
 
-    def ___get_new_bot_credentials(self) -> BotCredentials:
+    def __get_new_bot_credentials(self) -> BotCredentials:
         """Convenience method to retrieve bot credentials from user input"""
 
         try:
@@ -125,7 +118,7 @@ class RedditAdminImplementation(RedditAdmin):
                 # Resume console logging
                 self.__resume_console_logging()
 
-                return BotCredentials(
+                return BotCredentialsImplementation(
                     user_agent, client_id,
                     client_secret, username,
                     password
@@ -144,7 +137,7 @@ class RedditAdminImplementation(RedditAdmin):
         # instance from provided credentials
 
         try:
-            reddit_interface_factory = RedditInterfaceFactory(
+            reddit_interface_factory = DefaultRedditInterfaceFactory(
                 bot_credentials
             )
         # Handle if credential authentication fails
@@ -154,7 +147,7 @@ class RedditAdminImplementation(RedditAdmin):
                 "Please enter new valid credentials"
             )
             try:
-                new_bot_credentials = self.___get_new_bot_credentials()
+                new_bot_credentials = self.__get_new_bot_credentials()
                 reddit_interface_factory = self.__get_reddit_interface_factory(new_bot_credentials)
             except (KeyboardInterrupt, EOFError):
                 raise BotInitializationError(
@@ -206,6 +199,7 @@ class RedditAdminImplementation(RedditAdmin):
             self.__pluginsExecutor = self.__initialize_plugins_executor(
                 bot_credentials
             )
+            self.__mainLogger.info("Bot successfully initialized")
 
             # -------------------------------------------------------------------------------
 
@@ -213,13 +207,10 @@ class RedditAdminImplementation(RedditAdmin):
         except BotInitializationError as er:
             self.__mainLogger.critical(
                 "A fatal error occurred during the "
-                "bot's initialization. The application "
-                "will now exit. Error(s): " + str(er),
+                "bot's initialization. Error(s): " + str(er),
                 exc_info=True
             )
-            sys.exit(2)  # TODO: May need future cleaning up
-
-        self.__mainLogger.info("Bot successfully initialized")
+            raise er
 
     # -------------------------------------------------------------------------------
 
@@ -310,21 +301,7 @@ class RedditAdminImplementation(RedditAdmin):
                 "'{}' is not a valid bot command".format(command)
             )
 
-    @staticmethod
-    def __kill_bot():
-        """Forcefully shut down the bot"""
-
-        # Windows kill command
-        if (
-                sys.platform.startswith('win32') or
-                sys.platform.startswith('cygwin')
-        ):
-            os.kill(os.getpid(), signal.CTRL_BREAK_EVENT)
-
-        # Linux kill command
-        os.kill(os.getpid(), signal.SIGKILL)
-
-    def __shut_down_bot(self, wait=True, shutdown_exit_code=0):
+    def __shut_down_bot(self, wait=True):
         """Shut down the bot"""
 
         if wait:
@@ -342,30 +319,13 @@ class RedditAdminImplementation(RedditAdmin):
                     )
                 )
             )
-            try:
-                self.__pluginsExecutor.shut_down(True)
-                self.__mainLogger.info('Bot successfully shut down')
-                if shutdown_exit_code != 0:
-                    sys.exit(shutdown_exit_code)
-
-            # Handle keyboard interrupt midway through graceful shutdown
-            except KeyboardInterrupt:
-
-                self.__mainLogger.warning(
-                    'Graceful shutdown aborted.'
-                )
-                self.__pluginsExecutor.shut_down(False)
-                self.__mainLogger.info('Bot shut down')
-
-                # Killing the process (only way to essentially stop all threads)
-                self.__kill_bot()
+            self.__pluginsExecutor.shut_down(True)
+            self.__mainLogger.info('Bot successfully shut down')
 
         else:
             self.__pluginsExecutor.shut_down(False)
             self.__mainLogger.info('Bot shut down')
 
-            self.__kill_bot()
-
     def __is_bot_shut_down(self):
         """Check if bot is shutdown"""
 
@@ -389,7 +349,7 @@ class RedditAdminImplementation(RedditAdmin):
                 'a graceful shutdown is attempted or press '
                 'Ctrl+C to exit immediately'
             )
-            self.__shut_down_bot(True, 1)
+            self.__shut_down_bot(True)
 
         # Handle unknown exception while bot is running
         except BaseException as ex:
@@ -399,7 +359,7 @@ class RedditAdminImplementation(RedditAdmin):
                 "a graceful shutdown is attempted or press "
                 "Ctrl+C to exit immediately: " + str(ex.args), exc_info=True
             )
-            self.__shut_down_bot(True, 2)
+            self.__shut_down_bot(True)
 
     def run(self, bot_credentials: BotCredentials, listen: bool = False):
 
@@ -427,9 +387,9 @@ class RedditAdminImplementation(RedditAdmin):
             if not self.__is_bot_shut_down():
                 self.__shut_down_bot()
 
-    def stop(self):
+    def stop(self, wait: bool):
 
-        self.__shut_down_bot()
+        self.__shut_down_bot(wait=wait)
 
     # -------------------------------------------------------------------------------
 
@@ -437,4 +397,4 @@ class RedditAdminImplementation(RedditAdmin):
 def get_reddit_admin(plugins: List[Plugin]) -> RedditAdmin:
     """Get a Reddit Admin instance"""
 
-    return RedditAdminImplementation(plugins=plugins)
+    return _RedditAdminImplementation(plugins=plugins)

redditadmin/plugin/__init__.py

@@ -1,3 +1,5 @@
-from .plugin import Plugin
-from .pluginsexecutor import PluginsExecutor
-from .redditinterfacefactory import RedditInterfaceFactory
+from .plugin import Plugin as IPlugin, AbstractPlugin as Plugin, PluginInitializationError
+from .pluginsexecutor import PluginsExecutor as IPluginsExecutor, \
+    AbstractPluginsExecutor as PluginsExecutor, PluginsExecutorInitializationError
+from .redditinterfacefactory import RedditInterfaceFactory as IRedditInterfaceFactory,\
+    DefaultRedditInterfaceFactory as RedditInterfaceFactory

redditadmin/plugin/asynchronouspluginsexecutor.py

@@ -3,22 +3,19 @@
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor, Future
 from typing import Dict, List
-from .pluginsexecutor import PluginsExecutor
+from .pluginsexecutor import AbstractPluginsExecutor, PluginsExecutorInitializationError
 from .redditinterfacefactory import RedditInterfaceFactory
 from .plugin import Plugin
-from .exceptions import PluginsExecutorInitializationError
 
 
-class AsynchronousPluginsExecutor(PluginsExecutor):
+class AsynchronousPluginsExecutor(AbstractPluginsExecutor):
     """
-    Class responsible for asynchronously executing
-    multiple plugins in different threads
+    Executes multiple plugins in different threads
     """
 
     __executor: ThreadPoolExecutor
     __plugins: Dict[str, Plugin]
     __executedPrograms: Dict[str, Future]
-    __redditInterfaceFactory: RedditInterfaceFactory
 
     def __init__(
             self,
@@ -182,7 +179,6 @@ class AsynchronousPluginsExecutor(PluginsExecutor):
             )
 
     def get_program_statuses(self):
-        """Get the executed program statuses"""
 
         program_statuses = \
             {
@@ -192,7 +188,6 @@ class AsynchronousPluginsExecutor(PluginsExecutor):
         return program_statuses
 
     def shut_down(self, wait):
-        """Shut down the plugin executor"""
 
         super().shut_down()
         for plugin in self.__plugins.values():

redditadmin/plugin/plugin.py

@@ -1,20 +1,42 @@
 import logging
-from abc import ABC, abstractmethod
+from abc import ABCMeta, abstractmethod
 from typing import TypeVar, Generic
 
 from ..program.program import Program
 from ..utility.redditinterface import RedditInterface
-from ..utility.exceptions import InitializationError
+from ..utility.miscellaneous import InitializationError
 
 T = TypeVar("T", bound=Program)
 
 
-class Plugin(Generic[T], ABC):
+class Plugin(Generic[T], metaclass=ABCMeta):
     """
-    Class responsible for generating multiple
-    instances of a specific program
+    Generates multiple instances of a specific program
     """
 
+    @abstractmethod
+    def get_program(self, reddit_interface: RedditInterface) -> T:
+        """Get new program instance"""
+        ...
+
+    @abstractmethod
+    def get_program_command(self) -> str:
+        """Get the program command string"""
+        ...
+
+    @abstractmethod
+    def is_shut_down(self) -> bool:
+        """Check if plugin is shut down"""
+        ...
+
+    @abstractmethod
+    def shut_down(self):
+        """Shut down the plugin"""
+        ...
+
+
+class AbstractPlugin(Generic[T], Plugin, metaclass=ABCMeta):
+
     _programCommand: str
     _pluginLogger: logging.Logger
     _isPluginShutDown: bool
@@ -29,33 +51,23 @@ class Plugin(Generic[T], ABC):
         )
         self._isPluginShutDown = False
 
-    @abstractmethod
-    def get_program(self, reddit_interface: RedditInterface) -> T:
-        """Get new program instance"""
-
-        raise NotImplementedError
-
     def get_program_command(self) -> str:
-        """Get the program command string"""
         return self._programCommand
 
     def is_shut_down(self) -> bool:
-        """Check if plugin is shut down"""
         return self._isPluginShutDown
 
     def shut_down(self):
-        """Shut down the plugin"""
         self._isPluginShutDown = True
 
     def __eq__(self, value) -> bool:
-        return isinstance(value, Plugin) and \
+        return isinstance(value, AbstractPlugin) and \
                self.get_program_command() == value.get_program_command()
 
 
 class PluginInitializationError(InitializationError):
     """
-    Class to encapsulate an error in the initialization
-    of a plugin module
+    Raised when initialization of a plugin module fails
     """
 
     def __init__(self, *args):

redditadmin/plugin/pluginsexecutor.py

@@ -1,43 +1,54 @@
 # -*- coding: utf-8 -*-
 
 import logging
-from abc import ABC, abstractmethod
+from abc import ABCMeta, abstractmethod
 from typing import Dict
 
+from src.redditadmin.utility.miscellaneous import InitializationError
 
-class PluginsExecutor(ABC):
+
+class PluginsExecutor(metaclass=ABCMeta):
     """
-    Class responsible for executing plugins
+    Executes plugins
     """
 
-    _isPluginsExecutorShutDown: bool
-    _pluginsExecutorLogger: logging.Logger
-
-    def __init__(self, plugins_executor_name: str):
-        self._pluginsExecutorLogger = logging.getLogger(
-            plugins_executor_name
-        )
-        self._isPluginsExecutorShutDown = False
-
     @abstractmethod
     def execute_program(self, program_command):
         """Execute the provided program command"""
-
-        raise NotImplementedError
+        ...
 
     @abstractmethod
     def get_program_statuses(self) -> Dict[str, str]:
         """Get the executed program statuses"""
+        ...
 
-        raise NotImplementedError
-
+    @abstractmethod
     def shut_down(self, *args):
         """Shut down the plugins executor"""
+        ...
+
+    @abstractmethod
+    def is_shut_down(self) -> bool:
+        """Check if the Plugins Executor is shut down"""
+        ...
+
+
+class AbstractPluginsExecutor(PluginsExecutor, metaclass=ABCMeta):
+
+    _isPluginsExecutorShutDown: bool
+    _pluginsExecutorLogger: logging.Logger
+
+    def __init__(self, plugins_executor_name: str):
+        self._pluginsExecutorLogger = logging.getLogger(
+            plugins_executor_name
+        )
+        self._isPluginsExecutorShutDown = False
+
+    def shut_down(self, *args):
 
         self._isPluginsExecutorShutDown = True
 
     def is_shut_down(self) -> bool:
-        """Check if the Plugins Executor is shut down"""
 
         return self._isPluginsExecutorShutDown
 
@@ -52,3 +63,12 @@ class PluginsExecutor(ABC):
                 "The plugins executor cannot execute any more program "
                 "after it has been shut down"
             )
+
+
+class PluginsExecutorInitializationError(InitializationError):
+    """
+    Raised when initialization of a Plugins Executor module fails
+    """
+
+    def __init__(self, *args):
+        super().__init__(*args)

redditadmin/plugin/redditinterfacefactory.py

@@ -1,49 +1,47 @@
+from abc import ABCMeta, abstractmethod
+
 import praw
 
-from ..utility.botcredentials import BotCredentials
-from ..utility.exceptions import InvalidBotCredentialsError
-from ..utility.redditinterface import RedditInterface
+from ..utility.botcredentials import BotCredentials, InvalidBotCredentialsError
+from ..utility.miscellaneous import is_reddit_authenticated
+from ..utility.redditinterface import RedditInterface, RedditInterfaceImplementation
 
 
-class RedditInterfaceFactory:
+class RedditInterfaceFactory(metaclass=ABCMeta):
     """Factory for RedditInterface objects"""
 
-    __botCredentials: BotCredentials
+    @abstractmethod
+    def get_reddit_interface(self) -> RedditInterface:
+        """Retrieve new Reddit Interface"""
+        ...
+
+
+class DefaultRedditInterfaceFactory(RedditInterfaceFactory):
 
     def __init__(
             self,
             bot_credentials: BotCredentials
     ):
         praw_reddit = praw.Reddit(
-            user_agent=bot_credentials.get_user_agent,
-            client_id=bot_credentials.get_client_id,
-            client_secret=bot_credentials.get_client_secret,
-            username=bot_credentials.getusername,
-            password=bot_credentials.get_password
+            user_agent=bot_credentials.user_agent,
+            client_id=bot_credentials.client_id,
+            client_secret=bot_credentials.client_secret,
+            username=bot_credentials.username,
+            password=bot_credentials.password
         )
-        if not self.__authenticated(praw_reddit):
+        if not is_reddit_authenticated(praw_reddit):
             raise InvalidBotCredentialsError
 
         self.__botCredentials = bot_credentials
 
-    @staticmethod
-    def __authenticated(praw_reddit_instance: praw.Reddit) -> bool:
-        """
-        Convenience method to authenticate bot credentials
-        provided to Reddit instance
-        """
-
-        return not praw_reddit_instance.read_only
-
-    def get_reddit_interface(self) -> RedditInterface:
-        """Retrieve new Reddit Interface"""
+    def get_reddit_interface(self):
 
         bot_credentials = self.__botCredentials
         praw_reddit = praw.Reddit(
-            user_agent=bot_credentials.get_user_agent,
-            client_id=bot_credentials.get_client_id,
-            client_secret=bot_credentials.get_client_secret,
-            username=bot_credentials.getusername,
-            password=bot_credentials.get_password
+            user_agent=bot_credentials.user_agent,
+            client_id=bot_credentials.client_id,
+            client_secret=bot_credentials.client_secret,
+            username=bot_credentials.username,
+            password=bot_credentials.password
         )
-        return RedditInterface(praw_reddit)
+        return RedditInterfaceImplementation(praw_reddit)

redditadmin/program/__init__.py

@@ -1,3 +1,5 @@
-from .program import Program, RecurringProgram
-from .streamprocessingprogram import StreamProcessingProgram, StreamFactory, SubmissionStreamFactory, \
-    CommentStreamFactory, CustomStreamFactory
+from .program import Program as IProgram, AbstractProgram as Program,\
+    RecurringProgram as IRecurringProgram, AbstractRecurringProgram as RecurringProgram
+from .streamprocessingprogram import StreamProcessingProgram as IStreamProcessingProgram,\
+    AbstractStreamProcessingProgram as StreamProcessingProgram,\
+    StreamFactory, SubmissionStreamFactory, CommentStreamFactory, CustomStreamFactory

redditadmin/program/program.py

@@ -1,26 +1,45 @@
 import logging
 import time
-from abc import ABC, abstractmethod
+from abc import ABCMeta, abstractmethod
 from typing import Callable
 
 
-class Program(ABC):
-    """Class representing a simple program"""
+class Program(metaclass=ABCMeta):
+    """Encapsulates a simple program/script"""
 
-    def __init__(self, program_name: str):
-        self._programLogger = logging.getLogger(
-            program_name
-        )        
+    @property
+    @abstractmethod
+    def program_name(self):
+        ...
 
     @abstractmethod
     def execute(self, *args, **kwargs):
         """Execute the program"""
+        ...
 
-        raise NotImplementedError()
 
+class RecurringProgram(Program, metaclass=ABCMeta):
+    """Encapsulates a looping program type"""
 
-class RecurringProgram(Program, ABC):
-    """Class encapsulating a looping program type"""
+    @abstractmethod
+    def _run_nature_core(self, *args, **kwargs):
+        """Run core program"""
+        ...
+
+
+class AbstractProgram(Program, metaclass=ABCMeta):
+
+    def __init__(self, program_name: str):
+        self.__program_name = program_name
+        self._programLogger = logging.getLogger(
+            program_name
+        )
+
+    def program_name(self):
+        return self.__program_name
+
+
+class AbstractRecurringProgram(RecurringProgram, AbstractProgram, metaclass=ABCMeta):
 
     def __init__(
             self,
@@ -28,7 +47,7 @@ class RecurringProgram(Program, ABC):
             stop_condition: Callable[..., bool],
             cooldown: float = 0
     ):
-        super().__init__(program_name)
+        super().__init__(program_name=program_name)
         self._stopCondition = stop_condition
         self._cooldown = cooldown
 
@@ -37,9 +56,3 @@ class RecurringProgram(Program, ABC):
             self._run_nature_core(*args, **kwargs)
             if self._cooldown and self._cooldown > 0:
                 time.sleep(self._cooldown)
-
-    @abstractmethod
-    def _run_nature_core(self, *args, **kwargs):
-        """Run core program"""
-
-        raise NotImplementedError()

redditadmin/program/streamprocessingprogram.py

@@ -1,39 +1,47 @@
-from abc import ABC, abstractmethod
+from abc import ABCMeta, abstractmethod
 from typing import Generator, Callable
 
 from praw.models import Subreddit, ListingGenerator
 from praw.models.util import stream_generator
 
-from .program import RecurringProgram
+from .program import RecurringProgram, AbstractRecurringProgram
 from ..utility.decorators import consumestransientapierrors
 
 
-class StreamFactory(ABC):
+class StreamFactory(metaclass=ABCMeta):
     """
-    Class responsible for producing
-    new Reddit Object streams at request
+    Produces new Reddit Object streams at request
     """
 
     @abstractmethod
     def get_new_stream(self) -> Generator:
         """Produce new stream"""
+        ...
 
-        raise NotImplementedError()
 
-
-class StreamProcessingProgram(RecurringProgram, ABC):
+class StreamProcessingProgram(RecurringProgram, metaclass=ABCMeta):
     """
-    Class encapsulating a stream processing
-    program
+    Encapsulates a stream processing program
     """
 
+    @abstractmethod
+    def _run_pause_handler(self, *args):
+        """Execute when stream is paused"""
+        ...
+
+
+class AbstractStreamProcessingProgram(StreamProcessingProgram, AbstractRecurringProgram, metaclass=ABCMeta):
+
     def __init__(
             self,
             stream_factory: StreamFactory,
             stop_condition: Callable[..., bool],
             program_name: str
     ):
-        super().__init__(program_name, stop_condition)
+        super().__init__(
+            program_name=program_name,
+            stop_condition=stop_condition
+        )
         self.__streamFactory = stream_factory
 
     @consumestransientapierrors
@@ -60,15 +68,10 @@ class StreamProcessingProgram(RecurringProgram, ABC):
 
                 self._run_nature_core(streamItem)
 
-    def _run_pause_handler(self, *args):
-        """Execute when stream is paused"""
-        pass
-
 
 class SubmissionStreamFactory(StreamFactory):
     """
-    Class responsible for producing
-    new Submission streams at request
+    Produces new Submission streams at request
     """
 
     def __init__(
@@ -91,8 +94,7 @@ class SubmissionStreamFactory(StreamFactory):
 
 class CommentStreamFactory(StreamFactory):
     """
-    Class responsible for producing
-    new Comment streams at request
+    Produces new Comment streams at request
     """
 
     def __init__(
@@ -115,8 +117,7 @@ class CommentStreamFactory(StreamFactory):
 
 class CustomStreamFactory(StreamFactory):
     """
-    Class responsible for producing new
-    stream of custom Reddit objects according to
+    Produces new stream of custom Reddit objects according to
     the provided Listing Generator
     """
 

redditadmin/utility/__init__.py

@@ -1,5 +1,9 @@
-from .botcredentials import BotCredentials
-from .contributionsutility import retrieve_submissions_from_subreddit, retrieve_select_submissions, is_removed
+from .botcredentials import BotCredentials as IBotCredentials,\
+    BotCredentialsImplementation as BotCredentials, InvalidBotCredentialsError
+from .contributions import retrieve_submissions_from_subreddit, retrieve_select_submissions, is_removed
 from .decorators import consumestransientapierrors
-from .redditinterface import RedditInterface
-from .redditsubmission import RedditSubmission
+from .miscellaneous import is_reddit_authenticated, BotInitializationError, InitializationError
+from .redditinterface import RedditInterface as IRedditInterface,\
+    RedditInterfaceImplementation as RedditInterface
+from .redditsubmission import RedditSubmission as IRedditSubmission,\
+    RedditSubmissionImplementation as RedditSubmission

redditadmin/utility/botcredentials.py

@@ -1,13 +1,43 @@
-class BotCredentials:
+from abc import ABCMeta, abstractmethod
+
+
+class BotCredentials(metaclass=ABCMeta):
     """
-    Class holding the bot's credentials
+    Encapsulates the bot's credentials
     """
 
-    __user_agent: str
-    __client_id: str
-    __client_secret: str
-    __username: str
-    __password: str
+    @property
+    @abstractmethod
+    def password(self) -> str:
+        """Retrieve the bot's Password"""
+        ...
+
+    @property
+    @abstractmethod
+    def client_secret(self) -> str:
+        """Retrieve the bot's Client Secret"""
+        ...
+
+    @property
+    @abstractmethod
+    def client_id(self) -> str:
+        """Retrieve the bot's Client ID"""
+        ...
+
+    @property
+    @abstractmethod
+    def user_agent(self) -> str:
+        """Retrieve the bot's User Agent"""
+        ...
+
+    @property
+    @abstractmethod
+    def username(self) -> str:
+        """Retrieve the bot's Username"""
+        ...
+
+
+class BotCredentialsImplementation(BotCredentials):
 
     def __init__(
             self,
@@ -24,40 +54,30 @@ class BotCredentials:
         self.__password = password
 
     @property
-    def get_user_agent(self):
-        """Retrieve the bot's User Agent"""
-
+    def user_agent(self) -> str:
         return self.__user_agent
 
     @property
-    def get_client_id(self):
-        """Retrieve the bot's Client ID"""
-
+    def client_id(self):
         return self.__client_id
 
     @property
-    def get_client_secret(self):
-        """Retrieve the bot's Client Secret"""
-
+    def client_secret(self):
         return self.__client_secret
 
     @property
-    def getusername(self):
-        """Retrieve the bot's Username"""
-
+    def username(self):
         return self.__username
 
     @property
-    def get_password(self):
-        """Retrieve the bot's Password"""
-
+    def password(self):
         return self.__password
 
-    def clear_credentials(self):
-        """Convenience method to clear the bot's credentials"""
 
-        self.__user_agent = ""
-        self.__client_id = ""
-        self.__client_secret = ""
-        self.__username = ""
-        self.__password = ""
+class InvalidBotCredentialsError(Exception):
+    """
+    Raised when provided bot credentials are invalid
+    """
+
+    def __init__(self, *args):
+        super().__init__(self, args)

redditadmin/utility/{contributionsutility.py → contributions.py}

@@ -61,4 +61,4 @@ def is_removed(
     except AttributeError:
         author = None
     return author is None or author == '[Deleted]' or \
-        contribution.banned_by is not None
+        contribution.banned_by is not None

redditadmin/utility/decorators.py

@@ -11,10 +11,9 @@ from prawcore.exceptions import RequestException, ServerError
 
 def consumestransientapierrors(_execute_function=None, *, timeout: int = 30):
     """
-    Decorator responsible for consuming common transient
-    errors which may occur while connecting to the
-    Reddit API during the running of the provided
-    program
+    Consumes common transient errors which may
+    occur while connecting to the Reddit API during
+    the running of the provided program
     """
 
     def subsuming_function(execute_function):

redditadmin/utility/miscellaneous.py

@@ -0,0 +1,28 @@
+import praw
+
+
+class InitializationError(Exception):
+    """
+    Raised when the initialization of a module fails
+    """
+
+    def __init__(self, *args):
+        super().__init__(self, args)
+
+
+class BotInitializationError(InitializationError):
+    """
+    Raised when the initialization of a bot module fails
+    """
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+
+def is_reddit_authenticated(praw_reddit_instance: praw.Reddit) -> bool:
+    """
+    Convenience method to authenticate bot credentials
+    provided to Reddit instance
+    """
+
+    return not praw_reddit_instance.read_only

redditadmin/utility/redditinterface.py

@@ -1,19 +1,27 @@
 # -*- coding: utf-8 -*
+from abc import ABCMeta, abstractmethod
+
 from praw import Reddit
 
 
-class RedditInterface:
+class RedditInterface(metaclass=ABCMeta):
     """
-    Class holding tools to interface with the Reddit API
+    Encapsulates tools to interface with the Reddit API
     """
 
-    __prawReddit: Reddit
+    @property
+    @abstractmethod
+    def praw_reddit(self):
+        """Retrieve the interface's PrawReddit instance"""
+        ...
+
+
+class RedditInterfaceImplementation(RedditInterface):
 
     def __init__(self, praw_reddit: Reddit):
         self.__prawReddit = praw_reddit
 
     @property
-    def get_praw_reddit(self):
-        """Retrieve the interface's PrawReddit instance"""
+    def praw_reddit(self):
 
         return self.__prawReddit

redditadmin/utility/redditsubmission.py

@@ -1,18 +1,26 @@
+from abc import abstractmethod, ABCMeta
+
 from praw.models import Submission
 
 
-class RedditSubmission:
+class RedditSubmission(metaclass=ABCMeta):
     """
-    Class encapsulating a submission
+    Encapsulates a submission
     """
 
-    __submissionId: str
+    @property
+    @abstractmethod
+    def submission_id(self):
+        ...
+
+
+class RedditSubmissionImplementation(RedditSubmission):
 
     def __init__(self, submission_id):
         self.__submissionId = submission_id
 
     @property
-    def get_submission_id(self):
+    def submission_id(self):
         return self.__submissionId
 
     @classmethod
@@ -20,17 +28,17 @@ class RedditSubmission:
             cls, submission_id: str
     ):
         """
-        Returns a SimpleSubmission object from
-        the provided submissionId
+        Returns a RedditSubmission object from
+        the provided submission_id
         """
-        return RedditSubmission(submission_id)
+        return RedditSubmissionImplementation(submission_id)
 
     @classmethod
     def get_submission_from_praw_submission(
             cls, praw_submission: Submission
     ):
         """
-        Returns a SimpleSubmission object from
+        Returns a RedditSubmission object from
         the provided PRAW submission
         """
-        return RedditSubmission(praw_submission.id)
+        return RedditSubmissionImplementation(praw_submission.id)

{redditadmin-0.0.6.dist-info → redditadmin-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redditadmin
-Version: 0.0.6
+Version: 0.1.1
 Summary: Extensible Python administrative bot
 Project-URL: Homepage, https://github.com/Grod56/reddit-admin
 Project-URL: Issues, https://github.com/Grod56/reddit-admin/issues
@@ -130,17 +130,21 @@ Plugin:
 
 ```py
 class MyPlugin[Plugin[MyProgram]]
-    """The plugin for our program"""
 
-    def __init__():
-        super().__init__("myprogram")
 
-    def get_program(self, reddit_interface):
-        """Overriden from Plugin superclass"""
+"""The plugin for our program"""
 
-        praw_reddit = reddit_interface.get_praw_reddit
 
-        return MyProgram(praw_reddit)
+def __init__():
+    super().__init__("myprogram")
+
+
+def get_program(self, reddit_interface):
+    """Overriden from Plugin superclass"""
+
+    praw_reddit = reddit_interface.praw_reddit
+
+    return MyProgram(praw_reddit)
 ```
 
 Voila! We may now supply our plugin to the bot and run it just as we did before

redditadmin-0.1.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+redditadmin/__init__.py,sha256=H9tJpqCduGTfE__euVT9Qp5vWzS6VI3iXmGfbl_cixw,120
+redditadmin/core.py,sha256=eV_5JAZ_KvqVDxRkqrzzMumVkxs8SZecsiv3j9P5d20,14012
+redditadmin/plugin/__init__.py,sha256=aFjHxkbg-7X3NTdl0TeVWIbtkc-Efzz2iZPvV--UdNg,395
+redditadmin/plugin/asynchronouspluginsexecutor.py,sha256=n83iXNygrn8l0DnkEt0jb1UbOV1VtzxTV7OD3sJDsuQ,6897
+redditadmin/plugin/plugin.py,sha256=qJFmmruUn-CiKZcw6Vl13EpHm1bAd9D0CwKnqqDsYoU,1906
+redditadmin/plugin/pluginsexecutor.py,sha256=5iBcYDsk_MEN5DdO95T_Lb3nDwF1pBkRKoddmAY-jF4,1948
+redditadmin/plugin/redditinterfacefactory.py,sha256=QIyN0PIuzEAMPAlxD58UE6MMpGxMM08Xb_V9rCtkrJU,1587
+redditadmin/program/__init__.py,sha256=Vu_AxIUS4U2-6dAIGlzeQNvLtS1mY_5wDxUB5xGVV_k,406
+redditadmin/program/program.py,sha256=rT_3wV3w1F9R9voBsZsqYwMDGSEVsHJT_M_EMOxkAS0,1524
+redditadmin/program/streamprocessingprogram.py,sha256=DVWURQiQNtGPOlsiCDG5Abmw3_GvAPKEGJI19AtUcP8,3995
+redditadmin/utility/__init__.py,sha256=7-MxaEvDEoozvwWO56r75wgabuKQuI4jtdl2JhrmRFE,648
+redditadmin/utility/botcredentials.py,sha256=g9wkkPy2XUe7zDV6Mtzpxljr7BclsjPzbu2W6Uiy7J4,1801
+redditadmin/utility/contributions.py,sha256=dPU0OA0PBxh5ktHJtiLizYM5xtqPd-9VhOzRkvdw4iI,1490
+redditadmin/utility/decorators.py,sha256=yk2ZQXA2sLRBIZRl8nvHzeyM5DjMYHwtCZcnNOz2wxY,1629
+redditadmin/utility/miscellaneous.py,sha256=8FaWN6RyxGqCvM8Y1_Ud09mQMll8TpVU9WyYe-9np0w,632
+redditadmin/utility/redditinterface.py,sha256=Nd9cZEyS0tRtJWpy_QO0TsfQzG5LK_K5hSokl3Hu2IA,582
+redditadmin/utility/redditsubmission.py,sha256=SshPTHHCFLrBOMudKNc8P_kn9oVXUdbyxwnaV54xQnE,1057
+redditadmin-0.1.1.dist-info/METADATA,sha256=HUJrOaTZJAgquFOkm-YpB3djcD6pggQweUVYZVxK4t4,5338
+redditadmin-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+redditadmin-0.1.1.dist-info/licenses/LICENSE,sha256=kieFEKjHWxFgNnmvKA_eXHmaQQZ9ZgEI_5m14IiVzAo,1091
+redditadmin-0.1.1.dist-info/RECORD,,

redditadmin/plugin/exceptions.py

@@ -1,11 +0,0 @@
-from ..utility.exceptions import InitializationError
-
-
-class PluginsExecutorInitializationError(InitializationError):
-    """
-    Class to encapsulate an error in the initialization
-    of a Plugins Executor module
-    """
-
-    def __init__(self, *args):
-        super().__init__(*args)

redditadmin/utility/exceptions.py

@@ -1,28 +0,0 @@
-class InitializationError(Exception):
-    """
-    Class to encapsulate an error in the
-    initialization of a module
-    """
-
-    def __init__(self, *args):
-        super().__init__(self, args)
-
-
-class BotInitializationError(InitializationError):
-    """
-    Class to encapsulate an error in the
-    initialization of a bot module
-    """
-
-    def __init__(self, *args):
-        super().__init__(*args)
-
-
-class InvalidBotCredentialsError(Exception):
-    """
-    Class encapsulating an exception raised
-    when provided bot credentials are invalid
-    """
-
-    def __init__(self, *args):
-        super().__init__(self, args)

redditadmin-0.0.6.dist-info/RECORD

@@ -1,22 +0,0 @@
-redditadmin/__init__.py,sha256=H9tJpqCduGTfE__euVT9Qp5vWzS6VI3iXmGfbl_cixw,120
-redditadmin/core.py,sha256=iGgN74nYgRLvrkAue9hk-Ptdmpr0oUCx8xWdW5ROBaY,15173
-redditadmin/plugin/__init__.py,sha256=qHKyhBz5ovgef0lcXtIUsP7ZbryDrXCxRylyGJJjgTo,134
-redditadmin/plugin/asynchronouspluginsexecutor.py,sha256=WkEbTFciqgJ2cQ59AgXJBsPpPntugJxF2KapB1NNmwY,7096
-redditadmin/plugin/exceptions.py,sha256=tNwWiitjeCXVFTL9_y3fXF_Dzjk-CUHd2uqvl0_UUmI,298
-redditadmin/plugin/plugin.py,sha256=_Zr1mhTP6y1cZDxxd8vcRYodSeiOViprmZ7TGJwaA6A,1673
-redditadmin/plugin/pluginsexecutor.py,sha256=i758rqdlFysJh63ZzVY3fqQJriH2hc-gubiuK9wa24Y,1496
-redditadmin/plugin/redditinterfacefactory.py,sha256=20RInQUmvHFnbE7-SttjfYa1dsRTD0lgdh5mQVieFUw,1654
-redditadmin/program/__init__.py,sha256=86ezrveWRark-dpsSjuD_dPvsxDbh7uqHE-Porlhd_E,200
-redditadmin/program/program.py,sha256=pGvx03PWkfQsfdRfQ-g5DbXSG0NjDuGQBrTU3baQJaE,1205
-redditadmin/program/streamprocessingprogram.py,sha256=r-VuHmNdEiJq6sAoDDUub-VlX04lVCjgYCBfiiw9gPE,3888
-redditadmin/utility/__init__.py,sha256=bZlqoWdMCmR7COJiiSY6RamzyqQSvbLHyifdvrBW4Ac,302
-redditadmin/utility/botcredentials.py,sha256=qkrKtqXvA0h1NSwy70ESxsZyyXwXPiB5USpMt-56UwY,1462
-redditadmin/utility/contributionsutility.py,sha256=FHOlMJE3Vdk5H2j-_b0TzGP9rhGn-tAxQqx4_-hk8mg,1492
-redditadmin/utility/decorators.py,sha256=T0Mir1zX3_tHVDuU3UaQ1Mg1ayapaL84_GSbuifg5lY,1661
-redditadmin/utility/exceptions.py,sha256=8XliprLrcYtKYji6JPYw6nfC3yA0i551iOSV3Op06A4,652
-redditadmin/utility/redditinterface.py,sha256=kWmUrdQffujf3j9bDE9wCH3FAmvckeaOWcl9NV3MRy0,415
-redditadmin/utility/redditsubmission.py,sha256=tB830FGKmnFMBg5GXrMcGKYdGtSSYgt_uCCaLnNYlC4,862
-redditadmin-0.0.6.dist-info/METADATA,sha256=QU7GBJQ8cRPmx2shBPPEUBMRS1sC7MmEFQ-Jy0-1k1Q,5366
-redditadmin-0.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-redditadmin-0.0.6.dist-info/licenses/LICENSE,sha256=kieFEKjHWxFgNnmvKA_eXHmaQQZ9ZgEI_5m14IiVzAo,1091
-redditadmin-0.0.6.dist-info/RECORD,,