Supervisely
About SuperviselyEcosystemContact usSlack
  • 💻Supervisely Developer Portal
  • 🎉Getting Started
    • Installation
    • Basics of authentication
    • Intro to Python SDK
    • Environment variables
    • Supervisely annotation format
      • Project Structure
      • Project Meta: Classes, Tags, Settings
      • Objects
      • Tags
      • Image Annotation
      • Video Annotation
      • Point Clouds Annotation
      • Point Cloud Episode Annotation
      • Volumes Annotation
    • Python SDK tutorials
      • Images
        • Images
        • Image and object tags
        • Spatial labels on images
        • Keypoints (skeletons)
        • Multispectral images
        • Multiview images
        • Advanced: Optimized Import
        • Advanced: Export
      • Videos
        • Videos
        • Video and object tags
        • Spatial labels on videos
      • Point Clouds
        • Point Clouds (LiDAR)
        • Point Cloud Episodes and object tags
        • 3D point cloud object segmentation based on sensor fusion and 2D mask guidance
        • 3D segmentation masks projection on 2D photo context image
      • Volumes
        • Volumes (DICOM)
        • Spatial labels on volumes
      • Common
        • Iterate over a project
        • Iterate over a local project
        • Progress Bar tqdm
        • Cloning projects for development
    • Command Line Interface (CLI)
      • Enterprise CLI Tool
        • Instance administration
        • Workflow automation
      • Supervisely SDK CLI
    • Connect your computer
      • Linux
      • Windows WSL
      • Troubleshooting
  • 🔥App development
    • Basics
      • Create app from any py-script
      • Configuration file
        • config.json
        • Example 1. Headless
        • Example 2. App with GUI
        • v1 - Legacy
          • Example 1. v1 Modal Window
          • Example 2. v1 app with GUI
      • Add private app
      • Add public app
      • App Compatibility
    • Apps with GUI
      • Hello World!
      • App in the Image Labeling Tool
      • App in the Video Labeling Tool
      • In-browser app in the Labeling Tool
    • Custom import app
      • Overview
      • From template - simple
      • From scratch - simple
      • From scratch GUI - advanced
      • Finding directories with specific markers
    • Custom export app
      • Overview
      • From template - simple
      • From scratch - advanced
    • Neural Network integration
      • Overview
      • Serving App
        • Introduction
        • Instance segmentation
        • Object detection
        • Semantic segmentation
        • Pose estimation
        • Point tracking
        • Object tracking
        • Mask tracking
        • Image matting
        • How to customize model inference
        • Example: Custom model inference with probability maps
      • Serving App with GUI
        • Introduction
        • How to use default GUI template
        • Default GUI template customization
        • How to create custom user interface
      • Inference API
      • Training App
        • Overview
        • Tensorboard template
        • Object detection
      • High level scheme
      • Custom inference pipeline
      • Train and predict automation model pipeline
    • Advanced
      • Advanced debugging
      • How to make your own widget
      • Tutorial - App Engine v1
        • Chapter 1 Headless
          • Part 1 — Hello world! [From your Python script to Supervisely APP]
          • Part 2 — Errors handling [Catching all bugs]
          • Part 3 — Site Packages [Customize your app]
          • Part 4 — SDK Preview [Lemons counter app]
          • Part 5 — Integrate custom tracker into Videos Annotator tool [OpenCV Tracker]
        • Chapter 2 Modal Window
          • Part 1 — Modal window [What is it?]
          • Part 2 — States and Widgets [Customize modal window]
        • Chapter 3 UI
          • Part 1 — While True Script [It's all what you need]
          • Part 2 — UI Rendering [Simplest UI Application]
          • Part 3 — APP Handlers [Handle Events and Errors]
          • Part 4 — State and Data [Mutable Fields]
          • Part 5 — Styling your app [Customizing the UI]
        • Chapter 4 Additionals
          • Part 1 — Remote Developing with PyCharm [Docker SSH Server]
      • Custom Configuration
        • Fixing SSL Certificate Errors in Supervisely
        • Fixing 400 HTTP errors when using HTTP instead of HTTPS
      • Autostart
      • Coordinate System
      • MLOps Workflow integration
    • Widgets
      • Input
        • Input
        • InputNumber
        • InputTag
        • BindedInputNumber
        • DatePicker
        • DateTimePicker
        • ColorPicker
        • TimePicker
        • ClassesMapping
        • ClassesColorMapping
      • Controls
        • Button
        • Checkbox
        • RadioGroup
        • Switch
        • Slider
        • TrainValSplits
        • FileStorageUpload
        • Timeline
        • Pagination
      • Text Elements
        • Text
        • TextArea
        • Editor
        • Copy to Clipboard
        • Markdown
        • Tooltip
        • ElementTag
        • ElementTagsList
      • Media
        • Image
        • LabeledImage
        • GridGallery
        • Video
        • VideoPlayer
        • ImagePairSequence
        • Icons
        • ObjectClassView
        • ObjectClassesList
        • ImageSlider
        • Carousel
        • TagMetaView
        • TagMetasList
        • ImageAnnotationPreview
        • ClassesMappingPreview
        • ClassesListPreview
        • TagsListPreview
        • MembersListPreview
      • Selection
        • Select
        • SelectTeam
        • SelectWorkspace
        • SelectProject
        • SelectDataset
        • SelectItem
        • SelectTagMeta
        • SelectAppSession
        • SelectString
        • Transfer
        • DestinationProject
        • TeamFilesSelector
        • FileViewer
        • Dropdown
        • Cascader
        • ClassesListSelector
        • TagsListSelector
        • MembersListSelector
        • TreeSelect
        • SelectCudaDevice
      • Thumbnails
        • ProjectThumbnail
        • DatasetThumbnail
        • VideoThumbnail
        • FolderThumbnail
        • FileThumbnail
      • Status Elements
        • Progress
        • NotificationBox
        • DoneLabel
        • DialogMessage
        • TaskLogs
        • Badge
        • ModelInfo
        • Rate
        • CircleProgress
      • Layouts and Containers
        • Card
        • Container
        • Empty
        • Field
        • Flexbox
        • Grid
        • Menu
        • OneOf
        • Sidebar
        • Stepper
        • RadioTabs
        • Tabs
        • TabsDynamic
        • ReloadableArea
        • Collapse
        • Dialog
        • IFrame
      • Tables
        • Table
        • ClassicTable
        • RadioTable
        • ClassesTable
        • RandomSplitsTable
        • FastTable
      • Charts and Plots
        • LineChart
        • GridChart
        • HeatmapChart
        • ApexChart
        • ConfusionMatrix
        • LinePlot
        • GridPlot
        • ScatterChart
        • TreemapChart
        • PieChart
      • Compare Data
        • MatchDatasets
        • MatchTagMetas
        • MatchObjClasses
        • ClassBalance
        • CompareAnnotations
      • Widgets demos on github
  • 😎Advanced user guide
    • Objects binding
    • Automate with Python SDK & API
      • Start and stop app
      • User management
      • Labeling Jobs
  • 🖥️UI widgets
    • Element UI library
    • Supervisely UI widgets
    • Apexcharts - modern & interactive charts
    • Plotly graphing library
  • 📚API References
    • REST API Reference
    • Python SDK Reference
Powered by GitBook
On this page
  • Introduction
  • Version releases and Branch releases
  • Multi-app repositories
  • Step 1. Create a repository
  • Step 2. Add GitHub workflow
  • Step 3. Publish to production
  • Step 4. Create a release
  • App development process
  • App Development and local tests
  • Testing on development instance
  • Releasing the app to the public
  • Developing new features
  • Updating the app
  • Process for submitting a Public App
  • Step 1. Develop and test your app locally
  • Step 2. Submit your repository for review
  • Step 3. Review by Supervisely Team
  • Step 4: Maintenance and updates

Was this helpful?

Edit on GitHub
  1. App development
  2. Basics

Add public app

PreviousAdd private appNextApp Compatibility

Last updated 6 months ago

Was this helpful?

Introduction

Supervisely supports both private and public apps.

🔒 Private apps are those that are available only on your private Supervisely Instance (Enterprise Edition) in your account. The guidelines for adding public apps is .

🌎 Public apps are available on all private Supervisely Instances and in Community Edition.

This tutorial covers the case of adding a public app. It means that this app is open-sourced and is available on all Supervisely instances (Community Edition and all private customer's instances with Enterprise Edition license).

Only for Supervisely Team.

Version releases and Branch releases

There are two types of releases: version and branch. The version release is made from the main or master branch. With each version release, a release tag is added to the last commit. This tag is used to identify the release version and is important for the app versioning. If during the release process, the tag is not created, the release will be rejected. With version releases, you can specify the release version and description. The branch releases are for testing and debugging and are made from any other branch except main or master. With branch releases, you can't specify the release version and description. The release version will be the branch name.

Multi-app repositories

In Supervisely you can have a single git repository with multiple applications. It is advised to have connected applications with a common codebase in the same repository. By default supervisely release command will release the application from the root directory of the repository. If you have multiple applications in the repository, you can specify the path to the application directory with the -a flag. The application directory is a directory with a config.json file. Such applications are called subapps. For example, if you have a repository with two applications in the train and serve directories, you can release the train application with the following command:

supervisely release -a train

When making a release the tag is added to the last commit. And since all of the applications are in the same repository, it is impossible to differentiate the release tags of different applications. Therefore, it is advised to do a release for each subapp with every new version.

Step 1. Create a repository

Create an app repository on GitHub in a . *

Step 2. Add GitHub workflow

Workflow files to release the app as private and as public are the same. If you already have .github/workflows/release.yml or .github/workflows/release_branch.yml you only need to add .github/workflows/publish.yml file.

name: Release
run-name: Release version "${{ github.event.release.tag_name }}"
on:
  release:
    types: [published]
    branches:
      - main
      - master
jobs:
  Supervisely-Release:
    ***
    with:
      ***
      SUBAPP_PATHS: "__ROOT_APP__, subapp" <-- Change this variable

In each of this files, you should change the following variable: SUBAPP_PATHS - Paths to directories with applications within the repository (directory where the config.json file is located). If the application is located in a root directory, then you should specify __ROOT_APP__ instead of the path. Paths should be separated by commas.

In the example above, releases are configured for two applications in the repository: the one which is located in root directory and the one which is located in the subapp directory. Example for the repository with two applications, located in train and serve directories: SUBAPP_PATHS: "train, serve".

Step 3. Publish to production

Workflow files to release the app as private and as public are the same. To make your private app public you need to run Publish to production workflow.

This workflow will create a public release for all the GitHub releases in the repository. Only releases with valid version names (in semver format) will be published.

To run the workflow you need to go to the Actions tab of the repository and select the Publish app to production workflow. Then click on the Run workflow button. Do not change the Target of the release. It should always be main or master.

After the app is published to the production you will no longer be able to create releases via CLI tool and you will need to create releases via GitHub interface. How to do it is described below in steps 3.2 and 3.3.

Step 4. Create a release

4.1 Version release

The workflow we created in the previous step will be triggered when you publish a release in the repository.

To create a release, go to the repository page on GitHub and click on the Releases tab. Then click on the Create a new release or Draft a new release button. Choose a tag version in semver format (v1.0.0) and a release title. Then click on the Publish release button.

Do not change the Target of the release. It should always be main or master.

4.2 Branch release

The workflow we created in the previous step will be triggered when you push a branch (except "main" or "master") in the repository.

You can disable branch release by adding branch name to branches-ignore list in the .github/workflows/release_branch.yml workflow file. See below

name: Release branch
run-name: Release "${{ github.ref_name }}" branch
on:
  push:
    branches-ignore:
      - main
      - master
      - branch-to-ignore <-- Add branch name here
jobs:
  Supervisely-Release:

After the release is published the workflow will be triggered and you can see the release progress in the Actions tab. If the workflow is successful, the app will appear in the ecosystem.

App development process

App Development and local tests

The developer creates the application and tests it locally.

Testing on development instance

For development in a team you need to add APP_RELEASE_TOKEN variable to your ~/supervisely.env file. Ask the administrator for the token.

Releasing the app to the public

Developing new features

Still in development

You may be asking yourself: "How can I develop new features for my app if I can't create releases via CLI tool?". There is a solution for that. Future feature development and testing are done in development branches (any branch other than main or master).

name: Supervisely release
run-name: Supervisely ${{ github.repository }} app release
on:
  push:
    branches-ignore:
      - main
      - master
jobs:
    ***
      SUBAPP_PATHS: "__ROOT_APP__, subapp"

This workflow will be triggered on any push to any branch other than main or master. It will create a release with the name of the branch. For example, if you push to the dev branch, the release will be created with the version dev and the name dev branch release.

You can also limit branches on which the workflow will be triggered. To do so you need to replace branches-ignore parameter with branches parameter to the on section of the workflow. For example, if you want to trigger the workflow only on the test branch you need to add on: push: branches: - test

Updating the app

Process for submitting a Public App

Developers can submit their apps for review to Supervisely by following these steps:

Step 1. Develop and test your app locally

  1. Develop your app in a public repository on GitHub.

  2. Perform local testing to ensure your app works as expected.

Step 2. Submit your repository for review

Once your app is ready, email the repository link to support@supervisely.com, requesting a review for public release. Include the following details:

  • Repository URL

  • Brief description of your app

  • Any special requirements or instructions for testing

Step 3. Review by Supervisely Team

The Supervisely Team will fork your repository, review your code, and test the app. If the app meets the quality and security standards, the team will publish it as a public app in the Supervisely Ecosystem. If there are issues, you will receive a detailed list of improvements required.

Step 4: Maintenance and updates

Once the app is published, it will be accessible to all Supervisely users. The app remains maintained by the original developer (through the forked repository), but future changes will be subject to Supervisely's review before release.

Supervisely reserves the right to reject apps that do not meet security, quality, or compatibility standards.

Add a GitHub workflow files from :

To publish the app to the production (see step 3):

For version releases (see step 4.1):

For branch releases (see step 4.2):

Publish

When you done with development and local tests, you can test your app on the development instance. To do so you need to create a private app on the development instance and then create a new release. *.

The preferred way is to use CLI tool from the SDK. From the environment where you have installed the SDK, run the following command: supervisely release and follow the instructions. Make sure you set the correct server address and API token. After the release is created, you can find the application in the .

When you are ready to publish your app to the public, you need to create a public app. To do so you need to follow the steps described in the of this tutorial. After the app is published to the public you will no longer be able to create releases via CLI tool.

Do not forget to add the app to the . It is needed for back-compatibility with older versions of Supervisley instances. To check that the app is released on older instances ask the administrator.

To activate this mechanism you need to add another workflow file to the repository: You can use .

Same as in you need to change the SUBAPP_PATHS variable.

When you need to update the app, you need to create a new release. It is described in of this tutorial.

🔥
this tutorial
Supervisely-ecosystem organization
How to create an app
this repository
.github/workflows/publish.yml
.github/workflows/release.yml
.github/workflows/release_branch.yml
How to add private app
Private apps tab of the ecosystem
README_v2
This file
steps 1 to 3
step 2
step 4