android-notify 1.3__py3-none-any.whl → 1.60.6.dev0__py3-none-any.whl

android_notify/__init__.py

@@ -1,3 +1,4 @@
+""""For Easier Imports For Public Classes"""
 from .core import send_notification
 from .styles import NotificationStyles
-from .sword import Notification
+from .sword import Notification,NotificationHandler

android_notify/__main__.py

@@ -0,0 +1,24 @@
+import argparse
+from .config import __version__
+
+def print_version():
+    text = f"android_notify: v{__version__}"
+    border = '+'+'-'*(len(text) + 2)+'+'
+    print(border)
+    print(f'| {text} |')
+    print(border)
+
+def main():
+    parser = argparse.ArgumentParser(description="Android Notify CLI")
+    parser.add_argument('-v','--version', action='store_true', help="Show the version of android_notify")
+    args = parser.parse_args()
+
+    if args.version:
+        print_version()
+    # # Placeholder for the main functionality
+    # print("Android Notify CLI is running...")
+    # DEV:  pip install -e ., when edit and test project locally
+
+
+if __name__ == "__main__":
+    main()

android_notify/an_types.py

@@ -0,0 +1,341 @@
+"""For autocomplete Storing Reference to Available Methods"""
+from typing import Literal
+
+Importance = Literal['urgent', 'high', 'medium', 'low', 'none']
+"""
+    :argument urgent - Makes a sound and appears as a heads-up notification.
+    
+    :argument high - Makes a sound.
+    
+    :argument urgent - Makes no sound.
+    
+    :argument urgent - Makes no sound and doesn't appear in the status bar.
+    
+    :argument urgent - Makes no sound and doesn't in the status bar or shade.
+"""
+
+
+# For Dev
+# Idea for typing autocompletion and reference
+class Bundle:
+    def putString(self, key, value):
+        print(f"[MOCK] Bundle.putString called with key={key}, value={value}")
+
+    def putInt(self, key, value):
+        print(f"[MOCK] Bundle.putInt called with key={key}, value={value}")
+
+
+class String(str):
+    def __new__(cls, value):
+        print(f"[MOCK] String created with value={value}")
+        return str.__new__(cls, value)
+
+
+class Intent:
+    FLAG_ACTIVITY_NEW_TASK = 'FACADE_FLAG_ACTIVITY_NEW_TASK'
+    CATEGORY_DEFAULT = 'FACADE_FLAG_CATEGORY_DEFAULT'
+
+    def __init__(self, context='', activity=''):
+        self.obj = {}
+        print(f"[MOCK] Intent initialized with context={context}, activity={activity}")
+
+    def setAction(self, action):
+        print(f"[MOCK] Intent.setAction called with: {action}")
+        return self
+
+    def addFlags(self, *flags):
+        print(f"[MOCK] Intent.addFlags called with: {flags}")
+        return self
+
+    def setData(self, uri):
+        print(f"[MOCK] Intent.setData called with: {uri}")
+        return self
+
+    def setFlags(self, intent_flag):
+        print(f"[MOCK] Intent.setFlags called with: {intent_flag}")
+        return self
+
+    def addCategory(self, intent_category):
+        print(f"[MOCK] Intent.addCategory called with: {intent_category}")
+        return self
+
+    def getAction(self):
+        print("[MOCK] Intent.getAction called")
+        return self
+
+    def getStringExtra(self, key):
+        print(f"[MOCK] Intent.getStringExtra called with key={key}")
+        return self
+
+    def putExtra(self, key, value):
+        self.obj[key] = value
+        print(f"[MOCK] Intent.putExtra called with key={key}, value={value}")
+
+    def putExtras(self, bundle: Bundle):
+        self.obj['bundle'] = bundle
+        print(f"[MOCK] Intent.putExtras called with bundle={bundle}")
+
+
+class PendingIntent:
+    FLAG_IMMUTABLE = ''
+    FLAG_UPDATE_CURRENT = ''
+
+    def getActivity(self, context, value, action_intent, pending_intent_type):
+        print(
+            f"[MOCK] PendingIntent.getActivity called with context={context}, value={value}, action_intent={action_intent}, type={pending_intent_type}")
+
+
+class BitmapFactory:
+    def decodeStream(self, stream):
+        print(f"[MOCK] BitmapFactory.decodeStream called with stream={stream}")
+
+
+class BuildVersion:
+    SDK_INT = 0
+
+class Manifest:
+    POST_NOTIFICATIONS = 'FACADE_IMPORT'
+
+class Settings:
+    ACTION_APP_NOTIFICATION_SETTINGS = 'FACADE_IMPORT_ACTION_APP_NOTIFICATION_SETTINGS'
+    EXTRA_APP_PACKAGE = 'FACADE_IMPORT_EXTRA_APP_PACKAGE'
+    ACTION_APPLICATION_DETAILS_SETTINGS = 'FACADE_IMPORT_ACTION_APPLICATION_DETAILS_SETTINGS'
+
+class Uri:
+    def __init__(self,package_name):
+        print("FACADE_URI")
+
+class NotificationManager:
+    pass
+
+class NotificationManagerClass:
+    pass
+
+
+class NotificationChannel:
+    def __init__(self, channel_id, channel_name, importance):
+        self.description = None
+        self.channel_id = channel_id
+        self.channel = None
+        print(
+            f"[MOCK] NotificationChannel initialized with id={channel_id}, name={channel_name}, importance={importance}")
+
+    def createNotificationChannel(self, channel):
+        self.channel = channel
+        print(f"[MOCK] NotificationChannel.createNotificationChannel called with channel={channel}")
+
+    def getNotificationChannel(self, channel_id):
+        self.channel_id = channel_id
+        print(f"[MOCK] NotificationChannel.getNotificationChannel called with id={channel_id}")
+
+    def setDescription(self, description):
+        self.description = description
+        print(f"[MOCK] NotificationChannel.setDescription called with description={description}")
+
+    def getId(self):
+        print(f"[MOCK] NotificationChannel.getId called, returning {self.channel_id}")
+        return self.channel_id
+
+
+class IconCompat:
+    def createWithBitmap(self, bitmap):
+        print(f"[MOCK] IconCompat.createWithBitmap called with bitmap={bitmap}")
+
+
+class Color:
+    def __init__(self):
+        print("[MOCK] Color initialized")
+
+    def parseColor(self, color: str):
+        print(f"[MOCK] Color.parseColor called with color={color}")
+        return self
+
+
+class RemoteViews:
+    def __init__(self, package_name, small_layout_id):
+        print(f"[MOCK] RemoteViews initialized with package_name={package_name}, layout_id={small_layout_id}")
+
+    def createWithBitmap(self, bitmap):
+        print(f"[MOCK] RemoteViews.createWithBitmap called with bitmap={bitmap}")
+
+    def setTextViewText(self, id, text):
+        print(f"[MOCK] RemoteViews.setTextViewText called with id={id}, text={text}")
+
+    def setTextColor(self, id, color: Color):
+        print(f"[MOCK] RemoteViews.setTextColor called with id={id}, color={color}")
+
+
+class NotificationManagerCompat:
+    IMPORTANCE_HIGH = 4
+    IMPORTANCE_DEFAULT = 3
+    IMPORTANCE_LOW = ''
+    IMPORTANCE_MIN = ''
+    IMPORTANCE_NONE = ''
+
+class AndroidNotification:
+    DEFAULT_ALL = 3
+    PRIORITY_HIGH = 4
+    PRIORITY_DEFAULT = ''
+    PRIORITY_LOW = ''
+    PRIORITY_MIN = ''
+
+class NotificationCompat:
+    DEFAULT_ALL = 3
+    PRIORITY_HIGH = 4
+    PRIORITY_DEFAULT = ''
+    PRIORITY_LOW = ''
+    PRIORITY_MIN = ''
+
+
+class MActions:
+    def clear(self):
+        """This Removes all buttons"""
+        print('[MOCK] MActions.clear called')
+
+
+class NotificationCompatBuilder:
+    def __init__(self, context, channel_id):
+        self.mActions = MActions()
+        print(f"[MOCK] NotificationCompatBuilder initialized with context={context}, channel_id={channel_id}")
+
+    def setProgress(self, max_value, current_value, endless):
+        print(f"[MOCK] setProgress called with max={max_value}, current={current_value}, endless={endless}")
+
+    def setStyle(self, style):
+        print(f"[MOCK] setStyle called with style={style}")
+
+    def setContentTitle(self, title):
+        print(f"[MOCK] setContentTitle called with title={title}")
+
+    def setContentText(self, text):
+        print(f"[MOCK] setContentText called with text={text}")
+
+    def setSmallIcon(self, icon):
+        print(f"[MOCK] setSmallIcon called with icon={icon}")
+
+    def setLargeIcon(self, icon):
+        print(f"[MOCK] setLargeIcon called with icon={icon}")
+
+    def setAutoCancel(self, auto_cancel: bool):
+        print(f"[MOCK] setAutoCancel called with auto_cancel={auto_cancel}")
+
+    def setPriority(self, priority: Importance):
+        print(f"[MOCK] setPriority called with priority={priority}")
+
+    def setDefaults(self, defaults):
+        print(f"[MOCK] setDefaults called with defaults={defaults}")
+
+    def setOngoing(self, persistent: bool):
+        print(f"[MOCK] setOngoing called with persistent={persistent}")
+
+    def setOnlyAlertOnce(self, state):
+        print(f"[MOCK] setOnlyAlertOnce called with state={state}")
+
+    def build(self):
+        print("[MOCK] build called")
+
+    def setContentIntent(self, pending_action_intent: PendingIntent):
+        print(f"[MOCK] setContentIntent called with {pending_action_intent}")
+
+    def addAction(self, icon_int, action_text, pending_action_intent):
+        print(f"[MOCK] addAction called with icon={icon_int}, text={action_text}, intent={pending_action_intent}")
+
+    def setShowWhen(self, state):
+        print(f"[MOCK] setShowWhen called with state={state}")
+
+    def setWhen(self, time_ms):
+        print(f"[MOCK] setWhen called with time_ms={time_ms}")
+
+    def setCustomContentView(self, layout):
+        print(f"[MOCK] setCustomContentView called with layout={layout}")
+
+    def setCustomBigContentView(self, layout):
+        print(f"[MOCK] setCustomBigContentView called with layout={layout}")
+
+    def setSubText(self, text):
+        print(f"[MOCK] setSubText called with text={text}")
+
+    def setColor(self, color: Color) -> None:
+        print(f"[MOCK] setColor called with color={color}")
+
+
+class NotificationCompatBigTextStyle:
+    def bigText(self, body):
+        print(f"[MOCK] NotificationCompatBigTextStyle.bigText called with body={body}")
+        return self
+
+
+class NotificationCompatBigPictureStyle:
+    def bigPicture(self, bitmap):
+        print(f"[MOCK] NotificationCompatBigPictureStyle.bigPicture called with bitmap={bitmap}")
+        return self
+
+
+class NotificationCompatInboxStyle:
+    def addLine(self, line):
+        print(f"[MOCK] NotificationCompatInboxStyle.addLine called with line={line}")
+        return self
+
+
+class NotificationCompatDecoratedCustomViewStyle:
+    def __init__(self):
+        print("[MOCK] NotificationCompatDecoratedCustomViewStyle initialized")
+
+
+class Permission:
+    POST_NOTIFICATIONS = ''
+
+
+def check_permission(permission: Permission.POST_NOTIFICATIONS):
+    print(f"[MOCK] check_permission called with {permission}")
+    print(permission)
+
+
+def request_permissions(_list: [], _callback):
+    print(f"[MOCK] request_permissions called with {_list}")
+    _callback()
+
+
+class AndroidActivity:
+    def bind(self, on_new_intent):
+        print(f"[MOCK] AndroidActivity.bind called with {on_new_intent}")
+
+    def unbind(self, on_new_intent):
+        print(f"[MOCK] AndroidActivity.unbind called with {on_new_intent}")
+
+
+class PythonActivity:
+    mActivity = "[MOCK] mActivity used"
+    def __init__(self):
+        print("[MOCK] PythonActivity initialized")
+
+
+class DummyIcon:
+    icon = 101
+
+    def __init__(self):
+        print("[MOCK] DummyIcon initialized")
+
+
+class Context:
+    def __init__(self):
+        print("[MOCK] Context initialized")
+        pass
+
+    @staticmethod
+    def getApplicationInfo():
+        print("[MOCK] Context.getApplicationInfo called")
+        return DummyIcon
+
+    @staticmethod
+    def getResources():
+        print("[MOCK] Context.getResources called")
+        return None
+
+    @staticmethod
+    def getPackageName():
+        print("[MOCK] Context.getPackageName called")
+        return None  # TODO get package name from buildozer.spec file
+
+# Now writing Knowledge from errors
+# notify.(int, Builder.build()) # must be int

android_notify/an_utils.py

@@ -0,0 +1,209 @@
+"""Collection of useful functions"""
+
+import inspect, os, re, traceback
+from .config import autoclass
+from .an_types import Importance
+from .config import (
+    get_python_activity_context, app_storage_path, ON_ANDROID,
+    BitmapFactory, BuildVersion, Bundle,
+    NotificationManagerClass, AndroidNotification, Intent, Settings, Uri, String, Manifest
+
+)
+
+if ON_ANDROID:
+    Color = autoclass('android.graphics.Color')
+else:
+    from .an_types import Color
+
+
+def can_accept_arguments(func, *args, **kwargs):
+    try:
+        sig = inspect.signature(func)
+        sig.bind(*args, **kwargs)
+        return True
+    except TypeError:
+        return False
+
+
+if ON_ANDROID:
+    context = get_python_activity_context()
+else:
+    context = None
+
+
+def get_android_importance(importance: Importance):
+    """
+    Returns Android Importance Values
+    :param importance: ['urgent','high','medium','low','none']
+    :return: Android equivalent int or empty str
+    """
+    if not ON_ANDROID:
+        return None
+    value = ''
+    if importance == 'urgent':
+        value = AndroidNotification.PRIORITY_HIGH if BuildVersion.SDK_INT <= 25 else NotificationManagerClass.IMPORTANCE_HIGH
+    elif importance == 'high':
+        value = AndroidNotification.PRIORITY_DEFAULT if BuildVersion.SDK_INT <= 25 else NotificationManagerClass.IMPORTANCE_DEFAULT
+    elif importance == 'medium':
+        value = AndroidNotification.PRIORITY_LOW if BuildVersion.SDK_INT <= 25 else NotificationManagerClass.IMPORTANCE_LOW
+    elif importance == 'low':
+        value = AndroidNotification.PRIORITY_MIN if BuildVersion.SDK_INT <= 25 else NotificationManagerClass.IMPORTANCE_MIN
+    elif importance == 'none':
+        value = '' if BuildVersion.SDK_INT <= 25 else NotificationManagerClass.IMPORTANCE_NONE
+
+    return value
+    # side-note 'medium' = NotificationCompat.PRIORITY_LOW and 'low' = NotificationCompat.PRIORITY_MIN # weird but from docs
+
+
+def generate_channel_id(channel_name: str) -> str:
+    """
+    Generate a readable and consistent channel ID from a channel name.
+
+    Args:
+        channel_name (str): The name of the notification channel.
+
+    Returns:
+        str: A sanitized channel ID.
+    """
+    # Normalize the channel name
+    channel_id = channel_name.strip().lower()
+    # Replace spaces and special characters with underscores
+    channel_id = re.sub(r'[^a-z0-9]+', '_', channel_id)
+    # Remove leading/trailing underscores
+    channel_id = channel_id.strip('_')
+    return channel_id[:50]
+
+
+def get_img_from_path(relative_path):
+    app_folder = os.path.join(app_storage_path(), 'app')
+    img_full_path = os.path.join(app_folder, relative_path)
+    if not os.path.exists(img_full_path):
+        print(f'\nImage: "{img_full_path}" Not Found, (Local images gotten from App Path)')
+        try:
+            print("- These are the existing files in your app Folder:")
+            print('[' + ', '.join(os.listdir(app_folder)) + ']\n')
+        except Exception as could_not_get_files_in_path_error:
+            print('Exception: ', could_not_get_files_in_path_error)
+            print("Couldn't get Files in App Folder")
+        return None
+    return get_bitmap_from_path(img_full_path)
+    # TODO test with a badly written Image and catch error
+
+
+def setLayoutText(layout, id, text, color):
+    # checked if self.title_color available before entering method
+    if id and text:
+        layout.setTextViewText(id, text)
+        if color:
+            layout.setTextColor(id, Color.parseColor(color))
+
+
+def get_bitmap_from_url(url, callback, logs):
+    """Gets Bitmap from url
+
+    Args:
+        :param url: img url
+        :param callback: function to be called after thread done, callback receives bitmap data as argument
+        :param logs:
+    """
+    if logs:
+        print("getting Bitmap from URL---")
+    try:
+        URL = autoclass('java.net.URL')
+        url = URL(url)
+        connection = url.openConnection()
+        connection.connect()
+        input_stream = connection.getInputStream()
+        bitmap = BitmapFactory.decodeStream(input_stream)
+        input_stream.close()
+        if bitmap:
+            callback(bitmap)
+        else:
+            print('Error No Bitmap for small icon ------------')
+    except Exception as extracting_bitmap_frm_URL_error:
+        callback(None)
+        # TODO get all types of JAVA Error that can fail here
+        print('Error Type ', extracting_bitmap_frm_URL_error)
+        print('Failed to get Bitmap from URL ', traceback.format_exc())
+
+
+def add_data_to_intent(intent, title):
+    """Persist Some data to notification object for later use"""
+    bundle = Bundle()
+    bundle.putString("title", title or 'Title Placeholder')
+    # bundle.putInt("notify_id", self.__id)
+    bundle.putInt("notify_id", 101)
+    intent.putExtras(bundle)
+
+
+def get_sound_uri(res_sound_name):
+    if not res_sound_name:  # Incase it's None
+        return None
+
+    package_name = context.getPackageName()
+    return Uri.parse(f"android.resource://{package_name}/raw/{res_sound_name}")
+
+
+def get_package_path():
+    """
+    Returns the directory path of this Python package.
+    Works on Android, Windows, Linux, macOS.
+    """
+    return os.path.dirname(os.path.abspath(__file__))
+
+
+def get_bitmap_from_path(img_full_path):
+    uri = Uri.parse(f"file://{img_full_path}")
+    return BitmapFactory.decodeStream(context.getContentResolver().openInputStream(uri))
+
+
+def icon_finder(icon_name):
+    """Get the full path to an icon file."""
+    try:
+        import pkg_resources
+        return pkg_resources.resource_filename(__name__, f"fallback-icons/{icon_name}")
+    except Exception:
+        # Fallback if pkg_resources not available
+        package_dir = get_package_path()
+        return os.path.join(package_dir, "fallback-icons", icon_name)
+
+
+def can_show_permission_request_popup():
+    """
+    Check if we can show permission request popup for POST_NOTIFICATIONS
+    :return: bool
+    """
+    if not ON_ANDROID:
+        return False
+
+    if BuildVersion.SDK_INT < 33:
+        return False
+
+    return context.shouldShowRequestPermissionRationale(Manifest.POST_NOTIFICATIONS)
+
+
+def open_settings_screen():
+    if not context:
+        print("android_notify - Can't open settings screen, No context [not On Android]")
+        return None
+    intent = Intent()
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    package_name = String(context.getPackageName())  # String() is very important else fails silently with a toast
+    # saying "The app wasn't found in the list of installed apps" - Xiaomi or "unable to find application to perform this action" - Samsung and Techno
+
+    if BuildVersion.SDK_INT >= 26:  # Android 8.0 - android.os.Build.VERSION_CODES.O
+        intent.setAction(Settings.ACTION_APP_NOTIFICATION_SETTINGS)
+        intent.putExtra(Settings.EXTRA_APP_PACKAGE, package_name)
+    elif BuildVersion.SDK_INT >= 22:  # Android 5.0 - Build.VERSION_CODES.LOLLIPOP
+        intent.setAction("android.settings.APP_NOTIFICATION_SETTINGS")
+        intent.putExtra("app_package", package_name)
+        intent.putExtra("app_uid", context.getApplicationInfo().uid)
+    else:  # Last Retort is to open App Settings Screen
+        intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+        intent.addCategory(Intent.CATEGORY_DEFAULT)
+        intent.setData(Uri.parse("package:" + package_name))
+
+    context.startActivity(intent)
+    return None
+
+    # https://stackoverflow.com/a/45192258/19961621

android_notify/base.py

@@ -0,0 +1,97 @@
+"""Assists Notification Class with Args keeps subclass cleaner"""
+from dataclasses import dataclass, fields
+import difflib
+from .styles import NotificationStyles
+# For Dev when creating new attr use have to set type for validate_args to work
+
+@dataclass
+class BaseNotification:
+    """Encapsulation"""
+
+    # Basic options
+    title: str = ''
+    message: str = ''
+    style: str = 'simple'
+
+    # Style-specific attributes
+    big_picture_path: str = ''
+    large_icon_path: str = ''
+    progress_max_value: int = 0
+    progress_current_value: float = 0.0 # Also Takes in Ints
+    body: str = ''
+    lines_txt: str = ''
+
+    # Notification Functions
+    name: str = ''
+    callback: object = None
+
+    # Advanced Options
+    id: int = 0
+    app_icon: str = 'Defaults to package app icon'
+    sub_text: str=''
+
+    # Channel related
+    channel_name: str = 'Default Channel'
+    """User visible channel name"""
+    channel_id: str = 'default_channel'
+    """Used to reference notification channel"""
+
+    silent: bool = False
+    logs: bool = False
+
+    # Custom Notification Attrs
+    title_color: str = ''
+    message_color: str = ''
+
+    def __init__(self, **kwargs):
+        """Custom init to handle validation before dataclass assigns values"""
+
+        # Validate provided arguments
+        self.validate_args(kwargs)
+
+        # Assign validated values using the normal dataclass behavior
+        for field_ in fields(self):
+            field_name = field_.name
+            setattr(self, field_name, kwargs.get(field_name, getattr(self, field_name)))
+
+    def validate_args(self, inputted_kwargs):
+        """Check for unexpected arguments and suggest corrections before Python validation"""
+        default_fields =  {field.name : field.type for field in fields(self)} #{'title': <class 'str'>, 'message': <class 'str'>,...
+        allowed_fields_keys = set(default_fields.keys())
+
+        # Identify invalid arguments
+        invalid_args = set(inputted_kwargs) - allowed_fields_keys
+        if invalid_args:
+            suggestions = []
+            for arg in invalid_args:
+                closest_match = difflib.get_close_matches(arg, allowed_fields_keys, n=1, cutoff=0.6)
+                if closest_match:
+                    suggestions.append(f"* '{arg}' is invalid -> Did you mean '{closest_match[0]}'?")
+                else:
+                    suggestions.append(f"* '{arg}' is not a valid argument.")
+
+            suggestion_text = '\n'.join(suggestions)
+            raise ValueError(f"Invalid arguments provided:\n{suggestion_text}")
+
+        # Validating types
+        for each_arg in inputted_kwargs.keys():
+            expected_type = default_fields[each_arg]
+            actual_value = inputted_kwargs[each_arg]
+
+            # Allow both int and float for progress_current_value
+            if each_arg == "progress_current_value":
+                if not isinstance(actual_value, (int, float)):
+                    raise TypeError(f"Expected '{each_arg}' to be int or float, got {type(actual_value)} instead.")
+            else:
+                if not isinstance(actual_value, expected_type):
+                    raise TypeError(f"Expected '{each_arg}' to be {expected_type}, got {type(actual_value)} instead.")
+
+        # Validate `style` values
+        style_values = [value for key, value in vars(NotificationStyles).items() if not key.startswith("__")]
+        if 'style' in inputted_kwargs and inputted_kwargs['style'] not in ['',*style_values]:
+            inputted_style=inputted_kwargs['style']
+            allowed_styles=', '.join(style_values)
+            raise ValueError(
+                f"Invalid style '{inputted_style}'. Allowed styles: {allowed_styles}"
+            )
+