actionstreamer 0.4.4__tar.gz

actionstreamer-0.4.4/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: actionstreamer
+Version: 0.4.4
+Summary: A library for the ActionStreamer API.
+Author: ActionStreamer
+Author-email: joe@actionstreamer.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pytz (>=2024.1,<2025.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: wmi (>=1.5.1,<2.0.0) ; sys_platform == "win32"
+Description-Content-Type: text/markdown
+
+# ActionStreamer
+
+A library for the ActionStreamer API.
+

actionstreamer-0.4.4/README.md

@@ -0,0 +1,3 @@
+# ActionStreamer
+
+A library for the ActionStreamer API.

actionstreamer-0.4.4/actionstreamer/CommonFunctions/CommonFunctions.py

@@ -0,0 +1,254 @@
+import sys
+import hashlib
+import hmac
+import uuid
+import time
+from datetime import datetime
+import requests
+import os
+import re
+
+import pytz
+import requests
+
+from ActionStreamer.Config import WebServiceConfig
+
+class StandardResult:
+
+    def __init__(self, code: int, description: str):
+        self.Code = code
+        self.Description = description
+        
+
+class switch(object):
+
+	def __init__(self, value):
+		self.value = value
+		self.fall = False
+
+	def __iter__(self):
+		"""Return the match method once, then stop"""
+		yield self.match
+		raise StopIteration
+    
+	def match(self, *args) -> bool:
+		"""Indicate whether or not to enter a case suite"""
+		if self.fall or not args:
+			return True
+		elif self.value in args:
+			self.fall = True
+			return True
+		else:
+			return False
+
+
+def get_exception_info() -> tuple[str, int] | tuple[None, None]:
+    exception_type, exception_object, exception_traceback = sys.exc_info()
+    if exception_traceback is not None:
+        filename = exception_traceback.tb_frame.f_code.co_filename
+        line_number = exception_traceback.tb_lineno
+        return filename, line_number
+    return None, None
+
+
+def get_line_number() -> int | None:
+    exception_type, exception_object, exception_traceback = sys.exc_info()
+    if exception_traceback is not None:
+        return exception_traceback.tb_lineno
+    return None
+
+
+def log_to_console(message: str, agent_name='') -> None:
+    # Get the current UTC time
+    utc_now = datetime.now(pytz.utc)
+    
+    # Format the UTC time
+    utc_time_formatted = utc_now.strftime("%Y-%m-%d %H:%M:%S UTC")
+    
+    # Prepend the formatted UTC time to the string
+    if (agent_name):
+        result_string = f"[{utc_time_formatted}]: [{agent_name}]: {message}"
+    else:
+        result_string = f"[{utc_time_formatted}]: {message}"
+    
+    # Print the result to standard output
+    print(result_string)
+
+
+def send_signed_request(ws_config: WebServiceConfig, method: str, url: str, path: str, headers: dict = None, parameters: str = None, body: str = None) -> tuple[int, str]:
+    
+    try:
+        if headers is None:
+            headers = {"Content-Type": "application/json"}
+        elif isinstance(headers, str):
+            headers = dict(header.strip().split(':', 1) for header in headers.split('\n'))
+
+        nonce = str(uuid.uuid4())
+        timestamp = str(int(time.time()))
+
+        headers['X-Nonce'] = nonce
+        headers['X-Timestamp'] = timestamp
+        headers['Authorization'] = 'HMAC-SHA256 ' + ws_config.access_key
+        headers['X-AccessKey'] = ws_config.access_key
+
+        # Generate HMAC signature
+        signature, string_to_sign = get_hmac_signature(ws_config.secret_key, method, path, headers, parameters, body)
+
+        # Include signature in headers
+        headers['X-Signature'] = signature
+
+        verify = not ws_config.ignore_ssl
+        
+        if method.upper() == 'POST':
+            response = requests.post(url, headers=headers, data=body, verify=verify, timeout=ws_config.timeout)
+        elif method.upper() == 'GET':
+            response = requests.get(url, headers=headers, params=parameters, verify=verify, timeout=ws_config.timeout)
+        if method.upper() == 'PUT':
+            response = requests.put(url, headers=headers, data=body, verify=verify, timeout=ws_config.timeout)
+        elif method.upper() == 'PATCH':
+            response = requests.patch(url, headers=headers, data=body, params=parameters, verify=verify, timeout=ws_config.timeout)
+        elif method.upper() == 'DELETE': 
+            response = requests.delete(url, headers=headers, params=parameters, verify=verify, timeout=ws_config.timeout)
+
+        status_code = response.status_code
+        response_string = response.content.decode('utf-8')
+
+    except Exception as ex:
+        filename, line_number = get_exception_info()
+        if filename is not None and line_number is not None:
+            print(f"Exception occurred at line {line_number} in {filename}")
+        print(ex)
+        status_code = -1
+        response_string = "Error in send_signed_request"
+
+    return status_code, response_string
+   
+
+def get_hmac_signature(secret_key: str, method: str, path: str, headers, parameters: dict, body: str = None)-> tuple[str, str] | None:
+    
+    try:
+        if 'Content-Type' in headers:
+            del headers['Content-Type']
+
+        headerString = dictionary_to_string(headers)
+        parameterString = dictionary_to_string(parameters)
+
+        # Path should be in the format /v1/event
+        if not path.startswith('/'):
+            path = '/' + path
+
+        if path.endswith('/') and len(path) > 1:
+            path = path[:-1]
+
+        string_to_sign = '\n'.join([method, path, headerString, parameterString, body if body else ''])
+
+        string_to_sign = string_to_sign.strip()
+        #log_to_console("stringToSign: " + string_to_sign)
+        
+        # Generate the HMAC SHA256 signature
+        hmac_signature = hmac.new(secret_key.encode('utf-8'), string_to_sign.encode('utf-8'), hashlib.sha256)
+
+        # Convert the HMAC signature to hexadecimal
+        return hmac_signature.hexdigest(), string_to_sign
+
+    except Exception as ex:
+        filename, line_number = get_exception_info()
+        if filename is not None and line_number is not None:
+            print(f"Exception occurred at line {line_number} in {filename}")
+        print(ex)
+
+
+def dictionary_to_string(dictionary: dict) -> str:
+
+    result = ''
+
+    try:
+        sorted_keys = sorted(dictionary.keys())
+        
+        for key in sorted_keys:
+            result += f"{key}: {dictionary[key]}\n"
+        
+    except Exception as ex:
+        filename, line_number = get_exception_info()
+        #if filename is not None and line_number is not None:
+            #print(f"Exception occurred at line {line_number} in {filename}")
+        #print(ex)
+    
+    return result
+
+
+def upload_file_to_s3(file_path: str, signed_url: str) -> int:
+
+    retry = True
+    result = 0
+
+    while retry:
+
+        try:
+            with open(file_path, 'rb') as file:
+                response = requests.put(signed_url, data=file)
+            
+            if response.status_code == 200:
+                retry = False
+                result = 0
+            else:
+                print(f"Error uploading file to S3. Status code: {response.status_code}")
+                result = -1
+            
+        except Exception as ex:
+            print("Exception occurred while uploading file to S3:", str(ex))
+            result = -2
+        
+    return result
+
+
+def get_sha256_hash_for_file(file_path: str) -> str:
+    # Initialize the hash object (SHA-256 is used in this example)
+    hash_object = hashlib.sha256()
+
+    # Open the file in binary mode to read its contents
+    with open(file_path, "rb") as file:
+        # Read the file in chunks to avoid loading the entire file into memory
+        for chunk in iter(lambda: file.read(4096), b""):
+            hash_object.update(chunk)
+
+    # Get the hexadecimal representation of the hash
+    file_hash = hash_object.hexdigest()
+    
+    return file_hash
+
+
+def create_folders(path: str) -> None:
+    # Split the path into individual folders
+    folders = path.split(os.sep)
+
+    # Initialize the base folder to the root of the file system
+    base_folder = ""
+
+    # Loop through each folder in the path
+    for folder in folders:
+        # Append the current folder to the base folder
+        base_folder = os.path.join(base_folder, folder)
+
+        # Check if the current folder exists
+        if not os.path.exists(base_folder):
+            # If not, create the folder
+            os.makedirs(base_folder)
+
+
+def get_cpu_frequency() -> float:
+    with open("/proc/cpuinfo") as f:
+        cpuinfo = f.read()
+    # Find the first occurrence of "cpu MHz"
+    match = re.search(r"cpu MHz\s+:\s+(\d+\.\d+)", cpuinfo)
+    if match:
+        return float(match.group(1))
+    else:
+        raise RuntimeError("Unable to find CPU frequency in /proc/cpuinfo")
+
+
+def get_clock_cycles_per_millisecond() -> float:
+    frequency_mhz = get_cpu_frequency()
+    frequency_hz = frequency_mhz * 1_000_000
+    cycles_per_millisecond = frequency_hz / 1_000
+    return cycles_per_millisecond

actionstreamer-0.4.4/actionstreamer/CommonFunctions/Wifi/Wifi.py

@@ -0,0 +1,93 @@
+import json
+import subprocess
+
+
+def add_wifi_connection(ssid: str, password: str, connection_name: str, priority=1) -> None:
+    
+    try:
+        subprocess.run(['sudo', 'nmcli', 'connection', 'add', 'type', 'wifi', 'ifname', 'wlan0', 'con-name', connection_name, 'ssid', ssid, 'connection.autoconnect-priority', str(priority)], check=True)
+        subprocess.run(['sudo', 'nmcli', 'connection', 'modify', connection_name, 'wifi-sec.key-mgmt', 'wpa-psk'], check=True)
+        subprocess.run(['sudo', 'nmcli', 'connection', 'modify', connection_name, 'wifi-sec.psk', password], check=True)
+
+        # Activate the connection
+        subprocess.run(['sudo', 'nmcli', 'connection', 'up', connection_name], check=True)
+        #print(f"Added and activated new connection: {connection_name}")
+        
+    except subprocess.CalledProcessError as ex:
+        print(f"Failed to add connection: {connection_name}. Error: {ex}")
+
+
+def remove_wifi_connection(ssid: str) -> None:
+    
+    try:
+        subprocess.run(['sudo', 'nmcli', 'connection', 'delete', ssid], check=True)
+        print(f"Removed existing connection: {ssid}")
+    except subprocess.CalledProcessError as ex:
+        print(f"Failed to remove connection: {ssid}. It might not exist.")
+
+
+def set_wifi_priority(ssid: str, priority: int) -> None:
+
+    # Example usage:
+    # set_wifi_priority("YourSSID", 100)
+
+    try:
+        # Get the UUID of the connection
+        result = subprocess.run(
+            ['nmcli', '-g', 'uuid', 'connection', 'show', ssid],
+            capture_output=True, text=True, check=True
+        )
+        uuid = result.stdout.strip()
+
+        if not uuid:
+            raise ValueError(f"Connection {ssid} not found.")
+
+        # Set the autoconnect priority
+        subprocess.run(
+            ['nmcli', 'connection', 'modify', uuid, 'connection.autoconnect-priority', str(priority)],
+            check=True
+        )
+
+        # Restart Network Manager to apply the changes
+        subprocess.run(['sudo', 'systemctl', 'restart', 'NetworkManager'], check=True)
+
+        print(f"Priority for {ssid} set to {priority}.")
+
+    except subprocess.CalledProcessError as ex:
+        print(f"An error occurred while running nmcli: {ex}")
+
+    except ValueError as ex:
+        print(ex)
+
+
+def back_up_connections(backup_file_path: str) -> None:
+    # Backup all connection data to a JSON file
+    try:
+        result = subprocess.run(['sudo', 'nmcli', '--json', 'connection', 'export'], capture_output=True, text=True, check=True)
+        connections_data = json.loads(result.stdout)
+        
+        with open(backup_file_path, 'w') as f:
+            json.dump(connections_data, f, indent=4)
+        
+        print(f"Connections backed up to {backup_file_path}.")
+
+    except subprocess.CalledProcessError as ex:
+        print(f"Failed to backup connections. Error: {ex}")
+
+
+def restore_connections(backup_file_path: str) -> None:
+    # Restore all connections from a JSON backup file
+    try:
+        with open(backup_file_path, 'r') as f:
+            connections_data = json.load(f)
+
+        subprocess.run(['sudo', 'nmcli', 'connection', 'delete', 'id', 'all'], check=True)
+
+        for connection in connections_data:
+            subprocess.run(['sudo', 'nmcli', 'connection', 'import', 'json', json.dumps(connection)], check=True)
+        
+        print(f"Connections restored from {backup_file_path}.")
+
+    except (subprocess.CalledProcessError, json.JSONDecodeError) as ex:
+        print(f"Failed to restore connections. Error: {ex}")
+        

actionstreamer-0.4.4/actionstreamer/CommonFunctions/Wifi/__init__.py

@@ -0,0 +1,4 @@
+from .Wifi import add_wifi_connection, remove_wifi_connection, set_wifi_priority, back_up_connections, restore_connections
+
+
+__all__ = ['add_wifi_connection', 'remove_wifi_connection', 'set_wifi_priority', 'back_up_connections', 'restore_connections']

actionstreamer-0.4.4/actionstreamer/CommonFunctions/__init__.py

@@ -0,0 +1,4 @@
+from .CommonFunctions import StandardResult, switch, get_exception_info, get_line_number, log_to_console, send_signed_request, get_hmac_signature, dictionary_to_string, upload_file_to_s3, get_sha256_hash_for_file, create_folders
+from . import Wifi
+
+__all__ = ['StandardResult', 'switch', 'get_exception_info', 'get_line_number', 'log_to_console', 'send_signed_request', 'get_hmac_signature', 'dictionary_to_string', 'upload_file_to_s3', 'get_sha256_hash_for_file', 'Wifi', 'create_folders']

actionstreamer-0.4.4/actionstreamer/Config/Config.py

@@ -0,0 +1,127 @@
+import os
+import platform
+
+class WebServiceConfig:
+    
+    """
+    Configuration for connecting to the web service.
+
+    Attributes:
+        access_key (str): The access key for authentication.
+        secret_key (str): The secret key for authentication.
+        base_url (str): The base URL of the web service.
+        timeout (int): The timeout for requests in seconds.
+        ignore_ssl (bool): Whether to ignore SSL verification.
+    """        
+    def __init__(self, access_key: str, secret_key: str, base_url: str, timeout: int = 30, ignore_ssl: bool = False):
+        """
+        Initialize the WebServiceConfig.
+
+        :param access_key: The access key for authentication.
+        :param secret_key: The secret key for authentication.
+        :param base_url: The base URL of the web service.
+        :param timeout: The timeout for requests in seconds (default is 30).
+        :param ignore_ssl: Whether to ignore SSL verification (default is False).
+        """
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.base_url = base_url
+        self.timeout = timeout
+        self.ignore_ssl = ignore_ssl
+
+class LogConfig:
+
+    def __init__(self, ws_config: WebServiceConfig, device_name: str, agent_type: str, agent_version: str, agent_index: int, process_id: int):
+        self.ws_config = ws_config
+        self.device_name = device_name
+        self.agent_type = agent_type
+        self.agent_version = agent_version
+        self.agent_index = agent_index
+        self.process_id = process_id
+        
+
+def is_windows() -> bool:
+    return platform.system() == 'Windows'
+
+
+def get_config_folder_path(app_name: str, base_folder_path: str = '') -> str:
+
+    if is_windows():
+        username = os.getlogin()
+        config_dir = os.path.join('C:\\Users', username, 'AppData', 'Roaming', app_name, "config")
+        # If a virtual environment is used, the path will be in something like:
+        # C:\Users\Username\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\LocalCache\Roaming
+
+    else:
+        if base_folder_path:
+            config_dir = os.path.join(base_folder_path, ".config", app_name)
+        else:
+            config_dir = os.path.expanduser(os.path.join("~", ".config", app_name))
+
+    # Create the directory if it doesn't exist
+    if not os.path.exists(config_dir):
+        os.makedirs(config_dir)
+
+    return config_dir
+
+
+def get_appdata_folder_path(app_name: str, base_folder_path: str = '') -> str:
+
+    if is_windows():
+        username = os.getlogin()
+        appdata_folder_path = os.path.join('C:\\Users', username, 'AppData', 'Roaming', app_name)
+        # If a virtual environment is used, the path will be in something like:
+        # C:\Users\Username\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\LocalCache\Roaming
+    else:
+        if base_folder_path:
+            appdata_folder_path = os.path.join(base_folder_path, ".appdata", app_name)
+        else:
+            appdata_folder_path = os.path.expanduser(os.path.join("~", ".appdata", app_name))
+
+    # Create the directory if it doesn't exist
+    if not os.path.exists(appdata_folder_path):
+        os.makedirs(appdata_folder_path)
+
+    return appdata_folder_path
+
+
+def get_config_value(config_folder_path: str, name: str, default_value: str = '') -> str | None:
+
+    if not os.path.exists(config_folder_path):
+        os.makedirs(config_folder_path)
+
+    file_path = os.path.join(config_folder_path, name + '.txt')
+    
+    if not os.path.exists(file_path):
+        with open(file_path, 'w') as file:
+            file.write(default_value)
+
+    try:
+        with open(file_path, 'r') as file:
+            contents = file.read()
+        return contents
+    except FileNotFoundError:
+        print(f"File '{name}' not found in the specified folder '{config_folder_path}'")
+        return None
+    except Exception as ex:
+        print(f"Error occurred while reading '{name}': {ex}")
+        return None
+
+
+def set_config_value(config_folder_path: str, name: str, value: str) -> None:
+
+    if not os.path.exists(config_folder_path):
+        os.makedirs(config_folder_path)
+
+    # Create the directory if it doesn't exist
+    if not os.path.exists(config_folder_path):
+        os.makedirs(config_folder_path)
+
+    file_path = os.path.join(config_folder_path, name + '.txt')
+
+    try:
+        with open(file_path, 'w') as file:
+            file.write(value)
+        print(f"Successfully set the value in '{name}'")
+    except Exception as ex:
+        print(f"Error occurred while setting value in '{name}': {ex}")

actionstreamer-0.4.4/actionstreamer/Config/__init__.py

@@ -0,0 +1,4 @@
+from .Config import WebServiceConfig, LogConfig, is_windows, get_config_folder_path, get_appdata_folder_path, get_config_value, set_config_value
+
+
+__all__ = ['WebServiceConfig', 'LogConfig', 'is_windows', 'get_config_folder_path', 'get_appdata_folder_path', 'get_config_value', 'set_config_value']

actionstreamer-0.4.4/actionstreamer/Device/Device.py

@@ -0,0 +1,143 @@
+import getopt
+import socket
+import sys
+import platform
+import subprocess
+
+def process_cpuinfo() -> str:
+
+    device_name = "0000000000000000"
+
+    try:
+        optlist, args = getopt.getopt(sys.argv[1:], 'm:')
+
+    except getopt.GetoptError as err:
+        # Print help information and exit:
+        print(str(err))    # This will print something like "option -a not recognized"
+        return device_name
+
+    for option, argument in optlist:
+        if option == "-m":
+            device_name = argument
+                              
+    return device_name
+
+
+def get_serial_number() -> str:
+
+    serial_number = ""
+    manufacturer = ""
+    manufacturer, return_code = get_manufacturer()
+
+    if platform.system() == "Windows":
+        serial_number = get_cpu_serial_number_windows()
+    
+    elif platform.system() == "Linux":
+        serial_number =  get_cpu_serial_number_linux()
+    
+    else:
+        serial_number = ""
+
+    return manufacturer + "_" + serial_number
+
+
+def get_ip_address() -> str:
+
+    try:
+        # Get the local hostname
+        hostname = socket.gethostname()
+        # Get the IP address associated with the hostname
+        ip_address = socket.gethostbyname(hostname)
+    except socket.error:
+        # If an error occurs, return a default IP address
+        ip_address = "0.0.0.0"
+            
+    return ip_address
+
+
+def get_cpu_serial_number_windows() -> str:
+
+    try:
+        import wmi
+        wmi_object = wmi.WMI()
+        for processor in wmi_object.Win32_Processor():
+            return processor.ProcessorId.strip()
+        
+    except Exception as ex:
+        return str(ex)
+
+
+def get_cpu_serial_number_linux() -> str:
+
+    try:
+        with open('/proc/cpuinfo', 'r') as f:
+            for line in f:
+                if line.strip().startswith("Serial"):
+                    return line.strip().split(":")[1].strip()
+                
+    except Exception as ex:
+        return str(ex)
+    
+
+def get_manufacturer() -> tuple[str, int]:
+
+    if platform.system() == "Windows":
+        return get_manufacturer_windows()
+    else:
+        return get_manufacturer_linux()
+
+
+def get_manufacturer_windows() -> tuple[str, int]:
+    try:
+        import wmi
+        w = wmi.WMI()
+        for processor in w.Win32_Processor():
+            return parse_manufacturer(processor.Manufacturer.strip()), 0
+    except Exception as e:
+        print(f"Exception in get_manufacturer_windows: {e}")
+        return "", 1
+
+    return "", 1
+
+
+def get_manufacturer_linux() -> tuple[str, int]:
+    try:
+        with open("/proc/cpuinfo", "r") as f:
+            for line in f:
+                if line.startswith("Model"):
+                    model = line.split(":")[1].strip()
+                    if "Raspberry Pi" in model:
+                        return parse_raspberry_pi_model(model), 0
+        # Fall back to using dmidecode if not a Raspberry Pi
+        result = subprocess.run(['dmidecode', '-t', 'processor'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        for line in result.stdout.splitlines():
+            if line.strip().startswith("Manufacturer"):
+                return parse_manufacturer(line.split(":")[1].strip()), 0
+    except Exception as e:
+        print(f"Exception in get_manufacturer_linux: {e}")
+        return "", 1
+
+    return "", 1
+
+
+def parse_raspberry_pi_model(model: str) -> str:
+    
+    if "Raspberry Pi" in model:
+        parts = model.split()
+        if len(parts) >= 3 and parts[2].isdigit():
+            return f"RPi{parts[2]}"
+    return model
+
+
+def parse_manufacturer(manufacturer: str) -> str:
+
+    if "Intel" in manufacturer:
+        return "Intel"
+    elif "AMD" in manufacturer:
+        return "AMD"
+    elif "Broadcom" in manufacturer:
+        return "Broadcom"
+    elif "ARM" in manufacturer:
+        return "ARM"
+    else:
+        return manufacturer

actionstreamer-0.4.4/actionstreamer/Device/__init__.py

@@ -0,0 +1,4 @@
+from .Device import get_serial_number, get_ip_address, get_manufacturer
+
+
+__all__ = ['get_serial_number', 'get_ip_address', 'get_manufacturer']