jetsontools 0.0.1__tar.gz

jetsontools-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Justin Davis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jetsontools-0.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include src/jetsontools/py.typed
+include src/jetsontools/_scripts/jetson_libraries.sh
+include src/jetsontools/_scripts/jetson_variables.sh

jetsontools-0.0.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: jetsontools
+Version: 0.0.1
+Summary: Tools for working with NVIDIA Jetson devices.
+Author-email: Justin Davis <davisjustin302@gmail.com>
+Maintainer-email: Justin Davis <davisjustin302@gmail.com>
+Project-URL: Homepage, https://github.com/justincdavis/jetsontools
+Project-URL: Bug Tracker, https://github.com/justincdavis/jetsontools/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Typing :: Typed
+Requires-Python: <=3.13,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions>=4.0.0
+Provides-Extra: ci
+Requires-Dist: pyupgrade>=3.10; extra == "ci"
+Requires-Dist: ruff>=0.4.5; extra == "ci"
+Requires-Dist: mypy>=1.10.0; extra == "ci"
+Requires-Dist: types-setuptools>=57.0.0; extra == "ci"
+Requires-Dist: types-tqdm>=4.66.0; extra == "ci"
+Provides-Extra: test
+Requires-Dist: pytest>=6.2.0; extra == "test"
+Requires-Dist: hypothesis[numpy]>=6.98.0; extra == "test"
+Requires-Dist: pybboxes>=0.1.6; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6.1.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.3.0; extra == "docs"
+Requires-Dist: myst_parser>=1.0.0; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: jetsontools[jit]; extra == "dev"
+Requires-Dist: jetsontools[ci]; extra == "dev"
+Requires-Dist: jetsontools[test]; extra == "dev"
+Requires-Dist: jetsontools[docs]; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: wheel>=0.37.0; extra == "dev"
+Requires-Dist: bumpver>=2023.1126; extra == "dev"
+Requires-Dist: pyclean>=2.7.0; extra == "dev"
+Requires-Dist: pyright>=1.1.348; extra == "dev"
+Requires-Dist: seaborn>=0.13.0; extra == "dev"
+
+# jetsontools
+Tools for working with NVIDIA Jetson devices.

jetsontools-0.0.1/README.md

@@ -0,0 +1,2 @@
+# jetsontools
+Tools for working with NVIDIA Jetson devices.

jetsontools-0.0.1/pyproject.toml

@@ -0,0 +1,176 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jetsontools"
+version = "0.0.1"
+authors = [
+  {name="Justin Davis", email="davisjustin302@gmail.com"},
+]
+maintainers = [
+  {name="Justin Davis", email="davisjustin302@gmail.com"},
+]
+description = "Tools for working with NVIDIA Jetson devices."
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Natural Language :: English",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "Intended Audience :: End Users/Desktop",
+    "Typing :: Typed",
+]
+requires-python=">=3.8, <=3.13"
+dependencies = [
+    "typing_extensions>=4.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/justincdavis/jetsontools"
+"Bug Tracker" = "https://github.com/justincdavis/jetsontools/issues"
+
+[project.optional-dependencies]
+ci = [
+    "pyupgrade>=3.10",
+    "ruff>=0.4.5",
+    "mypy>=1.10.0",
+    "types-setuptools>=57.0.0",
+    "types-tqdm>=4.66.0",
+]
+test = [
+    "pytest>=6.2.0",
+    "hypothesis[numpy]>=6.98.0",
+    "pybboxes>=0.1.6",
+]
+docs = [
+    "sphinx>=6.1.0",
+    "sphinx-rtd-theme>=1.3.0",
+    "myst_parser>=1.0.0",
+]
+dev = [
+    "jetsontools[jit]",
+    "jetsontools[ci]",
+    "jetsontools[test]",
+    "jetsontools[docs]",
+    "twine>=4.0.0",
+    "wheel>=0.37.0",
+    "bumpver>=2023.1126",
+    "pyclean>=2.7.0",
+    "pyright>=1.1.348",
+    "seaborn>=0.13.0",
+]
+
+[tool.bumpver]
+current_version = "0.0.1"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message  = "Bump version {old_version} -> {new_version}"
+commit          = true
+tag             = true
+push            = false
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = ['current_version = "{version}"', 'version = "{version}"']
+"src/jetsontools/__init__.py" = ["{version}"]
+"docs/conf.py" = ["{version}"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"jetsontools" = ["py.typed"]
+
+[tool.ruff]
+fix = true
+show-fixes = true
+target-version = "py38"
+builtins = ["_"]
+line-length = 88
+indent-width = 4
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-format = true
+docstring-code-line-length = "dynamic"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["PLR", "C901", "E501", "D203", "D212", "ERA", "DOC502"]
+fixable = ["ALL"]
+unfixable = []
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+per-file-ignores = {}
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.mypy]
+python_version = "3.8"
+warn_unused_configs = true
+warn_redundant_casts = true
+warn_unused_ignores = false
+strict_equality = true
+check_untyped_defs = true
+disallow_subclassing_any = true
+disallow_untyped_decorators = true
+disallow_any_generics = false
+disallow_untyped_calls = true
+disallow_incomplete_defs = true
+disallow_untyped_defs = true
+no_implicit_reexport = true
+warn_return_any = true
+
+[tool.pyright]
+include = ["src"]
+exclude = ["**/node_modules",
+    "**/__pycache__",
+]
+
+ignore = ["scripts/*"]
+
+defineConstant = {DEBUG = true}
+stubPath = "typings"
+reportMissingImports = true
+reportMissingTypeStubs = false
+  
+pythonVersion = "3.8"
+pythonPlatform = "Linux"
+
+executionEnvironments = [
+    { root = "src", pythonVersion = "3.8", stubPath = "typings" },
+]

jetsontools-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jetsontools-0.0.1/src/jetsontools/__init__.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2024 Justin Davis (davisjustin302@gmail.com)
+#
+# MIT License
+# ruff: noqa: E402, I001
+"""
+Package for bounding boxes and their operations.
+
+Submodules
+----------
+info
+    Tools for getting information about the Jetson device.
+
+Classes
+-------
+Tegrastats
+    Runs tegrastats in a separate process and stores output in a file.
+
+Functions
+---------
+set_log_level
+    Set the log level for the jetsontools package.
+
+"""
+
+from __future__ import annotations
+
+# setup the logger before importing anything else
+import logging
+import os
+import sys
+
+
+# Created from answer by Dennis at:
+# https://stackoverflow.com/questions/7621897/python-logging-module-globally
+def _setup_logger(level: str | None = None) -> None:
+    if level is not None:
+        level = level.upper()
+    level_map: dict[str | None, int] = {
+        "DEBUG": logging.DEBUG,
+        "INFO": logging.INFO,
+        "WARNING": logging.WARNING,
+        "WARN": logging.WARNING,
+        "ERROR": logging.ERROR,
+        "CRITICAL": logging.CRITICAL,
+        None: logging.WARNING,
+    }
+    try:
+        log_level = level_map[level]
+    except KeyError:
+        log_level = logging.WARNING
+
+    # create logger
+    logger = logging.getLogger(__package__)
+    logger.setLevel(log_level)
+    formatter = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+    stdout_handler = logging.StreamHandler(sys.stdout)
+    stdout_handler.setLevel(log_level)
+    stdout_handler.setFormatter(formatter)
+    logger.addHandler(stdout_handler)
+
+
+def set_log_level(level: str) -> None:
+    """
+    Set the log level for the jetsontools package.
+
+    Parameters
+    ----------
+    level : str
+        The log level to set. One of "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL".
+
+    Raises
+    ------
+    ValueError
+        If the level is not one of the allowed values.
+
+    """
+    if level.upper() not in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
+        err_msg = f"Invalid log level: {level}"
+        raise ValueError(err_msg)
+    _setup_logger(level)
+
+
+level = os.getenv("JETSONTOOLS_LOG_LEVEL")
+_setup_logger(level)
+_log = logging.getLogger(__name__)
+if level is not None and level.upper() not in [
+    "DEBUG",
+    "INFO",
+    "WARNING",
+    "ERROR",
+    "CRITICAL",
+]:
+    _log.warning(f"Invalid log level: {level}. Using default log level: WARNING")
+
+from . import info
+from ._tegrastats import Tegrastats
+
+__all__ = [
+    "Tegrastats",
+    "info",
+    "set_log_level",
+]
+__version__ = "0.0.1"
+
+_log.info(f"Initialized jetsontools with version {__version__}")

jetsontools-0.0.1/src/jetsontools/_scripts/jetson_libraries.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# This file is part of the jetson_stats package (https://github.com/rbonghi/jetson_stats or http://rnext.it).
+# Copyright (c) 2020 Raffaello Bonghi.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+# Read CUDA version
+if [ -f /usr/local/cuda/version.txt ]; then
+    JETSON_CUDA=$(cat /usr/local/cuda/version.txt | sed 's/\CUDA Version //g')
+elif [ -f /usr/local/cuda/bin/nvcc ]; then
+    JETSON_CUDA=$(/usr/local/cuda/bin/nvcc --version | egrep -o "V[0-9]+.[0-9]+.[0-9]+" | cut -c2-)
+else
+    JETSON_CUDA="NOT_INSTALLED"
+fi
+# Jetson CUDA version
+export JETSON_CUDA
+
+# Read from OpenCV if is installed CUDA
+opencv_read_cuda()
+{
+    # Red if use CUDA or not
+    local OPENCV_VERSION_VERBOSE=$(opencv_version --verbose | grep "Use Cuda" )
+    if [ ! -z "$OPENCV_VERSION_VERBOSE" ]; then
+        # Read status of CUDA
+        local OPENCV_CUDA_FLAG=$(echo $OPENCV_VERSION_VERBOSE | cut -f2 -d ':' | tr -s ' ' | cut -d' ' -f2 )
+        if [ "$OPENCV_CUDA_FLAG" == "NO" ]; then
+            # Set NO if cuda is not installed
+            echo "NO"
+        else
+            # Set YES if cuda is installed
+            echo "YES"
+        fi
+        return
+    fi
+    # read NVIDIA CUDA version
+    OPENCV_VERSION_VERBOSE=$(opencv_version --verbose | grep "NVIDIA CUDA" )
+    if [ ! -z "$OPENCV_VERSION_VERBOSE" ]; then
+        # get information
+        local OPENCV_CUDA_FLAG=$(echo $OPENCV_VERSION_VERBOSE | cut -f2 -d ':' | tr -s ' ' | cut -d' ' -f4 | cut -d',' -f1 )
+        OPENCV_CUDA_FLAG=${OPENCV_CUDA_FLAG//[[:blank:]]/}
+        # Set YES if cuda is installed
+        echo "YES"
+        return
+    fi
+    echo "NO"
+    return
+}
+
+if hash opencv_version 2>/dev/null; then
+    JETSON_OPENCV="$(opencv_version)"
+    # Read information about cuda status
+    JETSON_OPENCV_CUDA=$(opencv_read_cuda)
+else
+    JETSON_OPENCV="NOT_INSTALLED"
+    JETSON_OPENCV_CUDA="NO"
+fi
+# Opencv variables
+export JETSON_OPENCV
+export JETSON_OPENCV_CUDA
+
+# Extract cuDNN version
+JETSON_CUDNN=$(dpkg -l 2>/dev/null | grep -m1 "libcudnn")
+if [ ! -z "$JETSON_CUDNN" ] ; then
+    JETSON_CUDNN=$(echo $JETSON_CUDNN | sed 's/.*libcudnn[0-9] \([^ ]*\).*/\1/' | cut -d '-' -f1 )
+else
+    JETSON_CUDNN="NOT_INSTALLED"
+fi
+# Export NVIDIA CuDNN Library
+export JETSON_CUDNN
+
+# Extract TensorRT version
+JETSON_TENSORRT=$(dpkg -l 2>/dev/null | grep -m1 " tensorrt ")
+if [ ! -z "$JETSON_TENSORRT" ] ; then
+    JETSON_TENSORRT=$(echo $JETSON_TENSORRT | sed 's/.*tensorrt \([^ ]*\).*/\1/' | cut -d '-' -f1 )
+else
+    JETSON_TENSORRT="NOT_INSTALLED"
+fi
+# Export NVIDIA CuDNN TensorRT
+export JETSON_TENSORRT
+
+# Extract Visionworks version
+JETSON_VISIONWORKS=$(dpkg -l 2>/dev/null | grep -m1 "libvisionworks")
+if [ ! -z "$JETSON_VISIONWORKS" ] ; then
+    JETSON_VISIONWORKS=$(echo $JETSON_VISIONWORKS | sed 's/.*libvisionworks \([^ ]*\).*/\1/' )
+else
+    JETSON_VISIONWORKS="NOT_INSTALLED"
+fi
+# Export NVIDIA CuDNN VisionWorks
+export JETSON_VISIONWORKS
+
+# Extract VPI
+JETSON_VPI=$(dpkg -l 2>/dev/null | grep -m1 "vpi")
+if [ ! -z "$JETSON_VPI" ] ; then
+    JETSON_VPI=$(echo $JETSON_VPI | sed 's/.*vpi[0-9] \([^ ]*\).*/\1/' | cut -d '-' -f1  )
+else
+    JETSON_VPI="NOT_INSTALLED"
+fi
+# Export VPI
+export JETSON_VPI
+
+# Vulkan
+JETSON_VULKAN_INFO=$(which vulkaninfo)
+if [ ! -z $JETSON_VULKAN_INFO ] ; then
+    JETSON_VULKAN_INFO=$($JETSON_VULKAN_INFO 2> /dev/null | grep -m1 "Vulkan Instance Version")
+    JETSON_VULKAN_INFO=$(echo $JETSON_VULKAN_INFO | sed 's/.*: \([^ ]*\).*/\1/' )
+else
+    JETSON_VULKAN_INFO="NOT_INSTALLED"
+fi
+# Export VPI
+export JETSON_VULKAN_INFO
+#EOF

jetsontools-0.0.1/src/jetsontools/_scripts/jetson_variables.sh

@@ -0,0 +1,207 @@
+#!/bin/bash
+# This file is part of the jetson_stats package (https://github.com/rbonghi/jetson_stats or http://rnext.it).
+# Copyright (c) 2020 Raffaello Bonghi.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+# TODO Add enviroments variables:
+# - UID -> https://devtalk.nvidia.com/default/topic/996988/jetson-tk1/chip-uid/post/5100481/#5100481
+# - GCID, BOARD, EABI
+
+###########################
+#### JETPACK DETECTION ####
+###########################
+# Write version of jetpack installed
+# https://developer.nvidia.com/embedded/jetpack-archive
+jetson_jetpack()
+{
+    local JETSON_L4T=$1
+    local JETSON_JETPACK=""
+    case $JETSON_L4T in
+        "35.1.0") JETSON_JETPACK="5.0.2" ;;
+        "34.1.1") JETSON_JETPACK="5.0.1 DP" ;;
+        "34.1.0") JETSON_JETPACK="5.0 DP" ;;
+        "32.7.3") JETSON_JETPACK="4.6.3" ;;
+        "32.7.2") JETSON_JETPACK="4.6.2" ;;
+        "32.7.1") JETSON_JETPACK="4.6.1" ;;
+        "32.6.1") JETSON_JETPACK="4.6" ;;
+        "32.5.1" | "32.5.2") JETSON_JETPACK="4.5.1" ;;
+        "32.5.0" | "32.5") JETSON_JETPACK="4.5" ;;
+        "32.4.4") JETSON_JETPACK="4.4.1" ;;
+        "32.4.3") JETSON_JETPACK="4.4" ;;
+        "32.4.2") JETSON_JETPACK="4.4 DP" ;;
+        "32.3.1") JETSON_JETPACK="4.3" ;;
+        "32.2.3") JETSON_JETPACK="4.2.3" ;;
+        "32.2.1") JETSON_JETPACK="4.2.2" ;;
+        "32.2.0" | "32.2") JETSON_JETPACK="4.2.1" ;;
+        "32.1.0" | "32.1") JETSON_JETPACK="4.2" ;;
+        "31.1.0" | "31.1") JETSON_JETPACK="4.1.1" ;;
+        "31.0.2") JETSON_JETPACK="4.1" ;;
+        "31.0.1") JETSON_JETPACK="4.0" ;;
+        "28.4.0") JETSON_JETPACK="3.3.3" ;;
+        "28.2.1") JETSON_JETPACK="3.3 | 3.2.1" ;;
+        "28.2.0" | "28.2") JETSON_JETPACK="3.2" ;;
+        "28.1.0" | "28.1") JETSON_JETPACK="3.1" ;;
+        "27.1.0" | "27.1") JETSON_JETPACK="3.0" ;;
+        "24.2.1") JETSON_JETPACK="3.0 | 2.3.1" ;;
+        "24.2.0" | "24.2") JETSON_JETPACK="2.3" ;;
+        "24.1.0" | "24.1") JETSON_JETPACK="2.2.1 | 2.2" ;;
+        "23.2.0" | "23.2") JETSON_JETPACK="2.1" ;;
+        "23.1.0" | "23.1") JETSON_JETPACK="2.0" ;;
+        "21.5.0" | "21.5") JETSON_JETPACK="2.3.1 | 2.3" ;;
+        "21.4.0" | "21.4") JETSON_JETPACK="2.2 | 2.1 | 2.0 | 1.2 DP" ;;
+        "21.3.0" | "21.3") JETSON_JETPACK="1.1 DP" ;;
+        "21.2.0" | "21.2") JETSON_JETPACK="1.0 DP" ;;
+        *) JETSON_JETPACK="UNKNOWN" ;;
+    esac
+    # return type jetpack
+    echo $JETSON_JETPACK
+}
+###########################
+
+JETSON_MODEL="UNKNOWN"
+# Extract jetson model name
+if [ -f /sys/firmware/devicetree/base/model ]; then
+    JETSON_MODEL=$(tr -d '\0' < /sys/firmware/devicetree/base/model)
+fi
+
+# Extract jetson chip id
+JETSON_CHIP_ID=""
+if [ -f /sys/module/tegra_fuse/parameters/tegra_chip_id ]; then
+    JETSON_CHIP_ID=$(cat /sys/module/tegra_fuse/parameters/tegra_chip_id)
+fi
+# Ectract type board
+JETSON_SOC=""
+if [ -f /proc/device-tree/compatible ]; then
+    # Extract the last part of name
+    JETSON_SOC=$(tr -d '\0' < /proc/device-tree/compatible | sed -e 's/.*,//')
+fi
+# Extract boardids if exists
+JETSON_BOARDIDS=""
+if [ -f /proc/device-tree/nvidia,boardids ]; then
+    JETSON_BOARDIDS=$(tr -d '\0' < /proc/device-tree/nvidia,boardids)
+fi
+
+# Code name
+JETSON_CODENAME=""
+JETSON_MODULE="UNKNOWN"
+JETSON_CARRIER="UNKNOWN"
+list_hw_boards()
+{
+    # Extract from DTS the name of the boards available
+    # Reference:
+    # 1. https://unix.stackexchange.com/questions/251013/bash-regex-capture-group
+    # 2. https://unix.stackexchange.com/questions/144298/delete-the-last-character-of-a-string-using-string-manipulation-in-shell-script
+    local s=$1
+    local regex='p([0-9-]+)' # Equivalent to p([\d-]*-)
+    while [[ $s =~ $regex ]]; do
+        local board_name=$(echo "P${BASH_REMATCH[1]}" | sed 's/-*$//' )
+        # Load jetson type
+        # If jetson type is not empty the module name is the same
+        if [ $JETSON_MODULE = "UNKNOWN" ] ; then
+            JETSON_MODULE=$board_name
+            echo "JETSON_MODULE=\"$JETSON_MODULE\""
+        else
+            JETSON_CARRIER=$board_name
+            echo "JETSON_CARRIER=\"$JETSON_CARRIER\""
+        fi
+        # Find next match
+        s=${s#*"${BASH_REMATCH[1]}"}
+    done
+}
+# Read DTS file
+# 1. https://devtalk.nvidia.com/default/topic/1071080/jetson-nano/best-way-to-check-which-tegra-board/
+# 2. https://devtalk.nvidia.com/default/topic/1014424/jetson-tx2/identifying-tx1-and-tx2-at-runtime/
+# 3. https://devtalk.nvidia.com/default/topic/996988/jetson-tk1/chip-uid/post/5100481/#5100481
+if [ -f /proc/device-tree/nvidia,dtsfilename ]; then
+    # ..<something>/hardware/nvidia/platform/t210/porg/kernel-dts/tegra210-p3448-0000-p3449-0000-b00.dts
+    # The last third is the codename of the board
+    JETSON_CODENAME=$(tr -d '\0' < /proc/device-tree/nvidia,dtsfilename)
+    JETSON_CODENAME=$(echo ${JETSON_CODENAME#*"/hardware/nvidia/platform/"} | tr '/' '\n' | head -2 | tail -1 )
+    # The basename extract the board type
+    JETSON_DTS="$(tr -d '\0' < /proc/device-tree/nvidia,dtsfilename | sed 's/.*\///')"
+    # List of all boards
+    eval $(list_hw_boards "$JETSON_DTS")
+fi
+
+# Export variables
+export JETSON_MODEL
+export JETSON_CHIP_ID
+export JETSON_SOC
+export JETSON_BOARDIDS
+export JETSON_CODENAME
+export JETSON_MODULE
+export JETSON_CARRIER
+
+# Write CUDA architecture
+# https://developer.nvidia.com/cuda-gpus
+# https://devtalk.nvidia.com/default/topic/988317/jetson-tx1/what-should-be-the-value-of-cuda_arch_bin/
+case $JETSON_MODEL in
+    *Orin*) JETSON_CUDA_ARCH_BIN="8.7" ;;
+    *Xavier*) JETSON_CUDA_ARCH_BIN="7.2" ;;
+    *TX2*) JETSON_CUDA_ARCH_BIN="6.2" ;;
+    *TX1* | *Nano*) JETSON_CUDA_ARCH_BIN="5.3" ;;
+    *TK1*) JETSON_CUDA_ARCH_BIN="3.2" ;;
+    * ) JETSON_CUDA_ARCH_BIN="NONE" ;;
+esac
+# Export Jetson CUDA ARCHITECTURE
+export JETSON_CUDA_ARCH_BIN
+
+# Serial number
+# https://devtalk.nvidia.com/default/topic/1055507/jetson-nano/nano-serial-number-/
+JETSON_SERIAL_NUMBER=""
+if [ -f /sys/firmware/devicetree/base/serial-number ]; then
+    JETSON_SERIAL_NUMBER=$(tr -d '\0' </sys/firmware/devicetree/base/serial-number)
+fi
+# Export NVIDIA Serial Number
+export JETSON_SERIAL_NUMBER
+
+# NVIDIA Jetson version
+# reference https://devtalk.nvidia.com/default/topic/860092/jetson-tk1/how-do-i-know-what-version-of-l4t-my-jetson-tk1-is-running-/
+# https://stackoverflow.com/questions/16817646/extract-version-number-from-a-string
+# https://askubuntu.com/questions/319307/reliably-check-if-a-package-is-installed-or-not
+# https://github.com/dusty-nv/jetson-inference/blob/7e81381a96c1ac5f57f1728afbfdec7f1bfeffc2/tools/install-pytorch.sh#L296
+if [ -f /etc/nv_tegra_release ]; then
+    # L4T string
+    # First line on /etc/nv_tegra_release 
+    # - "# R28 (release), REVISION: 2.1, GCID: 11272647, BOARD: t186ref, EABI: aarch64, DATE: Thu May 17 07:29:06 UTC 2018"
+    JETSON_L4T_STRING=$(head -n 1 /etc/nv_tegra_release)
+    # Load release and revision
+    JETSON_L4T_RELEASE=$(echo $JETSON_L4T_STRING | cut -f 2 -d ' ' | grep -Po '(?<=R)[^;]+')
+    JETSON_L4T_REVISION=$(echo $JETSON_L4T_STRING | cut -f 2 -d ',' | grep -Po '(?<=REVISION: )[^;]+')
+elif dpkg --get-selections | grep -q "^nvidia-l4t-core[[:space:]]*install$"; then
+    # Read version
+    JETSON_L4T_STRING=$(dpkg-query --showformat='${Version}' --show nvidia-l4t-core)
+    # extract version
+    JETSON_L4T_ARRAY=$(echo $JETSON_L4T_STRING | cut -f 1 -d '-')
+    # Load release and revision
+    JETSON_L4T_RELEASE=$(echo $JETSON_L4T_ARRAY | cut -f 1 -d '.')
+    JETSON_L4T_REVISION=${JETSON_L4T_ARRAY#"$JETSON_L4T_RELEASE."}
+else
+    # Load release and revision
+    JETSON_L4T_RELEASE="N"
+    JETSON_L4T_REVISION="N.N"
+fi
+# Write Jetson description
+JETSON_L4T="$JETSON_L4T_RELEASE.$JETSON_L4T_REVISION"
+# Export Release L4T
+export JETSON_L4T_RELEASE
+export JETSON_L4T_REVISION
+export JETSON_L4T
+
+JETSON_JETPACK=$(jetson_jetpack $JETSON_L4T)
+# Export Jetson Jetpack installed
+export JETSON_JETPACK
+# EOF

jetsontools-0.0.1/src/jetsontools/_tegrastats.py

@@ -0,0 +1,145 @@
+# Copyright (c) 2024 Justin Davis (davisjustin302@gmail.com)
+#
+# MIT License
+# ruff: noqa: S404, S603
+from __future__ import annotations
+
+import logging
+import multiprocessing as mp
+import subprocess
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from typing_extensions import Self
+
+_log = logging.getLogger(__name__)
+
+
+class Tegrastats:
+    """Runs tegrastats in a seperate process and stores output in a file."""
+
+    def __init__(
+        self: Self,
+        output: Path | str,
+        interval: int = 1000,
+        *,
+        readall: bool | None = None,
+    ) -> None:
+        """
+        Create an instance of tegrastats with outputs to a file.
+
+        Parameters
+        ----------
+        output : Path | str
+            The path to the output file
+        interval : int, optional
+            The interval to run tegrastats in milliseconds, by default 1000
+        readall : bool, optional
+            Optionally, read all possible information through tegrastats.
+            Additional information varies by board.
+            Can consume additional CPU resources.
+            By default, will NOT readall
+
+        """
+        self._output = Path(output)
+        self._interval = interval
+        self._readall = readall
+
+        self._process = mp.Process(
+            target=self._run,
+            args=(self._output, self._interval),
+            daemon=True,
+        )
+
+    def __enter__(self: Self) -> Self:
+        self._process.start()
+        return self
+
+    def __exit__(
+        self: Self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        _log.debug("Stopping tegrastats")
+        self._process.terminate()
+        command = ["tegrastats", "--stop"]
+        subprocess.run(
+            command,
+            check=True,
+        )
+
+    def _run(
+        self: Self,
+        output: Path,
+        interval: int,
+    ) -> None:
+        """
+        Target function for process running tegrastats.
+
+        Parameters
+        ----------
+        output : Path
+            The path to the output file.
+        interval : int
+            The interval to update tegrastats info (ms).
+
+        Raises
+        ------
+        RuntimeError
+            If the process created by Popen does not have stdout/stderr
+        CalledProcessError
+            If the process has any stderr output
+
+        """
+        # maintain the file in open state
+        with output.open("w+") as f:
+            _log.debug(f"Open file {output} for writing")
+
+            # create the command and run the Popen call
+            command = ["tegrastats", "--interval", str(interval)]
+            if self._readall:
+                command.append("--readall")
+            process = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+            )
+
+            _log.debug(f"Ran tegrastats with command: {command}")
+
+            # ensure stdout/stderr streams exist
+            if process.stdout is None or process.stderr is None:
+                err_msg = "Cannot access stdout or stderr streams in Tegrastat process."
+                raise RuntimeError(err_msg)
+
+            _log.debug("No errors from process found")
+
+            # read output while it exists
+            # this will be stopped by the __exit__ call
+            # which will call tegrastats --stop
+            # resulting in the lines to cease
+            while True:
+                line = process.stdout.readline()
+                if not line:
+                    break
+                timestamp = time.time()
+                f.write(f"{timestamp:.6f}:: {line}")
+                f.flush()
+
+            _log.debug("Stopped reading from tegrastats process")
+
+            # check for any errors
+            stderr_output = process.stderr.read()
+            if stderr_output:
+                raise subprocess.CalledProcessError(
+                    process.returncode,
+                    process.args,
+                    stderr=stderr_output,
+                )

jetsontools-0.0.1/src/jetsontools/info/__init__.py

@@ -0,0 +1,23 @@
+# Copyright (c) 2024 Justin Davis (davisjustin302@gmail.com)
+#
+# MIT License
+"""
+Tools for getting information about the Jetson device.
+
+Classes
+-------
+JetsonInfo
+    Class to store information about the Jetson device.
+
+Functions
+---------
+get_info
+    Get information about the Jetson device.
+
+"""
+
+from __future__ import annotations
+
+from ._info import JetsonInfo, get_info
+
+__all__ = ["JetsonInfo", "get_info"]

jetsontools-0.0.1/src/jetsontools/info/__main__.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2024 Justin Davis (davisjustin302@gmail.com)
+#
+# MIT License
+"""Print information about the Jetson device."""
+
+from __future__ import annotations
+
+from ._info import get_info
+
+if __name__ == "__main__":
+    _ = get_info(verbose=True)

jetsontools-0.0.1/src/jetsontools/info/_info.py

@@ -0,0 +1,182 @@
+# Copyright (c) 2024 Justin Davis (davisjustin302@gmail.com)
+#
+# MIT License
+# Adapted from: https://github.com/jetsonhacks/jetsonUtilities/blob/master/jetsonInfo.py
+# ruff: noqa: S404, S603, T201
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from enum import Enum
+from functools import lru_cache
+from pathlib import Path
+
+
+class _Terminalcolors(Enum):
+    """Terminal colors for printing."""
+
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+
+
+@dataclass
+class JetsonInfo:
+    """Class to store information about the Jetson device."""
+
+    model: str
+    l4t: str
+    jetpack: str
+    ubuntu: str | None
+    kernel: str | None
+    cuda: str
+    cuda_arch: str
+    opencv: str
+    opencv_cuda: str
+    cudnn: str
+    tensorrt: str
+    visionworks: str
+    vpi: str
+    vulkan: str
+
+
+@lru_cache(maxsize=None)
+def get_info(*, verbose: bool | None = None) -> JetsonInfo:
+    """
+    Get information about the Jetson device.
+
+    Parameters
+    ----------
+    verbose : bool, optional
+        If True, print additional information, by default None
+
+    Returns
+    -------
+    dict[str, str]
+        The information about the Jetson device.
+
+    Raises
+    ------
+    RuntimeError
+        If the subprocess stdout streams cannot be opened.
+
+    """
+    environment_vars: dict[str, str] = {}
+    output: dict[str, str] = {}
+
+    path0 = Path(__file__).parent.parent / "_scripts" / "jetson_variables.sh"
+    path0 = path0.resolve()
+    command0 = ["bash", "-c", f"source {path0} && env"]
+
+    proc = subprocess.Popen(command0, stdout=subprocess.PIPE)
+    if proc.stdout is None:
+        err_msg = f"Cannot open subprocess: {command0}"
+        raise RuntimeError(err_msg)
+    for c0_line in proc.stdout:
+        (key, _, value) = c0_line.partition(b"=")
+        environment_vars[key.decode()] = value.decode()
+
+    proc.communicate()
+
+    # Jetson Model
+    output["model"] = environment_vars["JETSON_MODEL"].strip()
+    if verbose:
+        print("NVIDIA " + output["model"])
+
+    # L4T Version
+    output["l4t"] = environment_vars["JETSON_L4T"].strip()
+    output["jetpack"] = environment_vars["JETSON_JETPACK"].strip()
+    if verbose:
+        print(
+            " L4T " + output["l4t"] + " [ JetPack " + output["jetpack"] + " ]",
+        )
+    # Ubuntu version
+    output["ubuntu"] = "UNKNOWN"
+    ubuntu_version_path = Path("/etc/os-release")
+    if ubuntu_version_path.exists():
+        with ubuntu_version_path.open("r") as ubuntu_version_file:
+            ubuntu_version_file_text = ubuntu_version_file.read()
+        for uvft_line in ubuntu_version_file_text.splitlines():
+            if "PRETTY_NAME" in uvft_line:
+                # PRETTY_NAME="Ubuntu 16.04 LTS"
+                ubuntu_release = uvft_line.split('"')[1]
+                output["ubuntu"] = ubuntu_release
+                if verbose:
+                    print("   " + ubuntu_release)
+    else:
+        if verbose:
+            print(
+                _Terminalcolors.FAIL.value
+                + "Error: Unable to find Ubuntu Version"
+                + _Terminalcolors.ENDC.value,
+            )
+            print("Reason: Unable to find file /etc/os-release")
+
+    # Kernel Release
+    output["kernel"] = "UNKNOWN"
+    kernel_release_path = Path("/proc/version")
+    if kernel_release_path.exists():
+        with kernel_release_path.open("r") as version_file:
+            version_file_text = version_file.read()
+        kernel_release_array = version_file_text.split(" ")
+        output["kernel"] = kernel_release_array[2]
+        if verbose:
+            print("   Kernel Version: " + kernel_release_array[2])
+    else:
+        if verbose:
+            print(
+                _Terminalcolors.FAIL.value
+                + "Error: Unable to find Linux kernel version"
+                + _Terminalcolors.ENDC.value,
+            )
+            print("Reason: Unable to find file /proc/version")
+
+    path1 = Path(__file__).parent.parent / "_scripts" / "jetson_libraries.sh"
+    path1 = path1.resolve()
+    command1 = ["bash", "-c", f"source {path1} && env"]
+
+    proc1 = subprocess.Popen(command1, stdout=subprocess.PIPE)
+    if proc1.stdout is None:
+        err_msg = f"Cannot open subprocess: {command1}"
+        raise RuntimeError(err_msg)
+    for c1_line in proc1.stdout:
+        (key, _, value) = c1_line.partition(b"=")
+        environment_vars[key.decode()] = value.decode()
+
+    output["cuda"] = environment_vars["JETSON_CUDA"].strip()
+    output["cuda_arch"] = environment_vars["JETSON_CUDA_ARCH_BIN"].strip()
+    output["opencv"] = environment_vars["JETSON_OPENCV"].strip()
+    output["opencv_cuda"] = environment_vars["JETSON_OPENCV_CUDA"].strip()
+    output["cudnn"] = environment_vars["JETSON_CUDNN"].strip()
+    output["tensorrt"] = environment_vars["JETSON_TENSORRT"].strip()
+    output["visionworks"] = environment_vars["JETSON_VISIONWORKS"].strip()
+    output["vpi"] = environment_vars["JETSON_VPI"].strip()
+    output["vulkan"] = environment_vars["JETSON_VULKAN_INFO"].strip()
+
+    if verbose:
+        print(f" CUDA: {output['cuda']}")
+        print(f" \tCUDA Arch: {output['cuda_arch']}")
+        print(f" OpenCV: {output['opencv']}")
+        print(f" \tOpenCV CUDA: {output['opencv_cuda']}")
+        print(f" cuDNN: {output['cudnn']}")
+        print(f" TensorRT: {output['tensorrt']}")
+        print(f" Vision Works: {output['visionworks']}")
+        print(f" VPI: {output['vpi']}")
+        print(f" Vulcan: {output['vulkan']}")
+
+    return JetsonInfo(
+        model=output["model"],
+        l4t=output["l4t"],
+        jetpack=output["jetpack"],
+        ubuntu=output["ubuntu"],
+        kernel=output["kernel"],
+        cuda=output["cuda"],
+        cuda_arch=output["cuda_arch"],
+        opencv=output["opencv"],
+        opencv_cuda=output["opencv_cuda"],
+        cudnn=output["cudnn"],
+        tensorrt=output["tensorrt"],
+        visionworks=output["visionworks"],
+        vpi=output["vpi"],
+        vulkan=output["vulkan"],
+    )

jetsontools-0.0.1/src/jetsontools.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: jetsontools
+Version: 0.0.1
+Summary: Tools for working with NVIDIA Jetson devices.
+Author-email: Justin Davis <davisjustin302@gmail.com>
+Maintainer-email: Justin Davis <davisjustin302@gmail.com>
+Project-URL: Homepage, https://github.com/justincdavis/jetsontools
+Project-URL: Bug Tracker, https://github.com/justincdavis/jetsontools/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Typing :: Typed
+Requires-Python: <=3.13,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions>=4.0.0
+Provides-Extra: ci
+Requires-Dist: pyupgrade>=3.10; extra == "ci"
+Requires-Dist: ruff>=0.4.5; extra == "ci"
+Requires-Dist: mypy>=1.10.0; extra == "ci"
+Requires-Dist: types-setuptools>=57.0.0; extra == "ci"
+Requires-Dist: types-tqdm>=4.66.0; extra == "ci"
+Provides-Extra: test
+Requires-Dist: pytest>=6.2.0; extra == "test"
+Requires-Dist: hypothesis[numpy]>=6.98.0; extra == "test"
+Requires-Dist: pybboxes>=0.1.6; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6.1.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.3.0; extra == "docs"
+Requires-Dist: myst_parser>=1.0.0; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: jetsontools[jit]; extra == "dev"
+Requires-Dist: jetsontools[ci]; extra == "dev"
+Requires-Dist: jetsontools[test]; extra == "dev"
+Requires-Dist: jetsontools[docs]; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: wheel>=0.37.0; extra == "dev"
+Requires-Dist: bumpver>=2023.1126; extra == "dev"
+Requires-Dist: pyclean>=2.7.0; extra == "dev"
+Requires-Dist: pyright>=1.1.348; extra == "dev"
+Requires-Dist: seaborn>=0.13.0; extra == "dev"
+
+# jetsontools
+Tools for working with NVIDIA Jetson devices.

jetsontools-0.0.1/src/jetsontools.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/jetsontools/__init__.py
+src/jetsontools/_tegrastats.py
+src/jetsontools/py.typed
+src/jetsontools.egg-info/PKG-INFO
+src/jetsontools.egg-info/SOURCES.txt
+src/jetsontools.egg-info/dependency_links.txt
+src/jetsontools.egg-info/requires.txt
+src/jetsontools.egg-info/top_level.txt
+src/jetsontools/_scripts/jetson_libraries.sh
+src/jetsontools/_scripts/jetson_variables.sh
+src/jetsontools/info/__init__.py
+src/jetsontools/info/__main__.py
+src/jetsontools/info/_info.py

jetsontools-0.0.1/src/jetsontools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jetsontools-0.0.1/src/jetsontools.egg-info/requires.txt

@@ -0,0 +1,30 @@
+typing_extensions>=4.0.0
+
+[ci]
+pyupgrade>=3.10
+ruff>=0.4.5
+mypy>=1.10.0
+types-setuptools>=57.0.0
+types-tqdm>=4.66.0
+
+[dev]
+jetsontools[jit]
+jetsontools[ci]
+jetsontools[test]
+jetsontools[docs]
+twine>=4.0.0
+wheel>=0.37.0
+bumpver>=2023.1126
+pyclean>=2.7.0
+pyright>=1.1.348
+seaborn>=0.13.0
+
+[docs]
+sphinx>=6.1.0
+sphinx-rtd-theme>=1.3.0
+myst_parser>=1.0.0
+
+[test]
+pytest>=6.2.0
+hypothesis[numpy]>=6.98.0
+pybboxes>=0.1.6

jetsontools-0.0.1/src/jetsontools.egg-info/top_level.txt

@@ -0,0 +1 @@
+jetsontools