def attach(self, port=None, fqbn=None, sketch_path=None, discovery_timeout=None, protocol=None):
"""
Calls the :code:`board attach` command.
:param port: Upload port address, e.g.: COM3 or /dev/ttyACM2
:type port: str or NoneTYpe
:param fqbn: Fully Qualified Board Name, e.g.: arduino:avr:uno
:type fqbn: str or NoneTYpe
:param sketch_path: The path of the sketch to attach to the board
:type sketch_path: str or NoneTYpe
:param discovery_timeout: Max time to wait for port discovery, e.g.: 30s, 1m (default 5s)
:type discovery_timeout: str or NoneTYpe
:param protocol: Upload port protocol, e.g: serial
:type protocol: str or NoneTYpe
:return: The output of the related command
:rtype: dict
"""
args = [commands.ATTACH]
if port:
args.extend([flags.PORT, CommandBase._strip_arg(port)])
if protocol:
args.extend([flags.PROTOCOL, CommandBase._strip_arg(protocol)])
if fqbn:
args.extend([flags.FQBN, CommandBase._strip_arg(fqbn)])
if sketch_path:
args.append(CommandBase._strip_arg(sketch_path))
if discovery_timeout:
args.extend([flags.DISCOVERY_TIMEOUT, CommandBase._strip_arg(discovery_timeout)])
return self._exec(args)
def __call__(self,
daemonize=None,
port=None,
debug=None,
debug_filter=None,
ip=None):
"""
Calls the :code:`daemon` command
:param daemonize: Do not terminate daemon process if the parent process dies
:type daemonize: bool or NoneType
:param port: The TCP port the daemon will listen to
:type port: str, integer or NoneType
:param debug: Enable debug logging of gRPC calls
:type debug: bool or NoneType
:param debug_filter: Display only the provided gRPC calls
:type debug_filter: str or NoneType
:param ip: The IP address the daemon will listen to (default "127.0.0.1")
:type ip: str or NoneType
:return: The output of the related command
:rtype: dict
"""
args = []
if daemonize is True:
args.append(flags.DAEMONIZE)
if port:
args.extend([flags.PORT, CommandBase._strip_arg(str(port))])
if debug is True:
args.append(flags.DEBUG)
if debug_filter:
args.extend(
[flags.DEBUG_FILTER,
CommandBase._strip_arg(debug_filter)])
return self._exec(args)
def __call__(self,
fqbn=None,
input_dir=None,
port=None,
interpreter=None,
info=None,
programmer=None,
sketch=None,
discovery_timeout=None,
protocol=None):
"""
Calls the :code:`debug` command
:param fqbn: Fully Qualified Board Name, e.g.: arduino:avr:uno
:type fqbn: str or NoneType
:param input_dir: Directory containing binaries for debug.
:type input_dir: str or NoneType
:param port: Debug port, e.g.: COM10 or /dev/ttyACM0
:type port: str or NoneType
:param interpreter: Debug interpreter e.g.: console, mi, mi1, mi2, mi3 (default "console")
:type interpreter: str or NoneType
:param info: Show metadata about the debug session instead of starting the debugger.
:type info: str or NoneType
:param programmer: Programmer to use for debugging
:type programmer: str or NoneType
:param sketch: The sketch to debug
:type sketch: str or NoneType
:param discovery_timeout: Max time to wait for port discovery, e.g.: 30s, 1m (default 5s)
:type discovery_timeout: str or NoneType
:param protocol: Upload port protocol, e.g: serial
:type protocol: str or NoneType
:return: The output of the related command
:rtype: dict
"""
args = []
if fqbn:
args.extend([flags.FQBN, CommandBase._strip_arg(fqbn)])
if input_dir:
args.extend([flags.INPUT_DIR, CommandBase._strip_arg(input_dir)])
if port:
args.extend([flags.PORT, CommandBase._strip_arg(port)])
if interpreter:
args.extend(
[flags.INTERPRETER,
CommandBase._strip_arg(interpreter)])
if info is True:
args.append(flags.INFO)
if programmer:
args.extend([flags.PROGRAMMER, CommandBase._strip_arg(programmer)])
if sketch:
args.append(CommandBase._strip_arg(sketch))
if discovery_timeout:
args.extend([
flags.DISCOVERY_TIMEOUT,
CommandBase._strip_arg(discovery_timeout)
])
if protocol:
args.extend([flags.PROTOCOL, CommandBase._strip_arg(protocol)])
return self._exec(args)
def examples(self, library, fqbn=None):
"""
Calls the :code:`lib examples` command
:param library: The name of the library
:type library: str
:param fqbn: The board FQBN
:type fqbn: str or NoneType
:return: The output of the related command
:rtype: dict
"""
args = [commands.EXAMPLES, CommandBase._strip_arg(library)]
if fqbn is not None:
args.extend([flags.FQBN, CommandBase._strip_arg(fqbn)])
return self._exec(args)
def __call__(self,
config=None,
describe=None,
discovery_timeout=None,
fqbn=None,
port=None,
protocol=None,
quiet=None):
"""
Calls the :code:`monitor` command
:param config: Configuration of the port.
:type config: str or NoneType
:param describe: Show all the settings of the communication port.
:type describe: bool or NoneType
:param discovery_timeout: Max time to wait for port discovery, e.g.: 30s, 1m (default 5s)
:type discovery_timeout: str or NoneType
:param fqbn: Fully Qualified Board Name, e.g.: arduino:avr:uno
:type fqbn: str or NoneType
:param port: Upload port address, e.g.: COM3 or /dev/ttyACM2
:type port: str or NoneType
:param protocol: Upload port protocol, e.g: serial
:type protocol: str or NoneType
:param quiet: Run in silent mode, show only monitor input and output.
:type quiet: bool or NoneType
:return: The output of the related command
:rtype: dict
"""
args = []
if config:
args.extend([flags.CONFIG, CommandBase._strip_arg(config)])
if describe is True:
args.append(flags.DESCRIBE)
if discovery_timeout:
args.extend([
flags.DISCOVERY_TIMEOUT,
CommandBase._strip_args(discovery_timeout)
])
if fqbn:
args.extend([flags.FQBN, CommandBase._strip_arg(fqbn)])
if port:
args.extend([flags.PORT, CommandBase._strip_arg(port)])
if protocol:
args.extend([flags.PROTOCOL, CommandBase._strip_arg(protocol)])
if quiet is True:
args.append(flags.QUIET)
return self._exec(args)
def deps(self, library):
"""
Calls the :code:`lib deps` command
:param library: The name of the library for dependency checking
:type library: str
:return: The output of the related command
:rtype: dict
"""
return self._exec([commands.DEPS, CommandBase._strip_arg(library)])
def new(self, name):
"""
Calls the :code:`sketch new` command
:param name: The name of the sketch to create
:type name: str
:return: The output of the related command
:rtype: dict
"""
return self._exec([commands.NEW, CommandBase._strip_arg(name)])
def __call__(self,
discovery_timeout=None,
fqbn=None,
port=None,
programmer=None,
protocol=None,
verify=None):
"""
Calls the :code:`burn-bootloader` command
:param fqbn: The fqbn of the board to burn
:type fqbn: str or NoneType
:param port: The port to use to burl the bootloader
:type port: str or NoneTYpe
:param programmer: The programmer to use for the burning process
:type programmer: str or NoneTYpe
:param verify: Verifies that the bootloader was successfully burnt
:type verify: bool or NoneTYpe
:param discovery_timeout: Max time to wait for port discovery, e.g.: 30s, 1m (default 5s)
:type discovery_timeout: str or NoneType
:param protocol: Upload port protocol, e.g: serial
:type protocol: str or NoneType
:return: The output of the related command
:rtype: dict
"""
args = []
if discovery_timeout:
args.extend([
flags.DISCOVERY_TIMEOUT,
CommandBase._strip_arg(discovery_timeout)
])
if fqbn:
args.extend([flags.FQBN, CommandBase._strip_arg(fqbn)])
if port:
args.extend([flags.PORT, CommandBase._strip_arg(port)])
if programmer:
args.extend([flags.PROGRAMMER, CommandBase._strip_arg(programmer)])
if protocol:
args.extend([flags.PROTOCOL, CommandBase._strip_arg(protocol)])
if verify is True:
args.append(flags.VERIFY)
return self._exec(args)
def init(self, dest_dir=None, dest_file=None, overwrite=None):
"""
Calls the :code:`config init` command
:param dest_dir: The directory where to save the file
:type dest_dir: str or NoneType
:param dest_file: A path where the file will be saved
:type dest_file: str or NoneType
:param overwrite: Overwrites an existing file
:type overwrite: bool or NoneType
:return: The output of the related command
:rtype: dict
"""
args = [commands.INIT]
if dest_dir:
args.extend([flags.DEST_DIR, CommandBase._strip_arg(dest_dir)])
if dest_file:
args.extend([flags.DEST_FILE, CommandBase._strip_arg(dest_file)])
if overwrite is True:
args.append(flags.OVERWRITE)
return self._exec(args)
def delete(self, setting_name):
"""
Calls the :code:`config delete` command
:param setting_name: The name of the setting to delete
:type setting_name: str
:return: The output of the related command
:rtype: dict
"""
return self._exec(
[commands.DELETE,
CommandBase._strip_arg(setting_name)])
def archive(self,
sketch_path=".",
archive_path=None,
include_build_dir=None):
"""
Calls the :code:`sketch archive` command
:param sketch_path: The path to the sketch to archive
:type sketch_path: str
:param archive_path: The path of the output archive
:type archive_path: str or NoneType
:param include_build_dir: Includes the build directory in the archive
:type include_build_dir: bool or NoneType
:return: The output of the related command
:rtype: dict
"""
args = [commands.ARCHIVE, CommandBase._strip_arg(sketch_path)]
if archive_path is not None:
args.append(CommandBase._strip_arg(archive_path))
if include_build_dir is True:
args.append(flags.INCLUDE_BUILD_DIR)
return self._exec(args)
def set(self, setting_name, values):
"""
Calls the :code:`config set` command
:param setting_name: The name of the setting to set
:type setting_name: str
:param values: The list of values to set
:type values: list
:return: The output of the related command
:rtype: dict
"""
args = [commands.SET, CommandBase._strip_arg(setting_name)]
args.extend(CommandBase._strip_args(values))
return self._exec(args)
def remove(self, setting_name, values):
"""
Calls the :code:`config remove` command
:param setting_name: The name of the setting from which values will be removed
:type setting_name: str
:param values: The list of values to remove
:type values: list
:return: The output of the related command
:rtype: dict
"""
args = [commands.REMOVE, CommandBase._strip_arg(setting_name)]
args.extend(CommandBase._strip_args(values))
return self._exec(args)
def __call__(self, shell, no_description=None):
"""
Calls the :code:`completion` command
:param shell: The shell name that will use completition
:type shell: str
:param no_description: Disable completion description for shells that support it
:type no_description: bool or NoneTYpe
:return: The output of the related command
:rtype: dict
"""
args = []
if no_description is True:
args.append(flags.NO_DESCRIPTION)
args.append(CommandBase._strip_arg(shell))
return self._exec(args)
def listall(self, boardname=None, show_hidden=None):
"""
Calls the :code:`board listall` command.
:param boardname: The name of the board, all board will be returned if left unset (or None)
:type boardname: str or NoneType
:param show_hidden: Show also boards marked as 'hidden' in the platform
:type show_hidden: bool or NoneTYpe
:return: The output of the related command
:rtype: dict
"""
args = [commands.LISTALL]
if boardname:
args.append(CommandBase._strip_arg(boardname))
if show_hidden is True:
args.append(flags.SHOW_HIDDEN)
return self._exec(args)
def list(self, discovery_timeout=None, watch=None):
"""
Calls the :code:`board list` command.
:param discovery_timeout: Max time to wait for port discovery, e.g.: 30s, 1m (default 1s)
:type discovery_timeout: str or NoneType
:param watch: Command keeps running and prints list of connected boards whenever there is a change. Added to pyduinocli for completion but won't actually return, use a loop instead
:type watch: bool or NoneTYpe
:return: The output of the related command
:rtype: dict
"""
args = [commands.LIST]
if discovery_timeout:
args.extend([flags.DISCOVERY_TIMEOUT, CommandBase._strip_arg(discovery_timeout)])
if watch is True:
args.append(flags.WATCH)
return self._exec(args)
def search(self, boardname=None, show_hidden=None):
"""
Calls the :code:`board search` command.
:param boardname: The name of the board
:type boardname: str or NoneType
:param show_hidden: Show also boards marked as 'hidden' in the platform
:type show_hidden: bool or NoneTYpe
:return: The output of the related command
:rtype: dict
"""
args = [commands.SEARCH]
if boardname:
args.append(CommandBase._strip_arg(boardname))
if show_hidden is True:
args.append(flags.SHOW_HIDDEN)
return self._exec(args)
def details(self, fqbn, full=None, list_programmers=None):
"""
Calls the :code:`board details` command.
:param fqbn: The fqbn of the board
:type fqbn: str
:param full: Show full board details
:type full: bool or NoneTYpe
:param list_programmers: Show list of available programmers
:type list_programmers: bool or NoneTYpe
:return: The output of the related command
:rtype: dict
"""
args = [commands.DETAILS, flags.FQBN, CommandBase._strip_arg(fqbn)]
if full is True:
args.append(flags.FULL)
if list_programmers is True:
args.append(flags.LIST_PROGRAMMERS)
return self._exec(args)
def list(self, all=None, updatable=None, fqbn=None):
"""
Calls the :code:`lib list` command
:param all: Includes built-in libraries
:type all: bool or NoneType
:param updatable: Only shows libraries that are not up to date
:type updatable: bool or NoneType
:param fqbn: Shows libraries for the specified board
:type fqbn: str or NoneType
:return: The output of the related command
:rtype: dict
"""
args = [commands.LIST]
if all is True:
args.append(flags.ALL)
if updatable is True:
args.append(flags.UPDATABLE)
if fqbn is not None:
args.extend([flags.FQBN, CommandBase._strip_arg(fqbn)])
return self._exec(args)
def __init__(self,
cli_path="arduino-cli",
config_file=None,
additional_urls=None,
log_file=None,
log_format=None,
log_level=None,
no_color=None):
"""
:param cli_path: The :code:`arduino-cli` command name if available in :code:`$PATH`. Can also be a direct path to the executable
:type cli_path: str
:param config_file: The path to the :code:`arduino-cli` configuration file to be used
:type config_file: str or NoneType
:param additional_urls: A list of URLs to custom board definitions files
:type additional_urls: list or NoneType
:param log_file: A path to a file where logs will be stored
:type log_file: str or NoneType
:param log_format: The format the logs will use
:type log_format: str or NoneType
:param log_level: The log level for the log file
:type log_level: str or NoneType
:param no_color: Disable colored output
:type no_color: bool or NoneType
"""
base_args = [cli_path, flags.FORMAT, ArduinoCliCommand.__FORMAT_JSON]
if config_file:
base_args.extend(
[flags.CONFIG_FILE,
CommandBase._strip_arg(config_file)])
if additional_urls:
base_args.extend([
flags.ADDITIONAL_URLS,
",".join(CommandBase._strip_args(additional_urls))
])
if log_file:
base_args.extend(
[flags.LOG_FILE,
CommandBase._strip_arg(log_file)])
if log_format:
base_args.extend(
[flags.LOG_FORMAT,
CommandBase._strip_arg(log_format)])
if log_level:
base_args.extend(
[flags.LOG_LEVEL,
CommandBase._strip_arg(log_level)])
if no_color is True:
base_args.append(flags.NO_COLOR)
CommandBase.__init__(self, base_args)
self.__board = BoardCommand(self._base_args)
self.__cache = CacheCommand(self._base_args)
self.__compile = CompileCommand(self._base_args)
self.__config = ConfigCommand(self._base_args)
self.__core = CoreCommand(self._base_args)
self.__daemon = DaemonCommand(self._base_args)
self.__debug = DebugCommand(self._base_args)
self.__lib = LibCommand(self._base_args)
self.__sketch = SketchCommand(self._base_args)
self.__upload = UploadCommand(self._base_args)
self.__version = VersionCommand(self._base_args)
self.__burn_bootloader = BurnBootloaderCommand(self._base_args)
self.__completion = CompletionCommand(self._base_args)
self.__outdated = OutdatedCommand(self._base_args)
self.__update = UpdateCommand(self._base_args)
self.__upgrade = UpgradeCommand(self._base_args)
self.__monitor = MonitorCommand(self._base_args)
def __call__(self,
sketch,
build_cache_path=None,
build_path=None,
build_properties=None,
fqbn=None,
output_dir=None,
port=None,
preprocess=None,
show_properties=None,
upload=None,
verify=None,
vid_pid=None,
warnings=None,
libraries=None,
library=None,
optimize_for_debug=None,
export_binaries=None,
programmer=None,
clean=None,
only_compilation_database=None,
discovery_timeout=None,
protocol=None):
"""
Calls the :code:`compile` command
:param sketch: The sketch to compile, can also be a path to a sketch
:type sketch: str
:param build_cache_path: Builds of 'core.a' are saved into this path to be cached and reused.
:type build_cache_path: str or NoneType
:param build_path: Path where to save compiled files. If omitted, a directory will be created in the default temporary path of your OS.
:type build_path: str or NoneType
:param build_properties: Override build properties with custom values.
:type build_properties: list or NoneType
:param fqbn: Fully Qualified Board Name, e.g.: arduino:avr:uno
:type fqbn: str or NoneType
:param output_dir: Save build artifacts in this directory.
:type output_dir: str or NoneType
:param port: Upload port, e.g.: COM10 or /dev/ttyACM0
:type port: str or NoneType
:param preprocess: Print preprocessed code to stdout instead of compiling.
:type preprocess: bool or NoneType
:param show_properties: Show all build properties used instead of compiling.
:type show_properties: bool or NoneType
:param upload: Upload the binary after the compilation.
:type upload: bool or NoneType
:param verify: Verify uploaded binary after the upload.
:type verify: bool or NoneType
:param vid_pid: When specified, VID/PID specific build properties are used, if board supports them.
:type vid_pid: str or NoneType
:param warnings: Optional, can be "none", "default", "more" and "all". Defaults to "none". Used to tell gcc which warning level to use (-W flag). (default "none")
:type warnings: str or NoneType
:param libraries: List of custom libraries dir paths separated by commas. Or can be used multiple times for multiple libraries dir paths.
:type libraries: list or NoneType
:param library: List of paths to libraries root folders. Libraries set this way have top priority in case of conflicts. Can be used multiple times for different libraries.
:type library: list or NoneType
:param optimize_for_debug: Optional, optimize compile output for debugging, rather than for release.
:type optimize_for_debug: bool or NoneType
:param export_binaries: If set built binaries will be exported to the sketch folder.
:type export_binaries: bool or NoneType
:param programmer: Optional, use the specified programmer to upload.
:type programmer: str or NoneType
:param clean: Optional, cleanup the build folder and do not use any cached build.
:type clean: bool or NoneType
:param only_compilation_database: Just produce the compilation database, without actually compiling.
:type only_compilation_database: bool or NoneType
:param discovery_timeout: Max time to wait for port discovery, e.g.: 30s, 1m (default 5s)
:type discovery_timeout: str or NoneType
:param protocol: Upload port protocol, e.g: serial
:type protocol: str or NoneType
:return: The output of the related command
:rtype: dict
"""
args = []
if build_cache_path:
args.extend([
flags.BUILD_CACHE_PATH,
CommandBase._strip_arg(build_cache_path)
])
if build_path:
args.extend([flags.BUILD_PATH, CommandBase._strip_arg(build_path)])
if build_properties:
for build_property in build_properties:
args.extend([
flags.BUILD_PROPERTY,
CommandBase._strip_arg(build_property)
])
if fqbn:
args.extend([flags.FQBN, CommandBase._strip_arg(fqbn)])
if output_dir:
args.extend([flags.OUTPUT_DIR, CommandBase._strip_arg(output_dir)])
if port:
args.extend([flags.PORT, CommandBase._strip_arg(port)])
if preprocess is True:
args.append(flags.PREPROCESS)
if show_properties is True:
args.append(flags.SHOW_PROPERTIES)
if upload is True:
args.append(flags.UPLOAD)
if verify is True:
args.append(flags.VERIFY)
if vid_pid:
args.extend([flags.VID_PID, CommandBase._strip_arg(vid_pid)])
if warnings:
args.extend([flags.WARNINGS, CommandBase._strip_arg(warnings)])
if libraries:
for l in libraries:
args.extend([flags.LIBRARIES, CommandBase._strip_arg(l)])
if library:
for l in library:
args.extend([flags.LIBRARY, CommandBase._strip_arg(l)])
if optimize_for_debug is True:
args.append(flags.OPTIMIZE_FOR_DEBUG)
if export_binaries is True:
args.append(flags.EXPORT_BINARIES)
if programmer:
args.extend([flags.PROGRAMMER, CommandBase._strip_arg(programmer)])
if clean is True:
args.append(flags.CLEAN)
if only_compilation_database is True:
args.append(flags.ONLY_COMPILATION_DATABASE)
if discovery_timeout:
args.extend([
flags.DISCOVERY_TIMEOUT,
CommandBase._strip_arg(discovery_timeout)
])
if protocol:
args.extend([flags.PROTOCOL, CommandBase._strip_arg(protocol)])
args.append(CommandBase._strip_arg(sketch))
return self._exec(args)
