greenlake-activate-cli 0.1.0__py3-none-any.whl

glcli/activate_login.py

@@ -0,0 +1,67 @@
+import os
+import logging
+from pathlib import Path
+
+import requests
+from dotenv import dotenv_values
+
+logger = logging.getLogger(__name__)
+REQUEST_TIMEOUT = 30
+ENVIRONMENT_VARIABLE = "CREDENTIAL_1"
+
+
+def user_config_path() -> Path:
+    """Return the user-level configuration path for the current platform."""
+    config_home = os.environ.get("XDG_CONFIG_HOME")
+    if config_home:
+        return Path(config_home) / "greenlake-activate-cli" / ".env"
+    return Path.home() / ".config" / "greenlake-activate-cli" / ".env"
+
+
+def credential_config_paths() -> tuple[Path, Path]:
+    """Return user-level and project-local credential file paths."""
+    return user_config_path(), Path.cwd() / ".env"
+
+
+def load_credentials() -> str:
+    """Load credentials using environment, user config, then local config."""
+    credential = os.environ.get(ENVIRONMENT_VARIABLE, "").strip()
+    if credential:
+        return credential
+
+    user_path, local_path = credential_config_paths()
+    for path in (user_path, local_path):
+        if not path.is_file():
+            continue
+        credential = str(dotenv_values(path).get(ENVIRONMENT_VARIABLE) or "").strip()
+        if credential:
+            return credential
+
+    raise RuntimeError(
+        f"{ENVIRONMENT_VARIABLE} is not configured. Set it in the environment, "
+        f"or create {user_path} or {local_path} with {ENVIRONMENT_VARIABLE}=<token>."
+    )
+
+def create_activate_session(credential_1:str) -> requests.Session:
+    """Login and return session."""
+    if not credential_1:
+        raise RuntimeError("CREDENTIAL_1 is not configured")
+
+    login_url = "https://activate.arubanetworks.com/LOGIN"
+    login_data = {
+        'credential_0': "username",
+        'credential_1': credential_1
+    }
+    logger.debug("Attempting to authenticate to: %s", login_url)
+    session = requests.session()
+    response = session.post(login_url, data=login_data, timeout=REQUEST_TIMEOUT)
+
+    logger.debug("Login status code: %s", response.status_code)
+    if response.status_code != 200:
+        logger.error("Login failed: %s", response.text)
+        raise RuntimeError("Activate login failed")
+
+    logger.info("Authenticated to Activate")
+    logger.debug("Full login response: %s", response.text)
+
+    return session

glcli/cli.py

@@ -0,0 +1,124 @@
+import logging
+from pathlib import Path
+
+import typer
+from glcli.activate_login import create_activate_session, load_credentials
+from glcli.data_parsing import parse_inventory_response
+from glcli.query_inventory import query_inventory, read_identifiers_from_file
+from glcli.query_folder import resolve_folder_ids
+from glcli.display_data import display_inventory_sn
+from rich.logging import RichHandler
+
+logger = logging.getLogger(__name__)
+app = typer.Typer(help="Interact with HPE GreenLake Activate via CLI.")
+query_app = typer.Typer(help="Query Activate inventory.")
+app.add_typer(query_app, name="query")
+
+def setup_logging(verbose: bool):
+    logging.basicConfig(
+        level=logging.DEBUG if verbose else logging.INFO,
+        format="%(levelname)s %(name)s: %(message)s" if verbose else "%(message)s",
+        handlers=[RichHandler(rich_tracebacks=True, show_path=verbose)],
+    )
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+
+def _load_credential() -> str:
+    try:
+        return load_credentials()
+    except RuntimeError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+def _query(identifier_type: str, identifiers: list[str], file: Path | None = None) -> None:
+    if file is not None:
+        identifiers = read_identifiers_from_file(file, identifier_type)
+
+    identifiers = [identifier.strip().upper() for identifier in identifiers if identifier.strip()]
+    if not identifiers:
+        raise typer.BadParameter("At least one identifier is required")
+
+    identifiers = list(dict.fromkeys(identifiers))
+    credential = _load_credential()
+    try:
+        session = create_activate_session(credential)
+        query_result, missing = query_inventory(session, identifier_type, identifiers)
+    finally:
+        if "session" in locals():
+            session.close()
+
+    extracted_data = parse_inventory_response(query_result)
+
+    if missing:
+        print(f"Not found: ({len(missing)}): {', '.join(missing)}")
+
+    display_inventory_sn(extracted_data)
+
+    if not extracted_data:
+        raise typer.Exit(code=1)
+    if missing:
+        raise typer.Exit(code=2)
+
+
+def _query_folder(values: list[str]) -> None:
+    values = [value.strip() for value in values if value.strip()]
+    if not values:
+        raise typer.BadParameter("At least one folder ID or name is required")
+
+    values = list(dict.fromkeys(values))
+    credential = _load_credential()
+    session = None
+    try:
+        session = create_activate_session(credential)
+        try:
+            folder_ids = resolve_folder_ids(session, values)
+        except ValueError as exc:
+            raise typer.BadParameter(str(exc)) from exc
+        query_result, missing = query_inventory(session, "folder", folder_ids)
+    finally:
+        if session is not None:
+            session.close()
+
+    extracted_data = parse_inventory_response(query_result)
+    display_inventory_sn(extracted_data)
+
+    if not extracted_data:
+        raise typer.Exit(code=1)
+
+
+@app.callback()
+def main_callback(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable debugging output to console."),
+) -> None:
+    setup_logging(verbose)
+
+
+@query_app.command("serial")
+def query_serial(
+    serials: list[str] | None = typer.Argument(None, metavar="SERIAL"),
+    file: Path | None = typer.Option(None, "--file", "-f", help="CSV or text file containing serial numbers."),
+) -> None:
+    _query("serial", serials or [], file)
+
+
+@query_app.command("mac")
+def query_mac(
+    macs: list[str] | None = typer.Argument(None, metavar="MAC"),
+    file: Path | None = typer.Option(None, "--file", "-f", help="CSV or text file containing MAC addresses."),
+) -> None:
+    _query("mac", macs or [], file)
+
+
+@query_app.command("folder")
+def query_folder(
+    folders: list[str] = typer.Argument(..., metavar="FOLDER_ID_OR_NAME"),
+) -> None:
+    _query_folder(folders)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

glcli/data_parsing.py

@@ -0,0 +1,45 @@
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+def parse_inventory_response(response:str) -> list[dict]:
+    """Function to extract the data that I want to get from Activate."""
+
+    try:
+        json_obj = json.loads(response)
+    except json.JSONDecodeError as exc:
+        raise ValueError("Inventory response is not valid JSON") from exc
+
+    if not isinstance(json_obj, dict):
+        raise ValueError("Inventory response must be a JSON object")
+
+    extracted_data: list[dict] = [] # each device is a dictionary
+    devices = json_obj.get("devices")
+
+    if isinstance(devices, list):
+       for device in devices:
+          if not isinstance(device, dict):
+              continue
+
+          serial = device.get("serialNumber")
+          mac = device.get("mac")
+          status = device.get("status")
+          additional_data = device.get("additionalData")
+          if not isinstance(additional_data, dict):
+              additional_data = {}
+          folder = additional_data.get("folder")
+          folder_id = additional_data.get("folderId")
+
+          device_dict = {
+              "serial":serial,
+              "mac":mac,
+              "status":status,
+              "folder":folder,
+              "folderId":folder_id,
+
+          }
+          extracted_data.append(device_dict)
+
+    logger.debug("Extracted data:\n%s", extracted_data)
+    return extracted_data

glcli/display_data.py

@@ -0,0 +1,14 @@
+from rich import print
+from rich.markup import escape
+
+def display_inventory_sn(extracted_data:list[dict]):
+    """Function to display output on the CLI when querying by SN"""
+
+    indent = " " * 5
+    for device in extracted_data:
+        print()
+        print(f"[yellow]Serial[/yellow]: [white]{escape(str(device['serial']))}[/white]")
+        print(f"{indent}[yellow]MAC Address[/yellow]: [white]{escape(str(device['mac']))}[/white]")
+        print(f"{indent}[yellow]Status[/yellow]: [white]{escape(str(device['status']))}[/white]")
+        print(f"{indent}[yellow]Folder[/yellow]: [white]{escape(str(device['folder']))}[/white]")
+        print(f"{indent}[yellow]Folder ID[/yellow]: [white]{escape(str(device['folderId']))}[/white]")

glcli/query_folder.py

@@ -0,0 +1,74 @@
+import requests
+import json
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+FOLDER_URL = "https://activate.arubanetworks.com/api/ext/folder.json?action=query"
+REQUEST_TIMEOUT = 30
+
+
+@dataclass(frozen=True)
+class Folder:
+    folder_id: str
+    name: str
+
+
+def list_folders(session: requests.Session) -> list[Folder]:
+    """Return all folders visible to the authenticated Activate session."""
+    response = session.post(FOLDER_URL, data="", timeout=REQUEST_TIMEOUT)
+    if response.status_code != 200:
+        logger.error("Folder query failure code: %s", response.status_code)
+        raise RuntimeError("Folder query failed.")
+
+    try:
+        payload = json.loads(response.text)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError("Activate returned invalid folder JSON") from exc
+
+    if not isinstance(payload, dict) or not isinstance(payload.get("folders"), list):
+        raise RuntimeError("Activate returned an invalid folder response")
+
+    folders = []
+    for item in payload["folders"]:
+        if not isinstance(item, dict) or not item.get("id") or not item.get("folderName"):
+            continue
+        folders.append(Folder(str(item["id"]), str(item["folderName"])))
+
+    logger.info("Read %d folder(s) from Activate", len(folders))
+    return folders
+
+
+def resolve_folder_ids(session: requests.Session, values: list[str]) -> list[str]:
+    """Resolve folder IDs and exact case-insensitive folder names."""
+    if all(value.isdigit() for value in values):
+        return list(dict.fromkeys(values))
+
+    folders = list_folders(session)
+    by_name: dict[str, list[Folder]] = {}
+    for folder in folders:
+        by_name.setdefault(folder.name.casefold(), []).append(folder)
+
+    resolved: list[str] = []
+    missing: list[str] = []
+    ambiguous: dict[str, list[str]] = {}
+    for value in values:
+        if value.isdigit():
+            resolved.append(value)
+            continue
+
+        matches = by_name.get(value.casefold(), [])
+        if not matches:
+            missing.append(value)
+        elif len(matches) > 1:
+            ambiguous[value] = [folder.folder_id for folder in matches]
+        else:
+            resolved.append(matches[0].folder_id)
+
+    if missing:
+        raise ValueError(f"Folder(s) not found: {', '.join(missing)}")
+    if ambiguous:
+        details = "; ".join(f"{name}: {', '.join(ids)}" for name, ids in ambiguous.items())
+        raise ValueError(f"Folder name(s) are ambiguous: {details}")
+
+    return list(dict.fromkeys(resolved))

glcli/query_inventory.py

@@ -0,0 +1,136 @@
+import requests
+import json
+import logging
+import csv
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+REQUEST_TIMEOUT = 30
+
+def query_inventory(session: requests.Session, identifier_type: str, identifiers: list[str]):
+    """Query GreenLake Activate inventory by serial number or MAC address."""
+    inventory_url = "https://activate.arubanetworks.com/api/ext/inventory.json?action=query"
+    if identifier_type == "serial":
+        payload = {"serialNumbers": identifiers}
+        response_key = "serialNumber"
+    elif identifier_type == "mac":
+        payload = {"devices": identifiers}
+        response_key = "mac"
+    elif identifier_type == "folder":
+        payload = {"folders": identifiers}
+        response_key = None
+    else:
+        raise ValueError(f"Unsupported inventory query type: {identifier_type}")
+
+    raw_data = f"json={json.dumps(payload)}"
+    logger.debug("Query string: %s", raw_data)
+
+    logger.debug("Attempting to query activate inventory: %s", inventory_url)
+    response = session.post(inventory_url, data=raw_data, timeout=REQUEST_TIMEOUT)
+
+    if response.status_code != 200:
+        logger.error("Query failure code: %s", response.status_code)
+        raise RuntimeError("Query failed.")
+
+    try:
+        json_response = json.loads(response.text)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError("Activate returned invalid JSON") from exc
+
+    if not isinstance(json_response, dict) or not isinstance(json_response.get("devices", []), list):
+        raise RuntimeError("Activate returned an invalid inventory response")
+
+    if response_key is None:
+        missing = []
+    else:
+        found = {
+            str(device[response_key]).upper()
+            for device in json_response.get("devices", [])
+            if isinstance(device, dict) and device.get(response_key)
+        }
+        missing = [identifier for identifier in identifiers if identifier.upper() not in found]
+
+    if missing:
+        logger.warning("Not found in Activate inventory: %s", ", ".join(missing))
+
+    logger.info("Query succeeded!")
+    logger.debug("Full query response:\n%s", response.text)
+
+    return response.text, missing
+
+
+def query_by_serial(session: requests.Session, serial_numbers: list[str]):
+    """Query GreenLake Activate inventory by serial number."""
+    return query_inventory(session, "serial", serial_numbers)
+
+
+def query_by_mac(session: requests.Session, mac_addresses: list[str]):
+    """Query GreenLake Activate inventory by MAC address."""
+    return query_inventory(session, "mac", mac_addresses)
+
+
+def query_by_folder(session: requests.Session, folder_ids: list[str]):
+    """Query GreenLake Activate inventory by folder ID."""
+    return query_inventory(session, "folder", folder_ids)
+
+def read_identifiers_from_file(path: Path, identifier_type: str = "serial") -> list[str]:
+    """Read serial numbers or MAC addresses from a CSV or newline-delimited file."""
+    if identifier_type not in {"serial", "mac"}:
+        raise ValueError(f"Unsupported identifier type: {identifier_type}")
+
+    columns_by_type = {
+        "serial": {"serial", "serialnumber", "serial_number", "serial number", "sn"},
+        "mac": {"mac", "macaddress", "mac_address", "mac address", "ethernet address"},
+    }
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    with path.open(newline="", encoding="utf-8-sig") as fh:
+        rows = list(csv.reader(fh))
+
+    if not rows:
+        raise ValueError(f"File is empty: {path}")
+
+    header = [c.strip().lower() for c in rows[0]]
+    col = next((i for i, c in enumerate(header) if c in columns_by_type[identifier_type]), None)
+
+    if col is None:
+        logger.debug("No serial header found in %s; reading first column", path)
+        col = 0
+        data = rows
+    else:
+        logger.debug("Using column '%s' (index %d)", header[col], col)
+        data = rows[1:]
+
+    identifiers = [
+        row[col].strip().upper()
+        for row in data
+        if row and len(row) > col and row[col].strip()
+    ]
+
+    logger.info("Read %d %s(s) from %s", len(identifiers), identifier_type, path)
+    return identifiers
+
+
+def read_serials_from_file(path: Path) -> list[str]:
+    """Read serial numbers from a CSV or newline-delimited text file."""
+    return read_identifiers_from_file(path, "serial")
+
+
+def get_serials(args) -> list[str]:
+    """Resolve serial numbers from either --file or the positional args."""
+    if args.file:
+        serials = read_serials_from_file(args.file)
+    else:
+        serials = args.serials
+
+    serials = [s.strip().upper() for s in serials if s.strip()]
+
+    if not serials:
+        raise ValueError("No serial numbers provided.")
+
+    deduped = list(dict.fromkeys(serials))
+    if len(deduped) != len(serials):
+        logger.warning("Removed %d duplicate serial(s)", len(serials) - len(deduped))
+
+    return deduped

greenlake_activate_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: greenlake-activate-cli
+Version: 0.1.0
+Summary: A CLI tool used to interact with HPE GreenLake Activate
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.2.3
+Requires-Dist: requests>=2.34.2
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.2
+
+# GreenLake Activate CLI
+
+The purpose of this is to help manage devices in HPE GreenLake Activate with an easy to use CLI interface.
+
+# Setup
+
+## Requirements
+
+- Python 3.14 or newer
+- An HPE GreenLake Activate API credential
+- Network access to `activate.arubanetworks.com`
+
+The CLI uses the following Python packages, which are installed automatically:
+
+- Typer
+- Requests
+- Rich
+- Python Dotenv
+
+## Install With uv
+
+[Install uv](https://docs.astral.sh/uv/getting-started/installation/) if it is not
+already available. For a published release, install the CLI as a global command:
+
+```sh
+uv tool install greenlake-activate-cli
+```
+
+This installs the CLI in an isolated environment and makes `glcli` available from
+any directory. If uv reports that its tool directory is not on your `PATH`, run:
+
+```sh
+uv tool update-shell
+```
+
+Restart your shell, then verify the installation:
+
+```sh
+glcli --help
+```
+
+To upgrade or remove the installed CLI:
+
+```sh
+uv tool upgrade greenlake-activate-cli
+uv tool uninstall greenlake-activate-cli
+```
+
+`pipx` is an alternative isolated installer:
+
+```sh
+pipx install greenlake-activate-cli
+```
+
+For development from a source checkout, clone the repository and run:
+
+```sh
+git clone <repository-url>
+cd greenlake_activate_cli
+uv sync
+```
+
+The `uv sync` command creates the project environment, installs the application and
+its dependencies, and makes the `glcli` command available through `uv run`:
+
+```sh
+uv run glcli --help
+```
+
+To install the development dependencies, including the test suite, use:
+
+```sh
+uv sync --dev
+```
+
+## Install With Python and pip
+
+Create a virtual environment, activate it, and install the project from the cloned
+repository:
+
+```sh
+python3.14 -m venv .venv
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install .
+```
+
+The `glcli` command is then available directly:
+
+```sh
+glcli --help
+```
+
+## Configure Credentials
+
+The recommended configuration file is:
+
+```sh
+mkdir -p ~/.config/greenlake-activate-cli
+printf 'CREDENTIAL_1=your_api_key_here\n' \
+	> ~/.config/greenlake-activate-cli/.env
+chmod 600 ~/.config/greenlake-activate-cli/.env
+```
+
+The CLI also accepts the environment variable directly:
+
+```sh
+export CREDENTIAL_1="your_api_key_here"
+```
+
+Credential sources are checked in this order:
+
+1. A non-empty `CREDENTIAL_1` environment variable.
+2. `$XDG_CONFIG_HOME/greenlake-activate-cli/.env`, when `XDG_CONFIG_HOME` is set.
+3. `~/.config/greenlake-activate-cli/.env`.
+4. `.env` in the current directory, retained for development and backward compatibility.
+
+The configuration file format is:
+
+```plain
+CREDENTIAL_1=<your_api_key_here>
+```
+
+Do not commit `.env` or share the credential. If no source contains `CREDENTIAL_1`,
+the CLI reports the supported locations and exits before sending an inventory query.
+
+# Usage
+
+Query inventory by serial number:
+
+```sh
+glcli query serial PHWLKAS02 PHWLKAS03
+```
+
+Query inventory by MAC address:
+
+```sh
+glcli query mac aa:bb:cc:00:11:22 dd:ee:ff:33:44:55
+```
+
+Query inventory by folder ID or folder name:
+
+```sh
+glcli query folder 5297450
+glcli query folder SiteA-South
+glcli query folder SiteA-South 5389522
+```
+
+Folder names are matched case-insensitively and exactly. Numeric values are treated
+as folder IDs. Folder names are resolved through Activate before the inventory query;
+unknown or ambiguous names are rejected. Folder queries currently accept positional
+values only and do not support `--file`.
+
+Serial numbers and MAC addresses can also be loaded from CSV or newline-delimited files:
+
+```sh
+glcli query serial --file serials.csv
+glcli query mac --file mac_addresses.csv
+```
+
+The file reader uses the first column. Serial files may use a `serial`, `serialNumber`,
+`serial_number`, `serial number`, or `sn` header.
+
+Use `--verbose` for diagnostic logging:
+
+```sh
+glcli --verbose query serial PHWLKAS02
+```
+
+Exit codes are `0` for a complete result, `1` when no devices are returned, and
+`2` when at least one requested identifier is missing.
+
+Run the offline tests with:
+
+```sh
+uv run pytest
+```

greenlake_activate_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+glcli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+glcli/activate_login.py,sha256=198BfJ7YqvQS3ENyohTxE4JiU_xPCkfS-rVEnOCDLg0,2262
+glcli/cli.py,sha256=Mh07tDDg34e0X8td9uqhlebnDKGBSQPuRWvpF8uyNcA,3959
+glcli/data_parsing.py,sha256=7tVGEjq80pCS6Xlpnoid8WaHdL4FgTtXKADJdtFWErY,1396
+glcli/display_data.py,sha256=OMwg7n4wEBGMoB3BZoF0VevYofe2T7IyR4NcvYC9qmA,737
+glcli/query_folder.py,sha256=e_CKhEn0N6qqVGdCJ7NVRY_oTVrnCM1arRV4CNv0xLY,2543
+glcli/query_inventory.py,sha256=nI3bDhXVQt4tXJf0U1FmOen0xIqNTyfMNtaMWdy2R2c,4893
+greenlake_activate_cli-0.1.0.dist-info/METADATA,sha256=8dFj8JsKMbtZBb1PYHHzUUBRq3FgBPL3L8eMOzzy03s,4368
+greenlake_activate_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+greenlake_activate_cli-0.1.0.dist-info/entry_points.txt,sha256=DL7gkYwMiDwSFNS_ZxwJp_OriwHg9D0MRNWNwdFkZVE,41
+greenlake_activate_cli-0.1.0.dist-info/top_level.txt,sha256=oMA6AccGyVhCJGGli7wciMdS8wFsV79gQQdUMLPUetY,6
+greenlake_activate_cli-0.1.0.dist-info/RECORD,,

greenlake_activate_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

greenlake_activate_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+glcli = glcli.cli:main

greenlake_activate_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+glcli