speedify.py

#!/usr/bin/python3
# Uses Python 3.7

import json
import logging
import subprocess
import os
import platform
import socket
from enum import Enum
from functools import wraps

logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

"""
.. module:: speedify
   :synopsis: Python wrapper for the Speedify CLI (Command Line Interface)

This module provides a comprehensive Python interface to control Speedify, a bonding VPN service.
It wraps nearly all functionality available in the Speedify CLI, allowing programmatic control of:
- Connection management (connect, disconnect, server selection)
- Authentication (login, logout, OAuth)
- Settings configuration (mode, encryption, transport, etc.)
- Adapter management (priority, rate limits, data limits)
- Privacy settings (killswitch, DNS leak protection)
- Traffic rules (streaming, bypass, fixed delay)
- Network sharing (Pair & Share)
- Statistics and monitoring

All functions communicate with the Speedify daemon via the speedify_cli executable using subprocess calls.
Responses are returned as parsed JSON dictionaries. Errors raise SpeedifyError or SpeedifyAPIError exceptions.

The CLI executable path is automatically detected on Windows, macOS, and Linux. You can override the default
by setting the SPEEDIFY_CLI environment variable or calling set_cli() with a custom path.

Example:
    import speedify

    # Check current state
    state = speedify.show_state()

    # Connect to closest server
    speedify.connect_closest()

    # Change settings
    speedify.mode("speed")
    speedify.encryption(True)

    # Disconnect
    speedify.disconnect()
"""


# ============================================================================
# Utility Functions (merged from utils.py and speedifyutil.py)
# ============================================================================

def ping_internet(host="8.8.8.8", port=53, timeout=3):
    """
    Check if internet connection is available by connecting to a host.

    :param host: Host to connect to (default: 8.8.8.8 - Google Public DNS)
    :param port: Port to connect to (default: 53 - DNS)
    :param timeout: Connection timeout in seconds (default: 3)
    :return: True if connection successful, False otherwise

    Example:
        >>> ping_internet()
        True
        >>> ping_internet(host="1.1.1.1", port=80)
        True
    """
    try:
        socket.setdefaulttimeout(timeout)
        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
        return True
    except socket.error as ex:
        logging.warning(str(ex))
        return False


def use_shell():
    """
    Determine if shell=True should be used for subprocess calls.

    :return: True on Windows, False on macOS/Linux

    This is needed because Windows requires shell=True for some commands,
    while Unix-like systems work better with shell=False.
    """
    if platform.system().lower() == "darwin":
        return False
    if platform.system().lower() == "linux":
        return False
    else:
        return True


def confirm_state_speedify(state):
    """
    Confirm whether Speedify is in the specified state.

    :param state: Expected State enum value
    :return: True if Speedify is in the specified state, False otherwise

    Example:
        >>> confirm_state_speedify(State.CONNECTED)
        True
    """
    desc = show_state()
    if state == desc:
        return True
    else:
        logging.error("confirmStateSpeedify Failed command results: " + str(desc))
        return False


def list_servers_speedify(public=True, private=False, excludeTest=True):
    """
    Get a flattened list of Speedify server tags.

    :param public: Include public servers (default: True)
    :param private: Include private/dedicated servers (default: False)
    :param excludeTest: Exclude servers with '-test' in the name (default: True)
    :return: List of server tags, or "ERROR" on failure

    Example:
        >>> servers = list_servers_speedify()
        >>> 'us-nyc' in servers
        True
    """
    try:
        serverlist = []
        jret = show_servers()
        if public:
            if "public" in jret:
                for server in jret["public"]:
                    serverlist.append(server["tag"])

        if private:
            if "private" in jret:
                for server in jret["private"]:
                    serverlist.append(server["tag"])
        if excludeTest:
            # servers with "test" in the name are bad news
            serverlist2 = [x for x in serverlist if "-test" not in x]
            serverlist = serverlist2
        return serverlist
    except SpeedifyError as err:
        logging.error("Failed to get server list: " + str(err))
        return "ERROR"


def using_speedify(destination="8.8.8.8"):
    """
    Check if internet traffic is really going through Speedify.

    Uses traceroute/mtr to verify that traffic is passing through 10.202.0.1
    (the Speedify virtual adapter IP).

    :param destination: Destination IP to trace (default: 8.8.8.8)
    :return: True if traffic is going through Speedify, False otherwise

    Example:
        >>> using_speedify()
        True
    """
    tracert = ["traceroute", "-m", "2", destination]
    if platform.system() == "Windows":
        tracert = ["tracert", "-h", "1", "-d", destination]
    elif platform.system() == "Linux":
        tracert = ["mtr", "-m", "2", "-c", "2", "--report", destination]
    try:
        result = subprocess.run(tracert, stdout=subprocess.PIPE, shell=use_shell())
    except FileNotFoundError as e:
        logging.error(e)
        raise e
    resultstr = result.stdout.decode("utf-8")
    if "10.202.0.1" in resultstr:
        return True
    else:
        return False


# ============================================================================
# Enums and Exception Classes
# ============================================================================

class State(Enum):
    """Enum of speedify states."""

    LOGGED_OUT = 0
    LOGGING_IN = 1
    LOGGED_IN = 2
    AUTO_CONNECTING = 3
    CONNECTING = 4
    DISCONNECTING = 5
    CONNECTED = 6
    OVERLIMIT = 7
    UNKNOWN = 8


class Priority(Enum):
    """Enum of speedify connection priorities."""

    AUTOMATIC = "automatic"
    ALWAYS = "always"
    BACKUP = "backup"
    SECONDARY = "secondary"
    NEVER = "never"


class SpeedifyError(Exception):
    """Generic error thrown by library."""

    def __init__(self, message):
        self.message = message


class SpeedifyAPIError(SpeedifyError):
    """Error thrown if speedify gave a bad json response."""

    def __init__(self, error_code, error_type, error_message):
        self.error_code = error_code
        self.error_type = error_type
        self.error_message = error_message
        self.message = error_message


_cli_path = None


def set_cli(new_cli_path):
    """Change the path to the cli after importing the module.
    The path defaults to the cli's default install location.

    :param new_cli_path:  Full path to speedify_cli.
    :type new_cli_path: str
    """
    global _cli_path
    _cli_path = new_cli_path


def get_cli():
    """
    :returns:  str -- The full path to the speedify cli.
    """
    global _cli_path
    if (_cli_path == None) or (_cli_path == ""):
        _cli_path = _find_cli()
    return _cli_path


def find_state_for_string(mystate):
    """
    Converts a string representation of a Speedify state to a State enum.

    :param mystate: String representation of the state (case-insensitive).
    :type mystate: str
    :returns: speedify.State -- The corresponding State enum value.
    :raises KeyError: If the state string is not a valid State enum value.
    """
    return State[str(mystate).upper().strip()]


def exception_wrapper(argument):
    """
    Decorator that wraps functions to provide standardized error logging for SpeedifyError exceptions.

    This decorator catches SpeedifyError exceptions, logs them with a contextual message,
    and then re-raises the exception. It's applied to most public API functions to ensure
    consistent error handling and logging throughout the module.

    :param argument: Contextual error message prefix to use when logging errors.
    :type argument: str
    :returns: function -- The decorated function with error handling.

    Example:
        @exception_wrapper("Failed to connect")
        def connect(server=""):
            # Function implementation
            pass
    """
    def decorator(function):
        @wraps(function)
        def wrapper(*args, **kwargs):
            try:
                result = function(*args, **kwargs)
                return result
            except SpeedifyError as err:
                logger.error(argument + ": " + err.message)
                raise err

        return wrapper

    return decorator


# Functions for controlling Speedify State


@exception_wrapper("Failed to connect")
def connect(server: str = ""):
    """
    connect(server="")
    Tell Speedify to connect. Returns serverInformation if success, raises Speedify if unsuccessful.
    See show_servers() for the list of servers available.

    Example:
        connect()
        connect("us nyc 11") # server numbers may change, use show_servers()

    :param server: Server to connect to.
    :type server: str
    :returns:  dict -- :ref:`JSON currentserver <connect>` from speedify.
    """
    args = ["connect"] + server.split()
    return _run_speedify_cmd(args)


def connect_closest():
    """Connects to the closest server

    :returns:  dict -- :ref:`JSON currentserver <connect>` from speedify.
    """
    return connect("closest")


def connect_public():
    """Connects to the closest public server

    :returns:  dict -- :ref:`JSON currentserver <connect>` from speedify.
    """
    return connect("public")


def connect_private():
    """Connects to the closest private server

    :returns:  dict -- :ref:`JSON currentserver <connect>` from speedify.
    """
    return connect("private")


def connect_p2p():
    """Connects to a server that allows p2p traffic

    :returns:  dict -- :ref:`JSON currentserver <connect>` from speedify.
    """
    return connect("p2p")


def connect_country(country: str = "us"):
    """Connects to a server via the 2 letter country code
    See show_servers() for the list of servers available.

    :param country: 2 letter country code.
    :type country: str
    :returns:  dict -- :ref:`JSON currentserver <connect>` from speedify.
    """
    return connect(country)


def connect_last():
    """Connects to the last server

    :returns:  dict -- :ref:`JSON currentserver <connect>` from speedify.
    """
    return connect("last")


@exception_wrapper("Disconnect failed")
def disconnect():
    """
    disconnect()
    Disconnects. Waits for disconnect to complete

    :returns: bool -- TRUE if disconnect succeeded
    """
    _run_speedify_cmd(["disconnect"])
    return True


@exception_wrapper("Failed to set connect method")
def connectmethod(method, country="us", city=None, num=None):
    """
    connectmethod(method, country="us", city=None, num=None)
    Sets the default connectmethod of --
        closest
        public
        private
        p2p
        country (in which case country is required)

    :param method: The connect method.
    :type method: str
    :param country: 2 letter country code.
    :type country: str
    :param city: The (optional) city the server is located.
    :type city: str
    :param num: The (optional) server number.
    :type num: int
    :returns:  dict -- :ref:`JSON connectmethod <connectmethod>` from speedify.
    """
    args = ["connectmethod"]
    if method == "dedicated":
        method = "private"
    if method == "country":
        args.append(country)
        if city != None:
            args.append(city)
            if num != None:
                args.append(num)
    elif method:
        args.append(method)
    resultjson = _run_speedify_cmd(args)
    return resultjson


def connectmethod_as_string(connectMethodObject, hypens=True):
    """
    Converts a connectmethod JSON object to a formatted string.

    Takes the JSON object returned by show_connectmethod() and converts it to a string
    representation. The separator can be either hyphens (for "us-nova-2" style strings)
    or spaces (for "us nova 2" style strings suitable for command line arguments).

    Example:
        method_obj = show_connectmethod()
        # Returns "us-nova-2" with hyphens
        hyphenated = connectmethod_as_string(method_obj, hypens=True)
        # Returns "us nova 2" with spaces
        spaced = connectmethod_as_string(method_obj, hypens=False)

    :param connectMethodObject: The JSON object returned by show_connectmethod().
    :type connectMethodObject: dict
    :param hypens: If True, use hyphens as separator; if False, use spaces.
    :type hypens: bool
    :returns: str -- Formatted connection method string.
    """
    sep = " "
    if hypens:
        sep = "-"
    ret = connectMethodObject["connectMethod"]
    if ret == "country":
        ret = str(connectMethodObject["country"])
        if connectMethodObject["city"]:
            ret = ret + sep + str(connectMethodObject["city"])
            if connectMethodObject["num"]:
                ret = ret + sep + str(connectMethodObject["num"])
    return ret


@exception_wrapper("Failed to login")
def login(user, password):
    """
    login(user, password)
    Login. Returns a State. State object will hold
    information on the success of this command.

    :param user: username
    :type user: str
    :param password: password
    :type password: str
    :returns:  speedify.State -- The speedify state enum.
    """
    args = ["login", user, password]
    resultjson = _run_speedify_cmd(args)
    return find_state_for_string(resultjson["state"])


@exception_wrapper("Failed to login")
def login_auto():
    """
    login()
    Attempt to login automatically.
    Returns a state indicating success category.

    :returns:  speedify.State -- The speedify state enum.
    """
    resultjson = _run_speedify_cmd(["login", "auto"])
    return find_state_for_string(resultjson["state"])


@exception_wrapper("Failed to login")
def login_oauth(token: str):
    """
    login_oauth(token)
    Attempt to login via an oauth token.
    Returns a state indicating success category.

    :param token: The oauth token.
    :type token: str
    :returns:  speedify.State -- The speedify state enum.
    """
    resultjson = _run_speedify_cmd("login", "oauth", token)
    return find_state_for_string(resultjson["state"])


@exception_wrapper("Failed to logout")
def logout():
    """
    logout()
    logout.  returns the state, desc=LOGGED_OUT is a success

    :returns:  speedify.State -- The speedify state enum.
    """
    jret = _run_speedify_cmd(["logout"])
    return find_state_for_string(jret["state"])


@exception_wrapper("Failed to refresh OAuth token")
def refresh_oauth(token: str):
    """
    refresh_oauth(token)
    Accepts a new security token for the same user to be used when communicating with servers.
    If changing users, use login_oauth() instead.

    Example:
        refresh_oauth("abdef1234567890")

    :param token: The new OAuth access token.
    :type token: str
    :returns:  dict -- JSON response from speedify.
    """
    return _run_speedify_cmd(["refresh", "oauth", token])


def esni(is_on: bool = True):
    """
    esni(is_on)
    Turn esni functionality on or off.

    :param is_on: Whether esni should be on... or not.
    :type is_on: bool
    """
    if is_on is True:
        is_on = "on"
    elif is_on is False:
        is_on = "off"
    else:
        raise ValueError("is_on neither True nor False")
    return _run_speedify_cmd(["esni", is_on])


def headercompression(is_on: bool = True):
    """
    headercompression(is_on)
    Turn header compression on or off.

    :param is_on: Whether headercompression should be on... or not.
    :type is_on: bool
    """
    if is_on is True:
        is_on = "on"
    elif is_on is False:
        is_on = "off"
    else:
        raise ValueError("is_on neither True nor False")
    return _run_speedify_cmd(["headercompression", is_on])


def gateway(uri: str):
    """
    gateway(uri)

    Set the gateway uri.

    :param uri: The gateway uri.
    :type uri: str
    """
    return _run_speedify_cmd(["gateway", uri])


def daemon(method: str):
    """
    daemon(method)
    Call `method` on the daemon. Only "exit" is supported.

    :param method: The method to call. Only "exit" is available.
    """
    return _run_speedify_cmd(["daemon", method])


#
# Getter functions
#


@exception_wrapper("Failed to show server list")
def show_servers():
    """
    show_servers()
    Returns all the servers, public and private

    :returns:  dict -- :ref:`JSON server list <show-servers>` from speedify.
    """
    return _run_speedify_cmd(["show", "servers"])


@exception_wrapper("Failed to show privacy")
def show_privacy():
    """
    show_privacy()
    Returns privacy settings

    :returns:  dict -- dict -- :ref:`JSON privacy <show-privacy>` from speedify.
    """
    return _run_speedify_cmd(["show", "privacy"])


@exception_wrapper("Failed to set advanced ISP stats")
def privacy_advanced_isp_stats(is_on: bool):
    """
    privacy_advanced_isp_stats(is_on)
    Enables or disables advanced ISP statistics. When enabled, extra stats are available from some ISPs (e.g., Starlink).

    Example:
        privacy_advanced_isp_stats(True)

    :param is_on: Enable (True) or disable (False) advanced ISP stats.
    :type is_on: bool
    :returns:  dict -- JSON privacy settings.
    """
    return _run_speedify_cmd(["privacy", "advancedIspStats", "on" if is_on else "off"])


@exception_wrapper("Failed to set API protection")
def privacy_api_protection(is_on: bool):
    """
    privacy_api_protection(is_on)
    Enables or disables protection on the Speedify API port. When disabled, speedify_cli can control a remote Speedify installation.

    Example:
        privacy_api_protection(True)

    :param is_on: Enable (True) or disable (False) API protection.
    :type is_on: bool
    :returns:  dict -- JSON privacy settings.
    """
    return _run_speedify_cmd(["privacy", "apiProtection", "on" if is_on else "off"])


@exception_wrapper("Failed to set DoH request")
def privacy_request_disable_doh(is_on: bool):
    """
    privacy_request_disable_doh(is_on)
    If the Speedify VPN connection should request that browsers disable DNS over HTTPS.
    Enabling this can help streaming and streamingbypass rules function.

    Example:
        privacy_request_disable_doh(True)

    :param is_on: Enable (True) or disable (False) request to disable DoH.
    :type is_on: bool
    :returns:  dict -- JSON privacy settings.
    """
    return _run_speedify_cmd(["privacy", "requestToDisableDoH", "on" if is_on else "off"])


@exception_wrapper("Failed to show settings")
def show_settings():
    """
    show_settings()
    Returns current settings

    :returns:  dict -- dict -- :ref:`JSON settings <show-settings>` from speedify.
    """
    return _run_speedify_cmd(["show", "settings"])


@exception_wrapper("Failed to show adapters")
def show_adapters():
    """
    show_adapters()
    Returns current adapters

    :returns:  dict -- dict -- :ref:`JSON list of adapters <show-adapters>` from speedify.
    """
    return _run_speedify_cmd(["show", "adapters"])


@exception_wrapper("Failed to show directory")
def show_directory():
    """
    show_directory()
    Returns current directory service

    :returns:  dict -- dict -- :ref:`JSON object for the current directory service <show-directory>` from speedify.
    """
    return _run_speedify_cmd(["show", "directory"])


@exception_wrapper("Failed to do captiveportal_check")
def captiveportal_check():
    """
    captiveportal_check()
    Returns adapters which are currently blocked by a captive portal

    :returns:  dict -- dict -- :ref:`JSON list of adapters behind captive portal` from speedify.
    """
    return _run_speedify_cmd(["captiveportal", "check"])


@exception_wrapper("Failed to do captiveportal_login")
def captiveportal_login(proxy: bool = True, adapterID: str = None):
    """
    captiveportal_login()
    Starts or stops the local proxy intercepting traffic on ports 52,80,433, for
    filling in a captive portal.   If the user interface is running, once this is
    turned on, it will launch a captive portal browser.  If it's not, then it's
    up to you to launch a browser pointing at an http website to get to the
    portal page.

    :param proxy: Whether the local proxy should intercept captive portal traffic
    :type priority: boolean
    :param adapterID: The interface adapterID
    :type adapterID: str

    :returns:  dict -- dict -- :ref:`JSON list of adapters behind captive portal` from speedify.
    """
    args = ["captiveportal", "login"]
    startproxy = True
    if proxy == "on":
        args.append("on")
    elif proxy == "off":
        startproxy = False
        args.append("off")
    elif proxy:
        args.append("on")
    else:
        startproxy = False
        args.append("off")

    if adapterID and startproxy:
        args.append(adapterID)
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to show connectmethod")
def show_connectmethod():
    """
    show_connectmethod()
    Returns the current state of the 'connectmethod' setting.

    :returns dict -- :ref:`JSON connectmethod <show-connectmethod>`.
    """
    return _run_speedify_cmd(["show", "connectmethod"])


@exception_wrapper("Failed to show streamingbypass")
def show_streamingbypass():
    """
    show_streamingbypass()
    Returns the current state of the 'streamingbypass' setting.

    :returns dict -- :ref:`JSON streamingbypass <show-streamingbypass>`.
    """
    return _run_speedify_cmd(["show", "streamingbypass"])


@exception_wrapper("Failed to show disconnect")
def show_disconnect():
    """
    show_disconnect()
    Returns the last reason for a disconnection.

    :returns dict -- :ref:`JSON disconnect <show-disconnect>`.
    """
    return _run_speedify_cmd(["show", "disconnect"])


@exception_wrapper("Failed to show streaming")
def show_streaming():
    """
    show_streaming()
    Returns the current state of the 'streaming' setting.

    :returns dict -- :ref:`JSON streaming <show-streaming>`.
    """
    return _run_speedify_cmd(["show", "streaming"])


@exception_wrapper("Failed to show speedtest")
def show_speedtest():
    """
    show_speedtest()
    Returns the current results of 'speedtest'.

    :returns dict -- :ref:`JSON speedtest <show-speedtest>`.
    """
    return _run_speedify_cmd(["show", "speedtest"])


@exception_wrapper("Failed to show fixeddelay")
def show_fixeddelay():
    """
    show_fixeddelay()
    Shows the current rules for including traffic in the jitter buffer (fixed delay).
    Rules for domains, ports, and IP addresses are supported.

    :returns dict -- :ref:`JSON traffic rules with fixed_delay action <show-fixeddelay>`.
    """
    return _run_speedify_cmd(["show", "fixeddelay"])


@exception_wrapper("Failed to show traffic rules")
def show_trafficrules():
    """
    show_trafficrules()
    Shows the current traffic rules setting.

    :returns dict -- :ref:`JSON traffic rules <show-trafficrules>`.
    """
    return _run_speedify_cmd(["show", "trafficrules"])


@exception_wrapper("Failed to get current server")
def show_currentserver():
    """
    show_currentserver()
    Returns current server

    :returns:  dict -- :ref:`JSON currentserver <show-currentserver>` from speedify.
    """
    return _run_speedify_cmd(["show", "currentserver"])


@exception_wrapper("Failed to get current user")
def show_user():
    """
    show_user()
    Returns current user

    :returns:  dict -- :ref:`JSON response <show-user>` from speedify.
    """
    return _run_speedify_cmd(["show", "user"])


@exception_wrapper("Failed to show connect method")
def show_connectmethod():
    """
    show_connectmethod()
    Returns the connectmethod related settings

    :returns:  :ref:`JSON response <show-connectmethod>` from speedify.
    """
    return _run_speedify_cmd(["show", "connectmethod"])


@exception_wrapper("getting state")
def show_state():
    """
    show_state()
    Returns the current state of Speedify (CONNECTED, CONNECTING, etc.)

    :returns:  speedify.State -- The speedify state enum.
    """
    resultjson = _run_speedify_cmd(["state"])
    return find_state_for_string(resultjson["state"])


@exception_wrapper("Failed to get version")
def show_version():
    """
    show_version()
    Returns speedify version

    :returns:  dict -- :ref:`JSON version <version>` from speedify.
    """
    return _run_speedify_cmd(["version"])


@exception_wrapper("Failed to get activation code")
def activationcode():
    """
    activationcode()
    Obtain activation code to activate a device on my.speedify.com

    Example:
        result = activationcode()
        print(result["activationCode"])
        print(result["activationUrl"])

    :returns:  dict -- JSON with activationCode and activationUrl fields.
    """
    return _run_speedify_cmd(["activationcode"])


@exception_wrapper("Failed to show logsettings")
def show_logsettings():
    """
    show_logsettings()
    Returns current log settings

    :returns:  dict -- :ref:`JSON logsettings <show-logsettings>` from speedify.
    """
    return _run_speedify_cmd(["show", "logsettings"])


@exception_wrapper("Failed to erase logs")
def log_erase():
    """
    log_erase()
    Deletes the Speedify daemon's log files.

    :returns:  dict -- JSON response from speedify.
    """
    return _run_speedify_cmd(["log", "erase"])


@exception_wrapper("Failed to configure daemon logs")
def log_daemon(file_size: int, files_per_daemon: int, total_files: int, log_level: str):
    """
    log_daemon(file_size, files_per_daemon, total_files, log_level)
    Configure the size and number of the Speedify daemon's log files.

    Example:
        log_daemon(3145728, 7, 9, "info")

    :param file_size: Size of each log file in bytes.
    :type file_size: int
    :param files_per_daemon: Number of log files per daemon.
    :type files_per_daemon: int
    :param total_files: Total number of log files.
    :type total_files: int
    :param log_level: Log level (verbose|info|warn|error).
    :type log_level: str
    :returns:  dict -- :ref:`JSON log settings <log-daemon>` from speedify.
    """
    return _run_speedify_cmd(
        ["log", "daemon", str(file_size), str(files_per_daemon), str(total_files), log_level]
    )


@exception_wrapper("Failed to show dscp")
def show_dscp():
    """
    show_dscp()
    Returns current DSCP queue settings

    Note: DSCP (Differentiated Services Code Point) settings are only supported on Linux.
    On other platforms, this will raise a SpeedifyAPIError.

    :returns:  dict -- :ref:`JSON dscp settings <show-dscp>` from speedify.
    :raises SpeedifyAPIError: On non-Linux platforms where DSCP is not supported.
    """
    return _run_speedify_cmd(["show", "dscp"])


@exception_wrapper("Failed to add DSCP queue")
def dscp_queues_add(dscp: int, priority: str = None, replication: str = None, retransmissions: int = None):
    """
    dscp_queues_add(dscp, priority, replication, retransmissions)
    Add a DSCP queue configuration.

    Note: DSCP settings are only supported on Linux.

    Example:
        dscp_queues_add(0, priority="on", replication="auto", retransmissions=2)

    :param dscp: DSCP value (0-63).
    :type dscp: int
    :param priority: Priority setting (on|off|auto), optional.
    :type priority: str
    :param replication: Replication setting (on|off|auto), optional.
    :type replication: str
    :param retransmissions: Number of retransmission attempts (0-255), optional.
    :type retransmissions: int
    :returns:  dict -- JSON with updated DSCP queue settings.
    :raises SpeedifyAPIError: On non-Linux platforms where DSCP is not supported.
    """
    args = ["dscp", "queues", "add", str(dscp)]
    if priority is not None:
        args.extend(["priority", priority])
    if replication is not None:
        args.extend(["replication", replication])
    if retransmissions is not None:
        args.extend(["retransmissions", str(retransmissions)])
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to set DSCP queue")
def dscp_queues_set(dscp: int, priority: str = None, replication: str = None, retransmissions: int = None):
    """
    dscp_queues_set(dscp, priority, replication, retransmissions)
    Set a DSCP queue configuration.

    Note: DSCP settings are only supported on Linux.

    Example:
        dscp_queues_set(0, priority="on", replication="auto", retransmissions=2)

    :param dscp: DSCP value (0-63).
    :type dscp: int
    :param priority: Priority setting (on|off|auto), optional.
    :type priority: str
    :param replication: Replication setting (on|off|auto), optional.
    :type replication: str
    :param retransmissions: Number of retransmission attempts (0-255), optional.
    :type retransmissions: int
    :returns:  dict -- JSON with updated DSCP queue settings.
    :raises SpeedifyAPIError: On non-Linux platforms where DSCP is not supported.
    """
    args = ["dscp", "queues", "set", str(dscp)]
    if priority is not None:
        args.extend(["priority", priority])
    if replication is not None:
        args.extend(["replication", replication])
    if retransmissions is not None:
        args.extend(["retransmissions", str(retransmissions)])
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to remove DSCP queue")
def dscp_queues_rem(dscp: int):
    """
    dscp_queues_rem(dscp)
    Remove a DSCP queue configuration.

    Note: DSCP settings are only supported on Linux.

    Example:
        dscp_queues_rem(0)

    :param dscp: DSCP value (0-63) to remove.
    :type dscp: int
    :returns:  dict -- JSON with updated DSCP queue settings.
    :raises SpeedifyAPIError: On non-Linux platforms where DSCP is not supported.
    """
    return _run_speedify_cmd(["dscp", "queues", "rem", str(dscp)])


@exception_wrapper("Failed to get networksharing settings")
def networksharing_settings():
    """
    networksharing_settings()
    Returns current network sharing (Pair & Share) settings

    :returns:  dict -- :ref:`JSON networksharing settings <networksharing-settings>` from speedify.
    """
    return _run_speedify_cmd(["networksharing", "settings"])


@exception_wrapper("Failed to get available shares")
def networksharing_availableshares():
    """
    networksharing_availableshares()
    Returns an array of all currently available networksharing peers found via discovery.

    :returns:  list -- Array of peer information.
    """
    return _run_speedify_cmd(["networksharing", "availableshares"])


@exception_wrapper("Failed to connect to peer")
def networksharing_connect(peer_connect_code: str):
    """
    networksharing_connect(peer_connect_code)
    Connect to a peer using a connect code (hostConnectCode), if available on local network.

    Example:
        networksharing_connect("F1C1290C-CA03-17B4-9989-A22222A28B74")

    :param peer_connect_code: The peer connect code from QR code scan.
    :type peer_connect_code: str
    :returns:  dict -- JSON with connection result.
    """
    return _run_speedify_cmd(["networksharing", "connect", peer_connect_code])


@exception_wrapper("Failed to get discovery state")
def networksharing_discovery():
    """
    networksharing_discovery()
    Shows the current state of Pair & Share discovery.

    :returns:  dict -- JSON with discoveryActive boolean field.
    """
    return _run_speedify_cmd(["networksharing", "discovery"])


@exception_wrapper("Failed to manage peer")
def networksharing_peer(action: str, peer_uuid: str):
    """
    networksharing_peer(action, peer_uuid)
    Controls pairing behavior with the peer with the given uuid.

    Example:
        networksharing_peer("allow", "F1C1290C-CA03-17B4-9989-A22222A28B74")
        networksharing_peer("request", "F1C1290C-CA03-17B4-9989-A22222A28B74")
        networksharing_peer("unpair", "F1C1290C-CA03-17B4-9989-A22222A28B74")

    :param action: Action to perform (allow|reject|request|unpair).
    :type action: str
    :param peer_uuid: UUID of the peer.
    :type peer_uuid: str
    :returns:  dict -- JSON with peer information.
    """
    return _run_speedify_cmd(["networksharing", "peer", action, peer_uuid])


@exception_wrapper("Failed to reconnect to peer")
def networksharing_reconnect(peer_uuid: str):
    """
    networksharing_reconnect(peer_uuid)
    Reconnect to the peer at the specified UUID.

    Example:
        networksharing_reconnect("F1C1290C-CA03-17B4-9989-A22222A28B74")

    :param peer_uuid: UUID of the peer.
    :type peer_uuid: str
    :returns:  dict -- JSON with connection result.
    """
    return _run_speedify_cmd(["networksharing", "reconnect", peer_uuid])


@exception_wrapper("Failed to set networksharing mode")
def networksharing_set_mode(mode: str, is_on: bool):
    """
    networksharing_set_mode(mode, is_on)
    Controls if device acts as a client (using peers' shared cellular) or host (sharing cellular).

    Example:
        networksharing_set_mode("client", True)
        networksharing_set_mode("host", False)

    :param mode: Mode to set (host|client).
    :type mode: str
    :param is_on: Enable (True) or disable (False).
    :type is_on: bool
    :returns:  dict -- JSON with updated settings.
    """
    return _run_speedify_cmd(["networksharing", "set", mode, "on" if is_on else "off"])


@exception_wrapper("Failed to set always on discovery")
def networksharing_set_alwayson_discovery(is_on: bool):
    """
    networksharing_set_alwayson_discovery(is_on)
    Controls if Pair and Share peer discovery is always active (can use more power when on battery).

    Example:
        networksharing_set_alwayson_discovery(True)

    :param is_on: Enable (True) or disable (False).
    :type is_on: bool
    :returns:  dict -- JSON with updated settings.
    """
    return _run_speedify_cmd(["networksharing", "set", "alwaysOnDiscovery", "on" if is_on else "off"])


@exception_wrapper("Failed to set auto pair behavior")
def networksharing_set_autopair_behavior(behavior: str):
    """
    networksharing_set_autopair_behavior(behavior)
    Controls if peers of the same user and/or team are automatically paired.

    Example:
        networksharing_set_autopair_behavior("auto_user_team")

    :param behavior: Pairing behavior (manual|auto_user|auto_user_team).
    :type behavior: str
    :returns:  dict -- JSON with updated settings.
    """
    return _run_speedify_cmd(["networksharing", "set", "autoPairBehavior", behavior])


@exception_wrapper("Failed to set display name")
def networksharing_set_displayname(name: str):
    """
    networksharing_set_displayname(name)
    Set the display name for this device. Other devices will see this name when pairing/sharing.

    Example:
        networksharing_set_displayname("My Laptop")

    :param name: Display name for this device.
    :type name: str
    :returns:  dict -- JSON with updated settings.
    """
    return _run_speedify_cmd(["networksharing", "set", "displayname", name])


@exception_wrapper("Failed to set pair request behavior")
def networksharing_set_pair_request_behavior(behavior: str):
    """
    networksharing_set_pair_request_behavior(behavior)
    Set the behavior for incoming connection requests.

    Example:
        networksharing_set_pair_request_behavior("accept")

    :param behavior: Request behavior (ask|accept|reject).
    :type behavior: str
    :returns:  dict -- JSON with updated settings.
    """
    return _run_speedify_cmd(["networksharing", "set", "pairRequestBehavior", behavior])


@exception_wrapper("Failed to set peer setting")
def networksharing_set_peer(setting: str, peer_uuid: str, is_on: bool):
    """
    networksharing_set_peer(setting, peer_uuid, is_on)
    Turns on/off settings related to an individual peer.

    Example:
        networksharing_set_peer("autoreconnect", "F1C1290C-CA03-17B4-9989-A22222A28B74", True)
        networksharing_set_peer("allowhost", "F1C1290C-CA03-17B4-9989-A22222A28B74", True)

    :param setting: Setting to change (autoreconnect|allowhost|allowclient).
    :type setting: str
    :param peer_uuid: UUID of the peer.
    :type peer_uuid: str
    :param is_on: Enable (True) or disable (False).
    :type is_on: bool
    :returns:  list -- Array of peer information.
    """
    return _run_speedify_cmd(["networksharing", "set", "peer", setting, peer_uuid, "on" if is_on else "off"])


@exception_wrapper("Failed to start discovery")
def networksharing_startdiscovery():
    """
    networksharing_startdiscovery()
    Begin discovering other devices on the local network.

    :returns:  dict -- JSON with discoveryActive boolean field.
    """
    return _run_speedify_cmd(["networksharing", "startdiscovery"])


@exception_wrapper("Failed to get stats")
def safebrowsing_stats():
    """
    safebrowsing_stats()
    Retrieves statistics about safe browsing feature usage.

    :returns: dict -- JSON response with safe browsing statistics from speedify.
    """
    args = ["safebrowsing", "stats"]
    return _run_speedify_cmd(args)


#
# Setter functions
#


@exception_wrapper("Failed to set directory server")
def directory(domain: str = ""):
    """
    directory(domain)

    Uses the given domain as the directory server.

    :param domain: The domain of the directory server.
    :type operation: str
    """
    return _run_speedify_cmd(["directory", domain])


@exception_wrapper("Failed to set DNS")
def dns(ip_addr: str = ""):
    """
    dns(ip_addr)

    Uses the given IP address for as the DNS server.

    Example:
        dns("8.8.8.8")

    :param ip_addr: The IP address of the DNS server.
    :type operation: str
    """
    return _run_speedify_cmd(["dns", ip_addr])


@exception_wrapper("Failed to add streaming bypass")
def streaming_domains_add(domains: str):
    """
    streaming_domains_add(domains)

    Add the streaming hint for some domains.

    Example:
        streaming_domains_add("example.com google.com")

    :param domains: The domains to add the streaming hint for.
    :type domains: str
    """
    return _run_speedify_cmd(["streaming", "domains", "add", domains])


@exception_wrapper("Failed to remove streaming bypass")
def streaming_domains_rem(domains: str):
    """
    streaming_domains_rem(domains)

    Remove the streaming hint for some domains.

    Example:
        streaming_domains_rem("example.com google.com")

    :param domains: The domains to remove the streaming hint from.
    :type domains: str
    """
    return _run_speedify_cmd(["streaming", "domains", "rem", domains])


@exception_wrapper("Failed to set streaming bypass")
def streaming_domains_set(domains: str):
    """
    streaming_domains_set(domains)

    Set the streaming hint for some domains.

    Example:
        streaming_domains_set("example.com google.com")

    :param domains: The domains to set the streaming hint on.
    :type domains: str
    """
    return _run_speedify_cmd(["streaming", "domains", "set", domains])


@exception_wrapper("Failed to add streaming flag")
def streaming_ipv4_add(ipv4_addrs: str):
    """
    streaming_ipv4_add(ipv4_addrs)

    Add the streaming flag for some ipv4 address(es).

    Example:
        streaming_ipv4_add(
            "68.80.59.53 55.38.18.29"
        )

    :param ipv4: The ipv4 adress(es) to add the streaming flag to.
        Example:
            "68.80.59.53 55.38.18.29"
            "68.80.59.53"
    :type ipv4_addrs: str
    """
    return _run_speedify_cmd(["streaming", "ipv4", "add", ipv4_addrs])


@exception_wrapper("Failed to remove streaming flag")
def streaming_ipv4_rem(ipv4_addrs: str):
    """
    streaming_ipv4_rem(ipv4_addrs)

    Remove the streaming flag from some ipv4 adress(es).

    Example:
        streaming_ipv4_rem(
            "68.80.59.53 55.38.18.29"
        )

    :param ipv4: The ipv4 adress(es) to remove the streaming flag from.
        Example:
            "68.80.59.53 55.38.18.29"
            "68.80.59.53"
    :type ipv4_addrs: str
    """
    return _run_speedify_cmd(["streaming", "ipv4", "rem", ipv4_addrs])


@exception_wrapper("Failed to set streaming flag")
def streaming_ipv4_set(ipv4_addrs: str):
    """
    streaming_ipv4_set(ipv4_addrs)

    Set the streaming flag on some ipv4 adress(es).

    Example:
        streaming_ipv4_set(
            "68.80.59.53 55.38.18.29"
        )

    :param ipv4: The ipv4 adress(es) to set the streaming flag on.
        Example:
            "68.80.59.53 55.38.18.29"
            "68.80.59.53"
    :type ipv4_addrs: str
    """
    return _run_speedify_cmd(["streaming", "ipv4", "set", ipv4_addrs])


@exception_wrapper("Failed to add streaming flag")
def streaming_ipv6_add(ipv6_addrs: str):
    """
    streaming_ipv6_add(ipv6_addrs)

    Add the streaming flag for some ipv6 address(es).

    Example:
        streaming_ipv6_add(
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
        )

    :param ipv6: The ipv6 adress(es) to add the streaming flag to.
        Example:
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
            "2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
    :type ipv6_addrs: str
    """
    return _run_speedify_cmd(["streaming", "ipv6", "add", ipv6_addrs])


@exception_wrapper("Failed to remove streaming flag")
def streaming_ipv6_rem(ipv6_addrs: str):
    """
    streaming_ipv6_rem(ipv6_addrs)

    Remove the streaming flag from some ipv6 adress(es).

    Example:
        streaming_ipv6_rem(
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
        )

    :param ipv6: The ipv6 adress(es) to remove the streaming flag from.
        Example:
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
            "2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
    :type ipv6_addrs: str
    """
    return _run_speedify_cmd(["streaming", "ipv6", "rem", ipv6_addrs])


@exception_wrapper("Failed to set streaming flag")
def streaming_ipv6_set(ipv6_addrs: str):
    """
    streaming_ipv6_set(ipv6_addrs)

    Set the streaming flag on some ipv6 adress(es).

    Example:
        streaming_ipv6_set(
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
        )

    :param ipv6: The ipv6 adress(es) to set the streaming flag on.
        Example:
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
            "2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
    :type ipv6_addrs: str
    """
    return _run_speedify_cmd(["streaming", "ipv6", "set", ipv6_addrs])


@exception_wrapper("Failed to add streaming flag")
def streaming_ports_add(ports: str):
    """
    streaming_ports_add(ports)

    Add the streaming flag for some port(s).

    Example:
        streaming_ports_add(
            "9999/tcp"
        )

    :param ports: The port(s) to add the streaming flag to.
        Example:
            "9999/tcp"
            "1500-2000/udp"
        Form:
            "<port>/<proto>"
            "<port begin>-<port end>/<proto>"
    :type ports: str
    """
    return _run_speedify_cmd(["streaming", "ports", "add", ports])


@exception_wrapper("Failed to remove streaming flag")
def streaming_ports_rem(ports: str):
    """
    streaming_ports_rem(ports)

    Remove the streaming flag from some port(s).

    Example:
        streaming_ports_rem(
            "9999/tcp"
        )

    :param ports: The port(s) to remove the streaming flag from.
        Example:
            "9999/tcp"
            "1500-2000/udp"
        Form:
            "<port>/<proto>"
            "<port begin>-<port end>/<proto>"
    :type ports: str
    """
    return _run_speedify_cmd(["streaming", "ports", "rem", ports])


@exception_wrapper("Failed to set streaming flag")
def streaming_ports_set(ports: str):
    """
    streaming_ports_set(ports)

    Set the streaming flag on some port(s).

    Example:
        streaming_ports_set(
            "9999/tcp"
        )

    :param ports: The port(s) to set the streaming flag on.
        Example:
            "9999/tcp"
            "1500-2000/udp"
        Form:
            "<port>/<proto>"
            "<port begin>-<port end>/<proto>"
    :type ports: str
    """
    return _run_speedify_cmd(["streaming", "ports", "set", ports])


@exception_wrapper("Failed to add streaming bypass")
def streamingbypass_domains_add(domains: str):
    """
    streamingbypass_domains_add(domains)

    Add a streaming bypass for some domain(s).

    Example:
        streamingbypass_domains_add(
            "example.com google.com"
        )

    :param domains: The domain(s) to add a streaming bypass to.
        Example:
            "example.com google.com"
            "google.com"
    :type domains: str
    """
    return _run_speedify_cmd(["streamingbypass", "domains", "add", domains])


@exception_wrapper("Failed to remove streaming bypass")
def streamingbypass_domains_rem(domains: str):
    """
    streamingbypass_domains_rem(domains)

    Remove a streaming bypass from some domain(s).

    Example:
        streamingbypass_domains_rem(
            "example.com google.com"
        )

    :param domains: The domain(s) to remove the streaming bypass from.
        Example:
            "example.com google.com"
            "google.com"
    :type domains: str
    """
    return _run_speedify_cmd(["streamingbypass", "domains", "rem", domains])


@exception_wrapper("Failed to set streaming bypass")
def streamingbypass_domains_set(domains: str):
    """
    streamingbypass_domains_set(domains)

    Set a streaming bypass on some domain(s).

    Example:
        streamingbypass_domains_set(
            "example.com google.com"
        )

    :param domains: The domain(s) to set the streaming bypass on.
        Example:
            "example.com google.com"
            "google.com"
    :type domains: str
    """
    return _run_speedify_cmd(["streamingbypass", "domains", "set", domains])


@exception_wrapper("Failed to add streaming bypass")
def streamingbypass_ipv4_add(ipv4_addrs: str):
    """
    streamingbypass_ipv4_add(ipv4_addrs)

    Add a streaming bypass for some ipv4 address(es).

    Example:
        streamingbypass_ipv4_add(
            "68.80.59.53 55.38.18.29"
        )

    :param ipv4_addrs: The ipv4 address(es) to add a streaming bypass to.
        Example:
            "68.80.59.53 55.38.18.29"
            "55.38.18.29"
    :type ipv4_addrs: str
    """
    return _run_speedify_cmd(["streamingbypass", "ipv4", "add", ipv4_addrs])


@exception_wrapper("Failed to remove streaming bypass")
def streamingbypass_ipv4_rem(ipv4_addrs: str):
    """
    streamingbypass_ipv4_rem(ipv4_addrs)

    Remove a streaming bypass from some ipv4 address(es).

    Example:
        streamingbypass_ipv4_rem(
            "68.80.59.53 55.38.18.29"
        )

    :param ipv4_addrs: The ipv4 address(es) to remove the streaming bypass from.
        Example:
            "68.80.59.53 55.38.18.29"
            "55.38.18.29"
    :type ipv4_addrs: str
    """
    return _run_speedify_cmd(["streamingbypass", "ipv4", "rem", ipv4_addrs])


@exception_wrapper("Failed to set streaming bypass")
def streamingbypass_ipv4_set(ipv4_addrs: str):
    """
    streamingbypass_ipv4_set(ipv4_addrs)

    Set a streaming bypass on some ipv4 address(es).

    Example:
        streamingbypass_ipv4_set(
            "68.80.59.53 55.38.18.29"
        )

    :param ipv4_addrs: The ipv4 address(es) to set the streaming bypass on.
        Example:
            "68.80.59.53 55.38.18.29"
            "55.38.18.29"
    :type ipv4_addrs: str
    """
    return _run_speedify_cmd(["streamingbypass", "ipv4", "set", ipv4_addrs])


@exception_wrapper("Failed to add streaming bypass")
def streamingbypass_ipv6_add(ipv6_addrs: str):
    """
    streamingbypass_ipv6_add(ipv6_addrs)

    Add a streaming bypass for some ipv6 address(es).

    Example:
        streamingbypass_ipv6_add(
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
        )

    :param ipv6_addrs: The ipv6 address(es) to add a streaming bypass to.
        Example:
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
            "2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
    :type ipv6_addrs: str
    """
    return _run_speedify_cmd(["streamingbypass", "ipv6", "add", ipv6_addrs])


@exception_wrapper("Failed to remove streaming bypass")
def streamingbypass_ipv6_rem(ipv6_addrs: str):
    """
    streamingbypass_ipv6_rem(ipv6_addrs)

    Remove a streaming bypass from some ipv6 address(es).

    Example:
        streamingbypass_ipv6_rem(
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
        )

    :param ipv6_addrs: The ipv6 address(es) to remove the streaming bypass from.
        Example:
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
            "2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
    :type ipv6_addrs: str
    """
    return _run_speedify_cmd(["streamingbypass", "ipv6", "rem", ipv6_addrs])


@exception_wrapper("Failed to set streaming bypass")
def streamingbypass_ipv6_set(ipv6_addrs: str):
    """
    streamingbypass_ipv6_set(ipv6_addrs)

    Set a streaming bypass on some ipv6 address(es).

    Example:
        streamingbypass_ipv6_set(
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
        )

    :param ipv6_addrs: The ipv6 address(es) to set the streaming bypass on.
        Example:
            "2001:db8:1234:ffff:ffff:ffff:ffff:0f0f 2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
            "2001:db8:1234:ffff:ffff:ffff:ffff:ffff"
    :type ipv6_addrs: str
    """
    return _run_speedify_cmd(["streamingbypass", "ipv6", "set", ipv6_addrs])


@exception_wrapper("Failed to add streaming bypass")
def streamingbypass_ports_add(ports: str):
    """
    streamingbypass_ports_add(ports)

    Add a streaming bypass for some port(s).

    Example:
        streamingbypass_ports_add("9999/tcp")

    :param ports: The ports to add a streaming bypass to.
        Must be of one of these forms:
            "<port>/<proto>"
            "<port begin>-<port end>/<proto>"
    :type ports: str
    """
    return _run_speedify_cmd(["streamingbypass", "ports", "add", ports])


@exception_wrapper("Failed to rem streaming bypass")
def streamingbypass_ports_rem(ports: str):
    """
    streamingbypass_ports_rem(ports)

    Remove a streaming bypass for some port(s).

    Example:
        streamingbypass_ports_rem("9999/tcp")

    :param ports: The ports to remove a streaming bypass from.
        Must be of one of these forms:
            "<port>/<proto>"
            "<port begin>-<port end>/<proto>"
    :type ports: str
    """
    return _run_speedify_cmd(["streamingbypass", "ports", "rem", ports])


@exception_wrapper("Failed to set streaming bypass")
def streamingbypass_ports_set(ports: str):
    """
    streamingbypass_ports_set(ports)

    Set a streaming bypass for some port(s).

    Example:
        streamingbypass_ports_set("9999/tcp")

    :param ports: The ports to set a streaming bypass on.
        Must be of one of these forms:
            "<port>/<proto>"
            "<port begin>-<port end>/<proto>"
    :type ports: str
    """
    return _run_speedify_cmd(["streamingbypass", "ports", "set", ports])


@exception_wrapper("Failed to set streaming bypass")
def streamingbypass_service(service_name: str, is_on: bool):
    """
    streamingbypass_service(service_name, is_on)

    Set the streaming bypass, on or off, for some pre-defined service.

    Example:
        streamingbypass_service("Netflix", True)

    :param service_name: The service to modify.
    :type service_name: str
    :param is_on: Whether to bypass the service... or not.
    :type is_on: bool
    """
    if is_on is True:
        is_on = "on"
    elif is_on is False:
        is_on = "off"
    return _run_speedify_cmd(["streamingbypass", "service", service_name, is_on])


@exception_wrapper("Failed to set adapter encryption")
def adapter_overratelimit(adapterID: str, bps: int):
    """
    adapter_overratelimit(adapterID: str, bps)

    Sets the rate limit, in bps, on adapterID.
    (show_adapters is where you find the adapterIDs).

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param bps: Speed, in bps, to limit the adapter to.
    :type bps: int
    :returns:  dict -- :ref:`JSON adapter response <adapter-encryption>` from speedify.
    """
    return _run_speedify_cmd(["adapter", "overlimitratelimit", adapterID, str(bps)])


@exception_wrapper("Failed to set adapter priority")
def adapter_priority(adapterID: str, priority=Priority.ALWAYS):
    """
    adapter_priority(adapterID: str, priority=Priority.ALWAYS)
    Sets the priority on the adapter whose adapterID is provided (show_adapters is where you find the adapterIDs)

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param priority: The speedify priority
    :type priority: speedify.Priority
    :returns:  dict -- :ref:`JSON adapter response <adapter-ratelimit>` from speedify.
    """
    args = ["adapter", "priority"]
    args.append(str(adapterID))
    args.append((str(priority.value)))
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set adapter encryption")
def adapter_encryption(adapterID: str, should_encrypt):
    """
    adapter_encryption(adapterID: str, should_encrypt)

    Example:
        adapter_encryption("something", True)
        adapter_encryption("something", "off")

    Sets the encryption on the adapter whose adapterID is provided
    (show_adapters is where you find the adapterIDs).

    Note that any time the main encryption() function is called,
    all the per adapter encryption settings are immediately reset.

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param should_encrypt: Whether to encrypt
    :type should_encrypt: bool | str
    :returns:  dict -- :ref:`JSON adapter response <adapter-encryption>` from speedify.
    """
    if should_encrypt is True:
        should_encrypt = "on"
    elif should_encrypt is False:
        should_encrypt = "off"
    should_encrypt = str(should_encrypt)
    return _run_speedify_cmd(["adapter", "encryption", adapterID, should_encrypt])


@exception_wrapper("Failed to set adapter ratelimit")
def adapter_ratelimit(adapterID: str, download_bps: int = 0, upload_bps: int = 0):
    """
    adapter_ratelimit(adapterID: str, download_bps: int = 0, upload_bps: int = 0)
    Sets the ratelimit in bps on the adapter whose adapterID is provided
    (show_adapters is where you find the adapterIDs)

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param upload_bps: The upload ratelimit in bps
    :type upload_bps: int
    :param download_bps: The download ratelimit in bps
    :type download_bps: int
    :returns:  dict -- :ref:`JSON adapter response <adapter-datalimit-daily>` from speedify.
    """
    return _run_speedify_cmd(["adapter", "ratelimit", adapterID, str(download_bps), str(upload_bps)])


@exception_wrapper("Failed to set adapter daily limit")
def adapter_datalimit_daily(adapterID: str, limit: int = 0):
    """
    adapter_datalimit_daily(adapterID, limit: int = 0)
    Sets the daily usage limit in bytes on the adapter whose adapterID is provided
    (show_adapters is where you find the adapterIDs)

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param limit: The daily usage limit, in bytes
    :type limit: int
    :returns:  dict -- :ref:`JSON adapter response <adapter-datalimit-daily>` from speedify
    """
    return _run_speedify_cmd(["adapter", "datalimit", "daily", adapterID, str(limit)])


@exception_wrapper("Failed to set adapter daily boost")
def adapter_datalimit_dailyboost(adapterID: str, boost: int = 0):
    """
    adapter_datalimit_dailyboost(adapterID, boost: int = 0)

    Gives some additional daily data, in bytes,
    to the adapter whose adapterID is provided.

    Show_adapters is where you find the adapterIDs.

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param boost: Some additional bytes to give to the daily limit.
    :type boost: int
    :returns:  dict -- :ref:`JSON adapter response <adapter-datalimit-daily>` from speedify
    """
    return _run_speedify_cmd(["adapter", "datalimit", "dailyboost", str(boost)])


@exception_wrapper("Failed to set adapter monthly limit")
def adapter_datalimit_monthly(adapterID: str, limit: int = 0, reset_day: int = 0):
    """
    adapter_datalimit_monthly(adapterID: str, limit: int = 0, reset_day: int = 0)
    Sets the monthly usage limit in bytes on the adapter whose adapterID is provided
    (show_adapters is where you find the adapterIDs)

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param limit: The monthly usage limit, in bytes
    :type limit: int
    :param reset_day: The day of the month to reset monthly usage (0-31)
    :type reset_day: int
    :returns:  dict -- :ref:`JSON adapter response <adapter-datalimit-monthly>` from speedify.
    """
    args = ["adapter", "datalimit", "monthly", adapterID, str(limit), str(reset_day)]
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to reset adapter usage")
def adapter_resetusage(adapterID: str):
    """
    adapter_resetusage(adapterID)
    Resets all the stats on this adapter back to 0.  Starts both daily and monthly limits over, if set.

    :param adapterID: The interface adapterID
    :type adapterID: str
    :returns:  dict -- :ref:`JSON adapter response <adapter-resetusage>` from speedify.
    """
    return _run_speedify_cmd(["adapter", "resetusage", adapterID])


@exception_wrapper("Failed to set adapter directional mode")
def adapter_directionalmode(adapterID: str, upload_mode: str, download_mode: str):
    """
    adapter_directionalmode(adapterID, upload_mode, download_mode)
    Controls if and how the adapter is used for upload and download, respectively.

    Example:
        adapter_directionalmode("eth0", "on", "on")
        adapter_directionalmode("wlan0", "backup_off", "on")

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param upload_mode: Upload mode (on|backup_off|strict_off).
    :type upload_mode: str
    :param download_mode: Download mode (on|backup_off|strict_off).
    :type download_mode: str
    :returns:  dict -- :ref:`JSON adapter response <adapter-directionalmode>` from speedify.
    """
    return _run_speedify_cmd(["adapter", "directionalmode", adapterID, upload_mode, download_mode])


@exception_wrapper("Failed to set adapter expose-dscp")
def adapter_expose_dscp(adapterID: str, is_on: bool):
    """
    adapter_expose_dscp(adapterID, is_on)
    Allows DSCP values of internal packets to be exposed to the VPN transport connection.

    Example:
        adapter_expose_dscp("eth0", True)

    :param adapterID: The interface adapterID
    :type adapterID: str
    :param is_on: Enable (True) or disable (False) DSCP exposure.
    :type is_on: bool
    :returns:  dict -- :ref:`JSON settings <adapter-expose-dscp>` from speedify.
    """
    return _run_speedify_cmd(["adapter", "expose-dscp", adapterID, "on" if is_on else "off"])


@exception_wrapper("Failed to set forwarded ports")
def ports(tcpports: list = [], udpports: list = []):
    """
    ports(tcpports=[], udpports=[])
    sets port forwarding. call with no arguments to unset all port forwarding

    :param tcpports: List of tcp ports to forward on
    :type tcpport: list
    :param udpports: List of udp ports to forward on
    :type udpport: list
    :returns:  dict -- :ref:`JSON settings <ports>` from speedify
    """
    args = ["ports"]
    if tcpports is not None:
        for port in tcpports:
            args.append(str(port) + "/tcp")
    if udpports is not None:
        for port in udpports:
            args.append(str(port) + "/udp")

    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to change modes")
def mode(mode: str):
    """
    mode(mode="speed")

    Uses one of 'redundant', 'speed' or 'streaming' operation modes.

    :param mode: One of:
        "redundant"
        "speed"
        "streaming"
    :type mode: str
    :returns:  dict -- :ref:`JSON settings <mode>` from speedify
    """
    return _run_speedify_cmd(["mode", mode])


@exception_wrapper("Failed to set encryption")
def encryption(should_encrypt=True):
    """
    encryption(encrypt = True)
    Sets encryption on or off.

    :param encrypt: Encrypted on or off
    :type encrypt: bool
    :returns:  dict -- :ref:`JSON settings <encryption>` from speedify
    """
    if should_encrypt is True:
        should_encrypt = "on"
    elif should_encrypt is False:
        should_encrypt = "off"
    resultjson = _run_speedify_cmd(["encryption", should_encrypt])
    return resultjson


@exception_wrapper("Failed to set jumbo")
def jumbo(mode: bool = True):
    """
    jumbo(mode = True)
    Sets jumbo MTU mode on or off.

    :param mode: Jumbo MTU on or off
    :type mode: bool
    :returns:  dict -- :ref:`JSON settings <jumbo>` from speedify
    """
    args = ["jumbo"]
    if mode == "on":
        args.append("on")
    elif mode == "off":
        args.append("off")
    elif mode is True:
        args.append("on")
    elif mode is False:
        args.append("off")
    else:
        # probably invalid, but we'll let speedify tell us THAT
        args.append(mode)

    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set fixed delay")
def fixeddelay(delay_ms: int):
    """
    fixeddelay(delay_ms)
    Set the jitter buffer delay in milliseconds (0-1000ms).
    The jitter buffer adds a delay to traffic and delivers it with consistent latency through the VPN tunnel to minimize jitter.
    Valid delay range: 0-1000 ms.

    Example:
        fixeddelay(100)

    :param delay_ms: Delay in milliseconds (0-1000).
    :type delay_ms: int
    :returns:  dict -- :ref:`JSON settings <fixeddelay>` from speedify.
    """
    return _run_speedify_cmd(["fixeddelay", str(delay_ms)])


@exception_wrapper("Failed to add fixeddelay domain rule")
def fixeddelay_domains_add(domains: str):
    """
    fixeddelay_domains_add(domains)
    Add domain(s) to include in the jitter buffer (fixed delay).

    Example:
        fixeddelay_domains_add("example.com another.com")

    :param domains: Space-separated domain(s) to add.
    :type domains: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-domains>` from speedify.
    """
    args = ["fixeddelay", "domains", "add"] + domains.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to remove fixeddelay domain rule")
def fixeddelay_domains_rem(domains: str):
    """
    fixeddelay_domains_rem(domains)
    Remove domain(s) from the jitter buffer (fixed delay).

    Example:
        fixeddelay_domains_rem("example.com")

    :param domains: Space-separated domain(s) to remove.
    :type domains: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-domains>` from speedify.
    """
    args = ["fixeddelay", "domains", "rem"] + domains.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to set fixeddelay domain rules")
def fixeddelay_domains_set(domains: str):
    """
    fixeddelay_domains_set(domains)
    Set domain(s) to include in the jitter buffer (fixed delay), replacing existing rules.

    Example:
        fixeddelay_domains_set("example.com another.com")

    :param domains: Space-separated domain(s) to set.
    :type domains: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-domains>` from speedify.
    """
    args = ["fixeddelay", "domains", "set"] + domains.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to add fixeddelay IP rule")
def fixeddelay_ips_add(ips: str):
    """
    fixeddelay_ips_add(ips)
    Add IP address(es) to include in the jitter buffer (fixed delay).

    Example:
        fixeddelay_ips_add("192.168.1.1 10.0.0.1")

    :param ips: Space-separated IP address(es) to add.
    :type ips: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-ips>` from speedify.
    """
    args = ["fixeddelay", "ips", "add"] + ips.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to remove fixeddelay IP rule")
def fixeddelay_ips_rem(ips: str):
    """
    fixeddelay_ips_rem(ips)
    Remove IP address(es) from the jitter buffer (fixed delay).

    Example:
        fixeddelay_ips_rem("192.168.1.1")

    :param ips: Space-separated IP address(es) to remove.
    :type ips: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-ips>` from speedify.
    """
    args = ["fixeddelay", "ips", "rem"] + ips.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to set fixeddelay IP rules")
def fixeddelay_ips_set(ips: str):
    """
    fixeddelay_ips_set(ips)
    Set IP address(es) to include in the jitter buffer (fixed delay), replacing existing rules.

    Example:
        fixeddelay_ips_set("192.168.1.1 10.0.0.1")

    :param ips: Space-separated IP address(es) to set.
    :type ips: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-ips>` from speedify.
    """
    args = ["fixeddelay", "ips", "set"] + ips.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to add fixeddelay port rule")
def fixeddelay_ports_add(ports: str):
    """
    fixeddelay_ports_add(ports)
    Add port(s) to include in the jitter buffer (fixed delay).

    Example:
        fixeddelay_ports_add("9000/udp 8000-8010/tcp")

    :param ports: Space-separated port specification(s) (format: port/proto or port-portRangeEnd/proto).
    :type ports: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-ports>` from speedify.
    """
    args = ["fixeddelay", "ports", "add"] + ports.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to remove fixeddelay port rule")
def fixeddelay_ports_rem(ports: str):
    """
    fixeddelay_ports_rem(ports)
    Remove port(s) from the jitter buffer (fixed delay).

    Example:
        fixeddelay_ports_rem("9000/udp")

    :param ports: Space-separated port specification(s) (format: port/proto or port-portRangeEnd/proto).
    :type ports: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-ports>` from speedify.
    """
    args = ["fixeddelay", "ports", "rem"] + ports.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to set fixeddelay port rules")
def fixeddelay_ports_set(ports: str):
    """
    fixeddelay_ports_set(ports)
    Set port(s) to include in the jitter buffer (fixed delay), replacing existing rules.

    Example:
        fixeddelay_ports_set("9000/udp 8000-8010/tcp")

    :param ports: Space-separated port specification(s) (format: port/proto or port-portRangeEnd/proto).
    :type ports: str
    :returns:  dict -- :ref:`JSON traffic rules <fixeddelay-ports>` from speedify.
    """
    args = ["fixeddelay", "ports", "set"] + ports.split()
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to set packetaggregation")
def packetaggregation(is_on: bool = True):
    """
    packetaggregation(is_on = True)
    Sets packetaggregation mode on or off.

    :param is_on: Whether packet aggregation is on... or off.
    :type is_on: bool
    :returns:  dict -- :ref:`JSON settings <packetaggr>` from speedify
    """
    if is_on is True:
        is_on = "on"
    elif is_on is False:
        is_on = "off"
    return _run_speedify_cmd(["packetaggr", is_on])


@exception_wrapper("Failed to set killswitch")
def killswitch(killswitch: bool = False):
    """
    killswitch(killswitch = False)
    sets killswitch on or off. (Windows only)

    :param killswitch: killswitch on or off
    :type killswitch: bool
    :returns:  dict -- :ref:`JSON privacy response <privacy-killswitch>` from speedify
    """
    args = ["privacy", "killswitch"]
    args.append("on") if killswitch else args.append("off")
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set overflow")
def overflow(speed_in_mbps: float = 30.0):
    """
    overflow(speed_in_mbps = 30.0)
    sets overflow threshold.

    :param speed_in_mbps: Overflow threshold in mbps
    :type speed_in_mbps: float
    :returns:  dict -- :ref:`JSON settings <overflow>` from speedify
    """
    args = ["overflow"]
    args.append(str(speed_in_mbps))
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set priority overflow")
def priorityoverflow(speed_in_mbps: float = 70.0):
    """
    priorityoverflow(speed_in_mbps = 70.0)
    sets priority overflow threshold.

    :param speed_in_mbps: Priority overflow threshold in mbps
    :type speed_in_mbps: float
    :returns:  dict -- :ref:`JSON settings <priorityoverflow>` from speedify
    """
    args = ["priorityoverflow"]
    args.append(str(speed_in_mbps))
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set maxredundant")
def maxredundant(num_connections: int = 5):
    """
    maxredundant(num_connections = 5)
    sets maximum number of redundant connections.

    :param num_connections: Maximum number of connections to use in redundant mode
    :type num_connections: int
    :returns:  dict -- :ref:`JSON settings <maxredundant>` from speedify
    """
    args = ["maxredundant"]
    args.append(str(num_connections))
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set packet pool size")
def packetpool(size: str = "default"):
    """
    packetpool(size = "default")
    sets packet pool size.

    :param size: Packet pool size (small, default, or large)
    :type size: str
    :returns:  dict -- :ref:`JSON settings <packetpool>` from speedify
    """
    args = ["packetpool"]
    args.append(str(size))
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set connect retry")
def connectretry(seconds: int = 0):
    """
    connectretry(seconds = 0)
    sets maximum connect retry timeout.

    :param seconds: Maximum number of seconds to wait between connect attempts
    :type seconds: int
    :returns:  dict -- :ref:`JSON settings <connectretry>` from speedify
    """
    args = ["connectretry"]
    args.append(str(seconds))
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set transport retry")
def transportretry(seconds: int = 0):
    """
    transportretry(seconds = 0)
    sets maximum transport retry timeout.

    :param seconds: Maximum number of seconds to wait between transport attempts
    :type seconds: int
    :returns:  dict -- :ref:`JSON settings <transportretry>` from speedify
    """
    args = ["transportretry"]
    args.append(str(seconds))
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set dnsleak")
def dnsleak(leak: bool = False):
    """
    dnsleak(leak = False)
    sets dnsleak on or off. (Windows only)

    :param dnsleak: dnsleak on or off
    :type dnsleak: bool
    :returns:  dict -- :ref:`JSON privacy response <privacy-dnsleak>` from speedify
    """
    args = ["privacy", "dnsleak"]
    args.append("on") if leak else args.append("off")
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set startupconnect")
def startupconnect(is_on: bool = True):
    """
    startupconnect(is_on)

    Sets whether or not to automatically connect on login.

    :param is_on: Sets connect on startup on/off
    :type is_on: bool
    :returns:  dict -- :ref:`JSON settings <startupconnect>` from speedify
    """
    if is_on is True:
        is_on = "on"
    elif is_on is False:
        is_on = "off"
    else:
        raise ValueError("is_on neither True nor False")
    return _run_speedify_cmd(["startupconnect", is_on])


@exception_wrapper("Failed to set route default")
def routedefault(is_default: bool = True):
    """
    routedefault(is_default=True)
    sets whether Speedify should take the default route to the internet.
    defaults to True, only make it False if you're planning to set up
    routing rules, like IP Tables, yourself..

    :param connect: Sets routedefault on/off
    :type connect: bool
    :returns:  dict -- :ref:`JSON settings <routedefault>` from speedify
    """
    if is_default is True:
        is_default = "on"
    elif is_default is False:
        is_default = "off"
    else:
        raise ValueError("is_on neither True nor False")
    return _run_speedify_cmd(["route", "default", is_default])


@exception_wrapper("Failed to run streamtest")
def streamtest():
    """
    streamtest()

    Runs stream test.
    Returns final results.
    Will take around 30 seconds.

    :returns:  dict -- :ref:`JSON streamtest <speedtest>` from speedify
    """
    return _run_speedify_cmd(["speedtest"], cmdtimeout=600)


@exception_wrapper("Failed to run speedtest")
def speedtest():
    """
    speedtest()

    Runs speed test.
    Returns final results.
    Will take around 30 seconds.

    :returns:  dict -- :ref:`JSON speedtest <speedtest>` from speedify
    """
    jret = _run_speedify_cmd(["speedtest"], cmdtimeout=600)
    return jret


@exception_wrapper("Failed to set transport")
def transport(transport: str = "auto"):
    """
    transport(transport='auto')
    Sets the transport mode (auto/tcp/multi-tcp/udp/https).

    :param transport: Sets the transport to one of
        "auto"
        "udp"
        "tcp"
        "multi-tcp"
        "https"
    :type transport: str
    :returns:  dict -- :ref:`JSON settings <transport>` from speedify
    """
    args = ["transport", transport]
    resultjson = _run_speedify_cmd(args)
    return resultjson


@exception_wrapper("Failed to set subnets")
def subnets(*subnet_list):
    """
    subnets(*subnet_list)
    Configures a group of subnets connected to this machine as accessible by other clients on a private server.
    Only for advanced enterprise routing scenarios.

    Example:
        subnets("192.168.202.1/23", "10.0.0.0/24")
        subnets()  # Clear all subnets

    :param subnet_list: Variable number of subnet specifications (format: address/prefix_length).
    :type subnet_list: str
    :returns:  dict -- :ref:`JSON settings <subnets>` from speedify.
    """
    args = ["subnets"] + list(subnet_list)
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to set target connections")
def targetconnections(upload_connections: int, download_connections: int):
    """
    targetconnections(upload_connections, download_connections)
    Controls the amount of connections Speedify will attempt to use for upload and download, respectively.

    Example:
        targetconnections(5, 5)

    :param upload_connections: Number of upload connections to target.
    :type upload_connections: int
    :param download_connections: Number of download connections to target.
    :type download_connections: int
    :returns:  dict -- :ref:`JSON settings <targetconnections>` from speedify.
    """
    return _run_speedify_cmd(["targetconnections", str(upload_connections), str(download_connections)])


@exception_wrapper("Failed getting stats")
def stats(time: int = 1):
    """
    stats(time=1)
    calls stats returns a list of all the parsed json objects it gets back

    :param time: How long to run the stats command.
    :type time: int
    :returns:  list -- list JSON stat responses from speedify.
    """
    if time == 0:
        logger.error("stats cannot be run with 0, would never return")
        raise SpeedifyError("Stats cannot be run with 0")

    class list_callback:
        def __init__(self):
            self.result_list = list()

        def __call__(self, input):
            self.result_list.append(input)

    list_callback = list_callback()
    stats_callback(time, list_callback)
    return list_callback.result_list


def stats_callback(time: int, callback):
    """
    stats_callback(time, callback)
    calls stats, and callback supplied function with each line of output. 0 is forever

    :param time: How long to run the stats command.
    :type time: int
    :param callback: Callback function
    :type callback: function
    """
    args = ["stats", str(time)]
    cmd = [get_cli(), "-s"] + args

    _run_long_command(cmd, callback)


@exception_wrapper("Failed to initialize safe browsing")
def safebrowsing_initialize(settings: str):
    args = ["safebrowsing", "initialize", settings]
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to configure safe browsing")
def safebrowsing_configure(settings: str):
    args = ["safebrowsing", "config", settings]
    return _run_speedify_cmd(args)


@exception_wrapper("Failed to enable safe browsing")
def safebrowsing_enable(enable: bool):
    args = ["safebrowsing", "enable"]
    args.append("on") if enable else args.append("off")
    return _run_speedify_cmd(args)


@exception_wrapper("Failed getting safebrowsing error")
def safebrowsing_error(time: int = 1):
    if time == 0:
        logger.error("safebrowsing error cannot be run with 0, would never return")
        raise SpeedifyError(
            "safebrowsing error cannot be run with 0, would never return"
        )

    class list_callback:
        def __init__(self):
            self.result_list = list()

        def __call__(self, input):
            self.result_list.append(input)

    list_callback = list_callback()
    safebrowsing_error_callback(time, list_callback)
    return list_callback.result_list


def safebrowsing_error_callback(time: int, callback):
    args = ["safebrowsing", "errors", str(time)]
    cmd = [get_cli(), "-s"] + args

    _run_long_command(cmd, callback)


#
# Internal functions
#


def _run_speedify_cmd(args, cmdtimeout: int = 60):
    """
    Core function that executes Speedify CLI commands and parses JSON responses.

    This is the primary interface between Python and the speedify_cli executable. It:
    1. Constructs the command by prepending the CLI path and -s flag to the provided arguments
    2. Executes the command via subprocess with appropriate timeout and shell settings
    3. Parses single-line JSON from the last line in stdout (using -s flag for compact output)
    4. Handles errors by parsing stderr JSON and raising appropriate SpeedifyError exceptions

    The -s flag tells speedify_cli to output JSON as single lines instead of pretty-printed,
    making parsing simpler and more efficient.

    The Speedify CLI returns:
    - Exit code 0: Success, JSON response in stdout
    - Exit code 1: API error from daemon, structured JSON error in stderr
    - Exit code 2-4: CLI parameter errors, plain text error messages

    :param args: List of command arguments to pass to speedify_cli (e.g., ["connect", "closest"])
    :type args: list
    :param cmdtimeout: Maximum time in seconds to wait for command completion (default: 60)
    :type cmdtimeout: int
    :returns: dict -- Parsed JSON response object from the CLI
    :raises SpeedifyError: For general CLI errors, timeouts, or invalid output
    :raises SpeedifyAPIError: For API errors returned by the Speedify daemon (exit code 1)
    """
    resultstr = ""
    try:
        # Build the full command: CLI path + "-s" flag for single-line JSON + user arguments
        cmd = [get_cli(), "-s"] + args

        # Execute the CLI command with appropriate settings
        result = subprocess.run(
            cmd,
            stdout=subprocess.PIPE,  # Capture stdout for JSON response
            stderr=subprocess.PIPE,  # Capture stderr for error messages
            shell=use_shell(),       # Platform-specific: True on Windows, False on Unix
            check=True,              # Raise CalledProcessError on non-zero exit
            timeout=cmdtimeout,      # Prevent indefinite hangs
        )

        # Parse the JSON response from stdout
        resultstr = result.stdout.decode("utf-8").strip()

        # With -s flag, CLI outputs one JSON object per line
        # Split by newlines and take the last non-empty line
        lines = [line for line in resultstr.split('\n') if line.strip()]

        if len(lines) > 0:
            # Parse and return the last JSON object (the final result)
            return json.loads(lines[-1])

        # No output received (shouldn't happen with a successful exit code)
        logger.error("command " + args[0] + " had NO records")
        raise SpeedifyError("No output from command " + args[0])

    except subprocess.TimeoutExpired:
        logger.error("Command timed out")
        raise SpeedifyError("Command timed out: " + args[0])
    except ValueError:
        # JSON parsing failed - CLI returned non-JSON or malformed JSON
        logger.error("Running cmd, bad json: (" + resultstr + ")")
        raise SpeedifyError("Invalid output from CLI")
    except subprocess.CalledProcessError as cpe:
        # The CLI command failed with a non-zero exit code
        # Try stderr first (daemon errors), fall back to stdout if stderr is empty
        out = cpe.stderr.decode("utf-8").strip()
        if not out:
            out = cpe.stdout.decode("utf-8").strip()

        returncode = cpe.returncode

        # Map exit codes to error categories
        # Exit code meanings from speedify_cli:
        # 1 = API error from daemon (structured JSON error)
        # 2 = Invalid parameter value
        # 3 = Missing required parameter
        # 4 = Unknown/unrecognized parameter
        errorKind = "Unknown"
        if returncode == 1:
            errorKind = "Speedify API"
        elif returncode == 2:
            errorKind = "Invalid Parameter"
        elif returncode == 3:
            errorKind = "Missing Parameter"
        elif returncode == 4:
            errorKind = "Unknown Parameter"
            # Exit code 4 returns full usage message, just raise generic error
            raise SpeedifyError(errorKind)

        # Parse the error based on exit code
        newerror = None
        if returncode == 1:
            # Exit code 1 means daemon returned a structured JSON error
            try:
                job = json.loads(out)
                if "errorCode" in job:
                    # Successfully parsed JSON error from daemon
                    newerror = SpeedifyAPIError(
                        job["errorCode"], job["errorType"], job["errorMessage"]
                    )
            except ValueError:
                # JSON parsing failed, treat as generic error
                logger.error("Could not parse Speedify API Error: " + out)
                newerror = SpeedifyError(errorKind + ": Could not parse error message")
        else:
            # Exit codes 2-3 return plain text errors, extract last non-empty line
            lastline = [i for i in out.split("\n") if i][-1]
            if lastline:
                newerror = SpeedifyError(str(lastline))
            else:
                newerror = SpeedifyError(errorKind + ": " + str("Unknown error"))

        # Raise the constructed error
        if newerror:
            raise newerror
        else:
            # Fallback: treat the raw output as an error message
            # This can happen with valid commands but invalid argument combinations
            logger.error("runSpeedifyCmd CPE : " + out)
            raise SpeedifyError(errorKind + ": " + str(": " + out))


#
# Callbacks
#


# The normal _run_speedify_cmd runs the command and waits for the final output.
# these versions keep running, calling you back as json objects are emitted. useful
# for stats and for a verbose speedtest, otherwise, stick with the non-callback versions
#


@exception_wrapper("SpeedifyError in longRunCommand")
def _run_long_command(cmdarray, callback):
    """
    Executes long-running Speedify CLI commands that stream multiple JSON responses.

    Unlike _run_speedify_cmd() which waits for a single final response, this function
    handles commands that continuously output JSON objects over time (like stats or
    continuous monitoring). With the -s flag, each line contains a complete JSON object,
    making parsing straightforward.

    Used internally by stats_callback() and safebrowsing_error_callback() to provide
    real-time monitoring capabilities.

    :param cmdarray: Complete command array including CLI path and -s flag (e.g., ["/path/to/speedify_cli", "-s", "stats", "10"])
    :type cmdarray: list
    :param callback: Function to invoke with each parsed JSON object. Takes one argument: the JSON dict.
    :type callback: function
    :returns: None
    """
    with subprocess.Popen(cmdarray, stdout=subprocess.PIPE) as proc:
        # With -s flag, each line is a complete JSON object
        # Read and process each line as it becomes available
        for line in proc.stdout:
            line = line.decode("utf-8").strip()

            if line:
                # Non-empty line contains a complete JSON object
                # Parse and invoke callback immediately
                _do_callback(callback, line)


def _do_callback(callback, message):
    """
    Helper function that parses a JSON string and invokes a callback with the result.

    Used by _run_long_command() to process buffered output. This function:
    1. Attempts to parse the message string as JSON
    2. If successful, invokes the callback with the parsed JSON object
    3. Logs any parsing or callback execution errors without raising exceptions

    :param callback: Function to invoke with the parsed JSON object
    :type callback: function
    :param message: String containing JSON to parse
    :type message: str
    :returns: None
    """
    jsonret = ""
    try:
        if message:
            jsonret = json.loads(message)
    except SpeedifyError as e:
        logger.debug("problem parsing json: " + str(e))
    if jsonret:
        try:
            callback(jsonret)
        except SpeedifyError as e:
            logger.warning("problem callback: " + str(e))


# Default cli search locations
def _find_cli():
    """
    Locates the speedify_cli executable on the system.

    This function searches for the Speedify CLI executable in the following order:
    1. Checks the SPEEDIFY_CLI environment variable for a custom path
    2. Searches platform-specific default installation paths:
       - macOS: /Applications/Speedify.app/Contents/Resources/speedify_cli
       - Windows: C:\\Program Files (x86)\\Speedify\\speedify_cli.exe
                  C:\\Program Files\\Speedify\\speedify_cli.exe
       - Linux: /usr/share/speedify/speedify_cli

    Called automatically by get_cli() on first use. Users can override the detected
    path by setting the SPEEDIFY_CLI environment variable or calling set_cli().

    :returns: str -- Absolute path to the speedify_cli executable
    :raises SpeedifyError: If the CLI executable cannot be found in any of the default locations
    """
    # Check environment variable first
    if "SPEEDIFY_CLI" in os.environ:
        possible = os.environ["SPEEDIFY_CLI"]
        if possible:
            if os.path.isfile(possible):
                logging.debug("Using cli from SPEEDIFY_CLI of (" + possible + ")")
                return possible
            else:
                logging.warning(
                    'SPEEDIFY_CLI specified a nonexistant path to cli: "'
                    + possible
                    + '"'
                )

    # Search platform-specific default installation paths
    possible_paths = [
        "/Applications/Speedify.app/Contents/Resources/speedify_cli",
        "c://program files (x86)//speedify//speedify_cli.exe",
        "c://program files//speedify//speedify_cli.exe",
        "/usr/share/speedify/speedify_cli",
    ]
    for pp in possible_paths:
        if os.path.isfile(pp):
            logging.debug("Using cli of (" + pp + ")")
            return pp

    logging.error("Could not find speedify_cli!")
    raise SpeedifyError("Speedify CLI not found")