Skip to content
Micropython Project Management Tool for VSCode with Linting, Intellisense, Dependency Management, and more!
Python Makefile
Branch: master
Clone or download
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.github/img docs: Update README with Project Deps Info Jul 26, 2019
docs Bump version: 2.0.2 → 2.1.0 Sep 1, 2019
micropy Bump version: 2.0.2 → 2.1.0 Sep 1, 2019
tests test: Update Project Structure Test Sep 1, 2019
.editorconfig
.gitignore
.gitmodules feat(lib): Update Stubber to Process Branch Jul 25, 2019
.prettierignore
.python-version
.travis.yml ci: Updated Tox and Travis Config Jun 9, 2019
CHANGELOG.md Bump version: 2.0.2 → 2.1.0 Sep 1, 2019
LICENSE feat: Relicensed under MIT Sep 2, 2019
MANIFEST.in
Makefile docs: Add Docs Automation Sep 1, 2019
Pipfile
README.md docs(readme): Add Link to LemaRiva Post Aug 31, 2019
setup.cfg Bump version: 2.0.2 → 2.1.0 Sep 1, 2019
setup.py Bump version: 2.0.2 → 2.1.0 Sep 1, 2019
tox.ini build(cov): Integrate Coveralls Jun 26, 2019

README.md

Micropy Cli PyPI PyPI - Python Version Travis (.com) Coverage Status

Micropy Cli is a project management/generation tool for writing Micropython code in modern IDEs such as VSCode. Its primary goal is to automate the process of creating a workspace complete with:

  • Linting compatible with Micropython
  • VSCode Intellisense
  • Autocompletion
  • Dependency Management
  • VCS Compatibility

Micropy Demo SVG

Installation

You can download and install the latest version of this software from the Python package index (PyPI) as follows:

pip install --upgrade micropy-cli

Usage

Usage: micropy [OPTIONS] COMMAND [ARGS]...

  CLI Application for creating/managing Micropython Projects.

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  init     Create new Micropython Project
  install  Install Project Requirements
  stubs    Manage Micropy Stubs

Creating a Project

Creating a new project folder is as simple as:

  1. Executing micropy init <PROJECT NAME>
  2. Selecting which templates to use
  3. Selecting your target device/firmware
  4. Boom. Your workspace is ready.

Micropy Demo

Micropy Project Environment

When creating a project with micropy-cli, two special items are added:

  • A .micropy/ folder
  • A micropy.json file

The .micropy/ contains symlinks from your project to your $HOME/.micropy/stubs folder. By doing this, micropy can reference the required stub files for your project as relative to it, rather than using absolute paths to $HOME/.micropy. How does this benefit you? Thanks to this feature, you can feel free to push common setting files such as settings.json and .pylint.rc to your remote git repository. This way, others who clone your repo can achieve a matching workspace in their local environment.

Note: The generated .micropy/ folder should be IGNORED by your VCS. It is created locally for each environment via the micropy.json file.

The micropy.json file contains information micropy needs in order to resolve your projects required files when other clone your repo. Think of it as a package.json for micropython.

Cloning a Micropy Environment

To setup a Micropy environment locally, simply:

  • Install micropy-cli
  • Navigate to the project directory
  • Execute micropy

Micropy will automatically configure and install any stubs required by a project thanks to its micropy.json file.

Project Dependencies

While all modules that are included in your targeted micropython firmware are available with autocompletion, intellisense, and linting, most projects require external dependencies.

Currently, handling dependencies with micropython is a bit tricky. Maybe you can install a cpython version of your requirement? Maybe you could just copy and paste it? What if it needs to be frozen?

Micropy handles all these issues for you automatically. Not only does it track your project's dependencies, it keeps both requirements.txt and dev-requirements.txt updated, enables autocompletion/intellisense for each dep, and allows you to import them just as you would on your device.

This allows you to include your requirement however you want, whether that be as a frozen module in your custom built firmware, or simply in the /lib folder on your device.

Installing Packages

To add a package as a requirement for your project, run:

micropy install <PACKAGE_NAMES>

while in your project's root directory.

This will automatically execute the following:

  • Source PACKAGE_NAMES from pypi, as a url, or a local path
  • Retrieve the module/package and stub it, adding it to your local .micropy folder.
  • Add requirement to your micropy.json
  • Update requirements.txt

To install dev packages that are not needed on your device, but are needed for local development, add the --dev flag. This will do everything above except stub the requirement.

You can also install all requirements found in micropy.json/requirements.txt/dev-requirements.txt by executing micropy install without passing any packages. Micropy will automatically do this when setting up a local environment of an existing micropy project.

Example

Lets say your new project will depend on picoweb and blynklib. Plus, you'd like to use rshell to communicate directly with your device. After creating your project via micropy init, you can install your requirements as so:

Micropy Pkg Install Demo

Now you or anybody cloning your project can import those requirements normally, and have the benefits of all the features micropy brings:

Micropy Deps Demo

Stub Management

Stub files are the magic behind how micropy allows features such as linting, Intellisense, and autocompletion to work. To achieve the best results with MicropyCli, its important that you first add the appropriate stubs for the device/firmware your project uses.

Note: When working in a micropy project, all stub related commands will also be executed on the active project. (i.e if in a project and you run micropy stubs add <stub-name>, then that stub retrieved AND added to the active project.)

Adding Stubs

Adding stubs to Micropy is a breeze. Simply run: micropy stubs add <STUB_NAME> By sourcing micropy-stubs, MicroPy has several premade stub packages to choose from.

These packages generally use the following naming schema:

<device>-<firmware>-<version>

For example, running micropy stubs add esp32-micropython-1.11.0 will install the following:

  • Micropython Specific Stubs
  • ESP32 Micropython v1.11 Device Specific Stubs
  • Frozen Modules for both device and firmware

You can search stubs that are made available to Micropy via micropy stubs search <QUERY>

Alternatively, using micropy stubs add <PATH>, you can manually add stubs to Micropy. For manual stub generation, please see Josvel/micropython-stubber.

Creating Stubs

Using micropy stubs create <PORT/IP_ADDRESS>, MicropyCli can automatically generate and add stubs from any Micropython device you have on hand. This can be done over both USB and WiFi.

Note: For stub creation, micropy-cli has additional dependencies.

These can be installed by executing: pip install micropy-cli[create_stubs]

Viewing Stubs

To list stubs you have installed, simply run micropy stubs list.

To search for stubs for your device, use micropy stubs search <QUERY>.

See Also

Acknowledgements

Micropython-Stubber

Josvel/micropython-stubber

Josverl's Repo is full of information regarding Micropython compatibility with VSCode and more. To find out more about how this process works, take a look at it.

micropy-cli and micropy-stubs depend on micropython-stubber for its ability to generate frozen modules, create stubs on a pyboard, and more.

You can’t perform that action at this time.