git_demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "import notebook\n",
    "notebook.nbextensions.check_nbextension('nb-mermaid',user=True)\n",
    "require(['base/js/utils'],\n",
    "function(utils) {\n",
    "        utils.load_extensions('nb-mermaid/nb-mermaid');\n",
    "});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TM1 in the DevOps Ecosystem with TM1Py\n",
    "The below code snippets cover on a step-by-step basis on how to implement tm1-git methodology in your existing tm1 implementation.<br>\n",
    "What's needed in order to run this:\n",
    "\n",
    "- Python >= 3.7\n",
    "- TM1py >= 1.10.0\n",
    "- Git installed\n",
    "- Git repository (GitHub, Azure, AWS Code Commit)\n",
    "- Two tm1 instances up and running"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Brief review of Git related concepts:\n",
    "Before jumping into the demo, let's try to level the ground on some basic concepts. What is...?\n",
    "\n",
    "- ``Git``: <br>\n",
    "Git is a free and open-source distributed version control system designed to track changes in code and other files, allowing multiple developers to work on a project simultaneously. It provides a structured and efficient way to manage and collaborate on software development by keeping track of code history, enabling branching and merging, and facilitating collaboration among team members.\n",
    "\n",
    "- ``Repository``: <br>\n",
    "A repository, often referred to as a \"repo,\" is a storage location where all the files and version history of a project are stored. It can be thought of as a folder or directory that contains all the code, documents, and assets for a specific project.\n",
    "\n",
    "- ``Initialization``: <br>\n",
    "Initialization typically refers to the process of setting up a new repository or project with version control using Git. When you initialize a repository, Git creates a hidden directory called \".git\" in the project's root directory. This directory contains all the necessary files and data to track changes and manage version history for your project.\n",
    "\n",
    "- ``Branch``: <br>\n",
    "A branch in Git is a separate line of development that diverges from the main codebase, allowing multiple developers to work on different features, fixes, or experiments simultaneously. Each branch represents a copy of the project's code, and changes made in one branch do not immediately affect other branches. Branches are used to isolate and manage code changes, making it easier to collaborate on and organize the development process.\n",
    "\n",
    "- ``Commit``: <br>\n",
    "A commit is a snapshot of the changes made to the files in a Git repository at a specific point in time. Each commit represents a set of changes (additions, deletions, or modifications) made by a developer. Commits are accompanied by a commit message that describes the purpose or context of the changes.\n",
    "\n",
    "- ``Push``:<br>\n",
    "Pushing in Git refers to the action of uploading your local commits to a remote repository. It is typically used to share your local changes with others or to synchronize your work with a central repository. When you push, your commits become part of the remote repository's history.\n",
    "\n",
    "- ``Pull``:<br>\n",
    "Pulling in Git is the process of fetching and merging changes from a remote repository into your local repository. It's used to update your local copy of a repository with changes made by other collaborators. A \"pull\" combines the \"fetch\" (retrieving changes) and \"merge\" (combining changes) operations into a single step.\n",
    "\n",
    "- ``Pull Request``:<br>\n",
    "A pull request (often abbreviated as PR) is a feature primarily associated with Git hosting platforms like GitHub and GitLab. It is a way for developers to propose changes to a repository's codebase. When you create a pull request, you are requesting that the repository's owner or maintainers review and potentially merge your changes into the main branch. Pull requests provide a collaborative and structured way to manage code contributions.\n",
    "\n",
    "- ``GitHub``: <br>\n",
    "GitHub is a web-based platform and hosting service that enhances collaboration and version control for software development projects. It leverages the Git version control system to provide a centralized location for developers to store, manage, and collaborate on code repositories. GitHub offers a wide range of features to facilitate code sharing, issue tracking, code review, and project management.\n",
    "\n",
    "### Brief review of Jenkins related concepts:\n",
    "Before jumping into the demo, let's try to level the ground on some basic concepts. What is...?\n",
    "\n",
    "- ``Jenkins``: <br>\n",
    "Jenkins is an open-source automation server that is widely used in DevOps and software development processes. It provides a platform for automating various tasks related to building, testing, and deploying software. Jenkins helps streamline the development and delivery pipeline by enabling continuous integration and continuous delivery (CI/CD) practices.\n",
    "\n",
    "- ``Pipeline``: <br>\n",
    "Jenkins Pipelines are a key feature that enable you to define and manage your CI/CD processes as code. They offer a structured way to automate and orchestrate the steps involved in building, testing, and deploying software. Jenkins Pipelines are typically written in a domain-specific language called Groovy and can be version-controlled alongside your application code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What's our starting point?\n",
    "- An empty GitHub repository\n",
    "- TM1 Instance in PROD that we want to source control\n",
    "- A Jenkins agent install in the TM1 Server"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import necessary modules, define global variables and Git functions\n",
    "Below we will define the source instance, other global variables and Git related functions we will use to manage our assets through Git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing the required libraries\n",
    "import configparser\n",
    "import json\n",
    "from TM1py.Services import TM1Service\n",
    "from TM1py.Objects import GitProject\n",
    "\n",
    "# setting up OS varibles\n",
    "config = configparser.ConfigParser()\n",
    "config.read('config.ini')\n",
    "\n",
    "# defining tm1 source and target instance from config.ini\n",
    "tm1_instance_prod = 'DEMO_PROD'\n",
    "\n",
    "# define git variables\n",
    "git_url='https://github.com/nicolasbisurgi/horizon2023_demo.git'\n",
    "git_user = 'nicolasbisurgi'\n",
    "git_email ='nicolasbisurgi@gmail.com'\n",
    "\n",
    "# Define Git functions\n",
    "\n",
    "def initiate_git_repo(tm1_instance_name:str, deployment: str):\n",
    "    with TM1Service(**config[tm1_instance_name]) as tm1:\n",
    "\n",
    "        # get instance configuration fields\n",
    "        git_pat = config.get(tm1_instance_name, 'git_pat')\n",
    "\n",
    "        # initiate git repo\n",
    "        tm1.git.git_init(\n",
    "            git_url=git_url,\n",
    "            deployment=deployment,\n",
    "            username=git_user,\n",
    "            password=git_pat,\n",
    "            force=True\n",
    "        )\n",
    "\n",
    "def push_to_git_repo(tm1_instance_name:str, message: str, branch: str, new_branch:str= None):\n",
    "    with TM1Service(**config[tm1_instance_name]) as tm1:\n",
    "\n",
    "        # get instance configuration fields\n",
    "        git_pat = config.get(tm1_instance_name, 'git_pat')\n",
    "\n",
    "        # push to repo\n",
    "        tm1.git.git_push(\n",
    "            message=message,\n",
    "            author=git_user,\n",
    "            email=git_email,\n",
    "            branch=branch,\n",
    "            new_branch=new_branch,\n",
    "            force=True,\n",
    "            username=git_user,\n",
    "            password=git_pat,\n",
    "            execute=True\n",
    "        )\n",
    "\n",
    "def pull_from_git_repo(tm1_instance_name: str, branch: str):\n",
    "\n",
    "    with TM1Service(**config[tm1_instance_name]) as tm1:\n",
    "        # get instance configuration fields\n",
    "        git_pat = config.get(tm1_instance_name, 'git_pat')\n",
    "\n",
    "        # pull to repo\n",
    "        pull_plan = tm1.git.git_pull(\n",
    "            branch=branch,\n",
    "            force=True,\n",
    "            execute=True,\n",
    "            username=git_user,\n",
    "            password=git_pat\n",
    "        )\n",
    "    # the below is not needed to execute the function but it offers some visibility\n",
    "    # to what's happening between the git repo and the tm1 server\n",
    "    pull_plan_ID = json.loads(pull_plan.content).get('ID')\n",
    "    pull_plan_operations = json.loads(pull_plan.content).get('Operations')\n",
    "\n",
    "    print(\n",
    "        f\"Created plan ID: {pull_plan_ID} with the below list of objects:\")\n",
    "    for operation in pull_plan_operations:\n",
    "        print(f\"{operation}\")\n",
    "\n",
    "\n",
    "def put_tm1project(tm1_instance_name:str):\n",
    "    with TM1Service(**config[tm1_instance_name]) as tm1:\n",
    "\n",
    "        # put tm1project on target instance\n",
    "        tm1_project = GitProject.TM1Project.from_file('tm1project.json')\n",
    "        tm1.git.tm1project_put(tm1_project)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initiate Git repository in TM1\n",
    "Action GitInit binds a remote Git repository to the TM1 server. It also initializes a Git context that stores the information of the Git-related operations, for example, the most recent Git branch that has been deployed. The Git context is persistent and server-scoped.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initiate instances\n",
    "initiate_git_repo(tm1_instance_prod, deployment='PROD')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` mermaid\n",
    "flowchart LR\n",
    "subgraph \"TM1 Server\"\n",
    "    A[(TM1_Instance)] -->|new directory| D[\"`./}git/.git`\"]\n",
    "end\n",
    "subgraph \"GitHub\"\n",
    "    A[(TM1_Instance)] <-->|REST| G(((Git Repo)))\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Customizing your tm1 assets with TM1Project\n",
    "In order to custom select what we want to migrate and how we want to do so, we can make use of the TM1 project<br>\n",
    "\n",
    "A project file tm1project.json SHOULD be created for each model. It specifies how to deploy and publish the model. The content of the project file is a JSON object with properties explained in the following sections.<br>\n",
    "\n",
    "The project file can be manually modified on Git. The server exposes the project file as a !tm1project resource, which can be viewed (GET) and modified (PUT). The project file is a part of the Git context. When a model is successfully deployed, the project file in the deployed model becomes the project file of the server.<br>\n",
    "\n",
    "*Below is a sample of the tm1project that we will be using in our session*\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"Version\": \"1.0\",\n",
    "  \"Name\": \"horizon2023_demo\",\n",
    "  \"Ignore\":\n",
    "  [\n",
    "    \"Cubes\",\n",
    "    \"Dimensions\",\n",
    "    \"!Processes('}bedrock*')\"\n",
    "  ],\n",
    "  \"Files\":\n",
    "  [\n",
    "    \"source_files/rules/*.*\",\n",
    "    \"source_files/data/*.*\",\n",
    "    \"source_files/metadata/*.*\",\n",
    "    \"source_files/misc/*.*\",\n",
    "    \"source_files/scripts/*.*\"\n",
    "  ],\n",
    "  \"Tasks\":\n",
    "  {\n",
    "    \"pre_push\":\n",
    "    {\n",
    "      \"Process\": \"Processes('sys_pre_push')\"\n",
    "    },\n",
    "    \"post_push\":\n",
    "    {\n",
    "      \"Process\": \"Processes('sys_post_push')\"\n",
    "    },\n",
    "    \"pre_pull\":\n",
    "    {\n",
    "      \"Process\": \"Processes('sys_pre_pull')\"\n",
    "    },\n",
    "    \"post_pull\":\n",
    "    {\n",
    "      \"Process\": \"Processes('sys_post_pull')\"\n",
    "    }\n",
    "  },\n",
    "  \"PrePush\":\n",
    "  [\n",
    "    \"Tasks('pre_push')\"\n",
    "  ],\n",
    "  \"PostPush\":\n",
    "  [\n",
    "    \"Tasks('post_push')\"\n",
    "  ],\n",
    "  \"PrePull\":\n",
    "  [\n",
    "    \"Tasks('pre_pull')\"\n",
    "  ],\n",
    "  \"PostPull\":\n",
    "  [\n",
    "    \"Tasks('post_pull')\"\n",
    "  ]\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Tasks as hooks\n",
    "The below TI's will handle code packaging activities as well as pre and post deployment steps as follows:\n",
    "- ``sys_pre_push``: This process will export rules, attributes, hierarchies and (some) data to flat files before pushing to the Git repo.\n",
    "- ``sys_post_push``: This process will be execute immediately after pushing to the repo, there are no actions in it for now.\n",
    "- ``sys_pre_pull``: This process will run savedataall, take a backup of the instance and clean the logs.\n",
    "- ``sys_post_pull``: This process will load the files generated by the source with the `sys_pre_push` process into the target tm1 instance.\n",
    "\n",
    "All these processes are wrapper os bedrock code, but you can put whatever you want in them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# put the tm1project\n",
    "put_tm1project(tm1_instance_prod)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Push source code to remote Git repo\n",
    "The first step to publish a model is to execute the GitPush action to create a Git push plan.\n",
    "\n",
    "GitPush takes the following parameters:\n",
    "\n",
    "- ``Branch``: the branch from which the last commit is used as the parent commit of the commit to create. If the Git repository is empty, this parameter **MUST NOT** be specified.\n",
    "\n",
    "- ``NewBranch``: if specified, the server creates a new branch and push the new commit onto it; if not specified, the server pushes the new commit onto the branch specified by Branch. If the Git repository is empty, this parameter MUST be present to instruct the server to create a base commit.\n",
    "\n",
    "- ``Force``: a flag passed in for evaluating preconditions.\n",
    "\n",
    "- ``Message``: the commit message.\n",
    "\n",
    "- ``Author``: the name of the commit author.\n",
    "\n",
    "- ``Email``: the email of the commit author.\n",
    "\n",
    "- ``Username``: the Git credential.\n",
    "\n",
    "- ``Password``: the Git credential."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "push_to_git_repo(\n",
    "    tm1_instance_name=tm1_instance_prod,\n",
    "    message='initial_commit',\n",
    "    branch='main'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` mermaid\n",
    "flowchart TD\n",
    "subgraph \"GitHub\"\n",
    "    G(((Git Repo)))\n",
    "end\n",
    "subgraph \"TM1 Prod Server\"\n",
    "    B[(TM1_Instance)] <-->|\"`REST<br> pushes code to repo as defined in tm1project`\"| G\n",
    "    B[(TM1_Instance)] --> |changes since init or last push| D[\"`./}git/.git`\"]\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bug to Fix & Enhancement\n",
    "Create new instance from Jenkins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a Development and Support instances\n",
    "In order to do bug fixing and new development we need 2 new instances"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` mermaid\n",
    "flowchart LR\n",
    "subgraph \"GitHub\"\n",
    "    G(((Git Repo)))\n",
    "end\n",
    "subgraph \"TM1 Server\"\n",
    "    J(((Jenkins Agent))) --> | creates service | T[(TM1_Instance)]\n",
    "    T <--> | pulls from repo | G\n",
    "end  \n",
    "subgraph \"Jenkins Server\"\n",
    "    S[(Jenkins Server)] --> | executes Pipeline | J\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bug Fix first then push to GitHub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tm1_instance_support = 'DEMO_SUPPORT'\n",
    "push_to_git_repo(\n",
    "    tm1_instance_name=tm1_instance_support,\n",
    "    message='adding comments',\n",
    "    branch='main',\n",
    "    new_branch='bugfix_ti_change'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graphical representation of current branches in GitHub\n",
    "``` mermaid\n",
    "%%{init: { 'logLevel': 'debug', 'theme': 'base', 'themeVariables': {\n",
    "        'git0': '#ffffff',\n",
    "        'git1': '#ff0000'},\n",
    "'gitGraph': {'showBranches': true, 'showCommitLabel':true,'mainBranchName': 'main'}} }%%\n",
    "gitGraph\n",
    "       commit id: \" \" tag: \"initial_commit\"\n",
    "       branch bugfix_ti_change\n",
    "       checkout bugfix_ti_change\n",
    "       commit id: \"added_comment\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Enhancement and then push to GitHub\n",
    "Create new process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tm1_instance_dev = 'DEMO_DEV'\n",
    "push_to_git_repo(\n",
    "    tm1_instance_name=tm1_instance_dev,\n",
    "    message='adding new super empty process',\n",
    "    branch='main',\n",
    "    new_branch='feature_new_process'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graphical representation of current branches in GitHub\n",
    "``` mermaid\n",
    "%%{init: { 'logLevel': 'debug', 'theme': 'base', 'themeVariables': {\n",
    "        'git0': '#ffffff',\n",
    "        'git1': '#ff0000',\n",
    "        'git2': '#00ff00'},\n",
    "'gitGraph': {'showBranches': true, 'showCommitLabel':true,'mainBranchName': 'main'}} }%%\n",
    "gitGraph\n",
    "       commit id: \" \" tag: \"initial_commit\"\n",
    "       branch bugfix_ti_change\n",
    "       checkout bugfix_ti_change\n",
    "       commit id: \"added_comment\"\n",
    "       checkout main\n",
    "       branch feature_new_process\n",
    "       checkout feature_new_process\n",
    "       commit id: \"new_ti\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What's next?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merging all changes\n",
    "Now that both the bug and the enhancement is there, we can merge them either one-by-one to ``main`` or combine them into one and then mergin with ``main``.\n",
    "LEt's explore this last option."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` mermaid\n",
    "%%{init: { 'logLevel': 'debug', 'theme': 'base', 'themeVariables': {\n",
    "        'git0': '#ffffff',\n",
    "        'git1': '#ff0000',\n",
    "        'git2': '#00ff00'},\n",
    "'gitGraph': {'showBranches': true, 'showCommitLabel':true,'mainBranchName': 'main'}} }%%\n",
    "gitGraph\n",
    "       commit id: \" \" tag: \"initial_commit\"\n",
    "       branch bugfix_ti_change\n",
    "       checkout bugfix_ti_change\n",
    "       commit id: \"added_comment\"\n",
    "       checkout main\n",
    "       branch feature_new_process\n",
    "       checkout feature_new_process\n",
    "       commit id: \"added_ti\"\n",
    "       merge bugfix_ti_change tag: \"merging bugs and features\"\n",
    "       checkout main\n",
    "       merge feature_new_process tag: \"merging with main\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overall workflow diagram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` mermaid\n",
    "flowchart LR\n",
    "subgraph \"Dev\"\n",
    "    subgraph \"TM1 Dev Server\"\n",
    "        U[Developer] --> |makes changes to TI| A[(TM1_Instance)]\n",
    "        A -->|tracks changes| D[\"`./}git/.git`\"]\n",
    "    end\n",
    "end\n",
    "subgraph \"GitHub\"\n",
    "    D -->|\"`REST<br>pushes as single commit`\"| G(((Git Repo)))\n",
    "    G --> |run security checks on code first | G\n",
    "end\n",
    "subgraph \"Ops\"\n",
    "    subgraph \"Jenkins Server\"\n",
    "        G -->|webhook| S[(Jenkins Server)]\n",
    "    end\n",
    "    subgraph \"TM1 Prod Server\"\n",
    "        S --> | executes Pipeline | J(((Jenkins Agent)))\n",
    "        J --> |get ready to deploy|B[(TM1_Instance)]\n",
    "        B -.  pulls from repo .-> G\n",
    "    end\n",
    "\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Missing automations\n",
    "This is a short demo so not all features of these apps are shown; but one of the key pieces to mention is that we could:\n",
    "- Set GitHub to protect a specific branch so any merge happens through a code review process\n",
    "- Set GitHub to scan our code for hardcoded passords\n",
    "- Set GitHub to call Jenkins through a 'webhook' everytime our 'main' branch is updated\n",
    "- Jenkins would not just automatically deploy to production, but it would also updte the support instance for immediate remediation (if needed)\n",
    "- Jenkins can run server and environmental checks before and after deployement\n",
    "- Jenkins pipeline could also be part of a Muticonfiguration pipeline that would be called when source system have been deployed\n",
    "- Launch RushTi scripts to test the recently deployed code\n",
    "- Call DataSync to update cubes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why take this approach?\n",
    "Taking this approach to development will not be natural for TM1 developre in your organization, most TM1 developers have not worked with Git. So why making this cultural shift to a DevOps approach?\n",
    "Aside from all the obvious benefits mentioned before... we are sort of forced to:\n",
    "1. Enterprise direction: most big organizations have this implemented already and it's a matter of time since they demand TM1 behaves as all the other enterprise tool.\n",
    "2. IBM direction: this approach, though not 100% identical, is they approach that IBM is taking with v12. There will no longer be files to move, nor scripts to run inside the server (as there are no more servers). This is future prove. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extended use for DevOps applications\n",
    "You can wrap-up the above functions in a command-line app that can be called by other DevOps applications such as Jenkins pipelines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` bash\n",
    "Usage:\n",
    "  git.py init (--instance <instance> --user <user> --password <password> --deployment <deployment>)\n",
    "  git.py pull (--instance <instance> --user <user> --password <password> --branch <branch>)\n",
    "  git.py push (--instance <instance> --user <user> --password <password> --branch <branch> --message <message> --email <email>) [--new_branch <new_branch>]\n",
    "  git.py -h | --help\n",
    "  git.py -v | --version\n",
    "\n",
    "Examples:\n",
    "  git.py init (--instance \"tm1_instance_support\" --user \"nbisurgi\" --password 12345 --deployment \"support\")\n",
    "  git.py pull --instance \"tm1_instance_prod\" --user \"nbisurgi\" --password 12345 --branch \"main\"\n",
    "  git.py push --instance \"tm1_instance_dev\" --user \"nbisurgi\" --password 12345 --branch \"main\" --new_branch \"dev\"\n",
    "\n",
    "Options:\n",
    "  --instance <instance>         # Target instance for process to run.\n",
    "  --deployment <deployment>     # Deployment (DEV, QA, ..., PROD).\n",
    "  --user <user>                 # GitHub username\n",
    "  --password <password>         # GitHub Personal Access Token.\n",
    "  --branch <branch>             # Branch to work with (pull from or push to)\n",
    "  --message <message>           # Commit message\n",
    "  --email <email>               # Email to validate in GitHub\n",
    "  --new_branch <branch>         # New branch (leave blank if no new branch needs to be created)\n",
    "  -h --help                     # Show this screen.\n",
    "  -v --version                  # Show version.\n",
    "\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "60deec0190b11f76b54c9863117b38226b1f4d9875a7d5e4504204d0843b3417"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}