System

from litmussdk.system import (
    users,
    tokens,
    network,
    ldap,
    certificates,
    events,
    external_storage,
    general,
    device_management,
    services,
    templates,
    wifi,
)

version = general.get_version()              # str, firmware version string
fw = general.firmware_info()                 # dict
mem = general.memory_info()                  # dict
storage = general.storage_info()             # dict
cpu = general.cpu_info()                     # list[dict]
net = general.network_info()                 # list[dict]
macs = general.mac_address()                 # list[dict]
modem = general.modem_info()                 # list[dict]

# List / get
all_users = users.list_users()               # list[dict]
user = users.get_user_by_id(user_id)         # dict

# Create
user = users.create_user(
    first_name="Jane",
    last_name="Doe",
    username="jdoe",
    password="s3cr3t",
    must_change_password=False,
)
user_id = user["id"]

# Update
users.update_user(
    user_id=user_id,
    current_password="s3cr3t",
    new_password="n3wpass",
    new_first_name="Jane",
    new_last_name="Doe",
    new_user_name="jdoe",
)

# Delete
users.delete_user(user_id)

groups = users.get_user_groups()             # list[dict]
details = users.get_user_group_details(group_id)

group = users.create_user_group("operators")
group_id = group["id"]

users.add_users_to_group(group_id, [user_id])
users.update_user_group_name(group_id, "engineers")
users.delete_user_group(group_id)

roles = users.get_user_roles()
role = users.add_user_role(name="viewer")
users.update_user_role(user_role=role["id"], name="reader")
users.delete_user_role(role["id"])

keys = tokens.get_api_keys()                 # list[dict]

key = tokens.create_api_key("my-key")
key_id = key["id"]

tokens.validate_api_key("my-key")
tokens.show_api_key_by_id(key_id)
tokens.update_api_key(key_id, "renamed-key")
tokens.delete_api_key_by_id(key_id)

from datetime import datetime

clients = tokens.get_oauth_clients()         # list[dict]

client = tokens.create_oauth_client(
    client_name="my-sdk-client",
    groups={"admin"},
    expiry_date=None,                        # or a datetime for expiry
    token_ttl_minutes=5,
)
client_id = client["id"]

tokens.get_oauth_client_by_id(client_id)
tokens.rename_oauth_client(client_id, "renamed-client")
tokens.delete_oauth_client_by_id(client_id)

# Device info
info = network.device_network_info()
iface = network.network_interface_details("eth0")
config = network.network_interface_config()
rules = network.firewall_rules()

# Names / locale
name = network.get_friendly_name()
network.set_friendly_name("my-edge-device")
country = network.get_country()
network.set_country("CA")

# Time
network.set_timezone("America/Toronto")
timezones = network.available_timezones()
network.set_ntp_servers(["pool.ntp.org"])

import datetime
network.set_system_clock(
    date=datetime.date(2025, 1, 15),
    time=datetime.time(12, 0, 0),
)

# DNS / Docker
network.set_dns_resolvers(["8.8.8.8", "1.1.1.1"])
network.set_docker_config(docker_binding_ip="10.30.50.1/24")

interfaces = network.get_packet_capture_interfaces()
status = network.packet_capture_status()

network.start_stop_packet_capture(action="start", interface="eth0", duration="30s")
network.start_stop_packet_capture(action="stop")

modems = network.list_available_modems()
network.update_modem_config(imei="123456789012345", apn="broadband")

ifaces = wifi.wifi_interfaces()
status = wifi.wifi_interfaces_status("wlan0")
networks = wifi.wifi_interfaces_networks("wlan0")
known = wifi.wifi_known_networks()

wifi.wifi_connect_with_password(ssid="MyNetwork", password="wifi-pass")
wifi.wifi_forget_network("MyNetwork")

providers = ldap.list_auth_providers()
details = ldap.auth_providers_details(provider_id)
status = ldap.ldap_provider_status(provider_id)
groups = ldap.ldap_provider_user_group(provider_id)

# Create
provider = ldap.create_new_auth_providers(
    host="ldap.example.com",
    port=389,
    base_dn="dc=example,dc=com",
    # ... driver-specific kwargs
)

# Test config before saving
ldap.ldap_test_config(host="ldap.example.com", base_dn="dc=example,dc=com")

# Update / delete
ldap.update_ldap_config(provider_id, host="ldap2.example.com")
ldap.delete_ldap_config(provider_id)

# Device certificate
cert = certificates.get_device_certificate()
csr = certificates.get_csr()

certificates.add_device_certificate(
    ca_chain="-----BEGIN CERTIFICATE-----\n...",
    certificate="-----BEGIN CERTIFICATE-----\n...",
    cert_key="-----BEGIN PRIVATE KEY-----\n...",
)
certificates.reset_device_certificate()

# Custom CA
ca = certificates.get_custom_ca_certificate()

# Identity certificates
identity = certificates.show_device_identity()
id_certs = certificates.get_identity_certificates()
certificates.install_identity_certificates(ca_chain="...", certificate="...")
certificates.delete_identity_certificates(ca_chain="...", certificate="...")

import time

now = int(time.time() * 1000)
one_hour_ago = now - 3_600_000

result = events.get_events(
    from_timestamp=one_hour_ago,
    to_timestamp=now,
    component="devicehub",   # optional filter
    severity="ERROR",        # optional filter
    count=50,
    offset=0,
)
# result: {events: [...], total: int}

stats = events.event_management_stats()
reports = events.events_zero_touch_reports()

# List
mounts = external_storage.list_attached_storages()

# Create
external_storage.create_new_cifs_mount(
    name="nas-share",
    share="//192.168.1.100/data",
    username="user",
    password="pass",
    domain="WORKGROUP",
    mount_on_boot=True,
    read_only=False,
)

# Get / update
details = external_storage.get_cifs_mount_details("nas-share")
external_storage.update_cifs_mount(
    cifs_mount_name="nas-share",
    share="//192.168.1.100/data2",
    username="user",
    password="newpass",
    domain="WORKGROUP",
    mount_on_boot=True,
    read_only=False,
    name="nas-share",
)

external_storage.create_ftp_mount(
    name="ftp-backup",
    share="ftp.example.com/backups",
    username="ftpuser",
    password="ftppass",
    mount_on_boot=True,
    read_only=True,
)

details = external_storage.get_ftp_mount_details("ftp-backup")
external_storage.update_ftp_mount(
    ftp_mount_name="ftp-backup",
    name="ftp-backup",
    share="ftp.example.com/backups2",
    username="ftpuser",
    password="newpass",
    mount_on_boot=True,
    read_only=False,
)

external_storage.mount_attached_storage("nas-share")
external_storage.unmount_attached_storage("nas-share")
external_storage.delete_mount_point("nas-share")

all_services = services.show_available_services()
status = services.show_service_status("mosquitto")
ftp_status = services.ftp_service_status()
ssh_status = services.ssh_service_status()

services.start_and_enable_service("mosquitto")
services.stop_and_disable_service("mosquitto")

user = services.create_ftp_user("ftpuser")
services.reset_ftp_user_password("ftpuser", "newpass")
services.delete_ftp_user("ftpuser")

# Cloud registration
status = device_management.show_cloud_registration_status()
device_management.register_with_cloud("ACTIVATION-CODE")
device_management.de_register_with_cloud()

# Cloud manager URL
url = device_management.show_cloud_url()
device_management.set_cloud_url("https://manager.example.com")

# Backup
interval = device_management.show_backup_interval()   # {interval: int}
device_management.set_backup_interval(24)             # hours

# Software
updates = device_management.list_software_updates()

# Power, use with caution
device_management.reboot_device()
device_management.shutdown_device()
device_management.factory_reset()    # irreversible

# See what can be included
items = templates.list_available_configurable_items()

# Export full template
full = templates.download_template_complete()

# Export selective template
partial = templates.download_template(
    dns=True,
    ntp=True,
    timezone=True,
    devices=["device-id-1"],
    flows=["flow-id-1"],
)

# Apply a template
templates.apply_template(partial)