NIME-demos.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a9a25ed2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import maxpy as mp"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaa065c7",
   "metadata": {},
   "source": [
    "# Example 1: Creating a Patch\n",
    "In this example, we'll create a simple patch with a [metro] object connected to a button."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ba647635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patcher: new patch created from template file: empty_template.json\n",
      "('metro 1000', 'button')\n",
      "['metro 1000', 'button']\n",
      "Patcher: connected: ( metro : outlet 0 ---> button : inlet 0 )\n",
      "PatchCheck: unknown objects : no unknown objects\n",
      "\n",
      "PatchCheck: unlinked js objects : no unlinked js objects\n",
      "\n",
      "PatchCheck: linked js objects (files must be in same folder as patch file): no linked js objects\n",
      "\n",
      "PatchCheck: linked abstractions (files must be in same folder as patch file): no linked abstractions\n",
      "\n",
      "maxpatch saved to example-1.maxpat\n"
     ]
    }
   ],
   "source": [
    "patch = mp.MaxPatch() #create an empty patch\n",
    "\n",
    "metro, button = patch.place(\"metro 1000\", \"button\") #create [metro 1000] and [button] objects \n",
    "                                                    #using the same creation strings as in MaxMSP \n",
    "\n",
    "patch.connect((metro.outs[0], button.ins[0])) #connect the first outlet of [metro 1000]\n",
    "                                              #to the first inlet of [button]\n",
    "    \n",
    "patch.save(\"example-1.maxpat\") #save patch to a MaxMSP file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4aa0146",
   "metadata": {},
   "source": [
    "# Example 2: Editing Existing Patches\n",
    "This next example shows how we can use MaxPy to edit existing patches.  \n",
    "We'll load in the patch we just made, add an [inlet] and an [outlet], and connect them to the [metro] and the button. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b65e6e59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patcher: loading patch from existing file: example-1.maxpat\n",
      "Patcher: metro added, total objects 1\n",
      "Patcher: button added, total objects 2\n",
      "Patcher: connected: ( metro : outlet 0 ---> button : inlet 0 )\n",
      "Patcher: patch loaded from existing file: example-1.maxpat\n",
      "('inlet', 'outlet')\n",
      "['inlet', 'outlet']\n",
      "Patcher: connected: ( inlet : outlet 0 ---> metro : inlet 0 )\n",
      "Patcher: connected: ( button : outlet 0 ---> outlet : inlet 0 )\n",
      "PatchCheck: unknown objects : no unknown objects\n",
      "\n",
      "PatchCheck: unlinked js objects : no unlinked js objects\n",
      "\n",
      "PatchCheck: linked js objects (files must be in same folder as patch file): no linked js objects\n",
      "\n",
      "PatchCheck: linked abstractions (files must be in same folder as patch file): no linked abstractions\n",
      "\n",
      "maxpatch saved to example-2.maxpat\n"
     ]
    }
   ],
   "source": [
    "patch = mp.MaxPatch(load_file = \"example-1.maxpat\") #load patch from file \n",
    "\n",
    "metro = None\n",
    "button = None\n",
    "\n",
    "#this block lets us easily find the metro and button objects in the patch\n",
    "#so that we can connect them later\n",
    "for obj_id, obj in patch.objs.items():\n",
    "    if obj.name == \"metro\":\n",
    "        metro = obj\n",
    "    elif obj.name == \"button\":\n",
    "        button = obj\n",
    "\n",
    "inlet, outlet = patch.place(\"inlet\", \"outlet\") #create [inlet] and [outlet] objects\n",
    "\n",
    "patch.connect((inlet.outs[0], metro.ins[0]),   #connect [inlet] --> [metro]\n",
    "              (button.outs[0], outlet.ins[0])) #connect [button] --> [outlet]\n",
    "\n",
    "patch.save(\"example-2.maxpat\") #save as a new file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cb3fee0",
   "metadata": {},
   "source": [
    "# Example 3: Object Placement \n",
    "You probably noticed that the objects from the last examples were placed awkwardly.  \n",
    "In this example, we'll see\n",
    "a few different ways to specify object placement."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30bcb1e6",
   "metadata": {},
   "source": [
    "### 3.1 Initial placement\n",
    "The first way is to specify object coordinates when initially placing the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "86bacd19",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patcher: new patch created from template file: empty_template.json\n",
      "('inlet', 'metro 1000', 'button', 'outlet')\n",
      "['inlet', 'metro 1000', 'button', 'outlet']\n",
      "Patcher: connected: ( inlet : outlet 0 ---> metro : inlet 0 )\n",
      "Patcher: connected: ( metro : outlet 0 ---> button : inlet 0 )\n",
      "Patcher: connected: ( button : outlet 0 ---> outlet : inlet 0 )\n",
      "PatchCheck: unknown objects : no unknown objects\n",
      "\n",
      "PatchCheck: unlinked js objects : no unlinked js objects\n",
      "\n",
      "PatchCheck: linked js objects (files must be in same folder as patch file): no linked js objects\n",
      "\n",
      "PatchCheck: linked abstractions (files must be in same folder as patch file): no linked abstractions\n",
      "\n",
      "maxpatch saved to example-3-1.maxpat\n"
     ]
    }
   ],
   "source": [
    "patch = mp.MaxPatch() #create empty patch\n",
    "inlet, metro, button, outlet = patch.place(\"inlet\", \"metro 1000\", \"button\", \"outlet\", #list of objects to place\n",
    "                                           spacing_type = \"custom\",                   #choose custom spacing                                  \n",
    "                                           spacing = [[100, 100],                     #coordinates for each object\n",
    "                                                      [100, 200],\n",
    "                                                      [100, 300],\n",
    "                                                      [100, 400]])\n",
    "\n",
    "\n",
    "patch.connect((inlet.outs[0], metro.ins[0]),\n",
    "              (metro.outs[0], button.ins[0]),\n",
    "              (button.outs[0], outlet.ins[0]))\n",
    "\n",
    "patch.save(\"example-3-1.maxpat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a52103f",
   "metadata": {},
   "source": [
    "### 3.2 Moving objects\n",
    "The second way is to move objects after their initial placement. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "b6ac1e47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patcher: loading patch from existing file: example-3-1.maxpat\n",
      "Patcher: inlet added, total objects 1\n",
      "Patcher: metro added, total objects 2\n",
      "Patcher: button added, total objects 3\n",
      "Patcher: outlet added, total objects 4\n",
      "Patcher: connected: ( inlet : outlet 0 ---> metro : inlet 0 )\n",
      "Patcher: connected: ( metro : outlet 0 ---> button : inlet 0 )\n",
      "Patcher: connected: ( button : outlet 0 ---> outlet : inlet 0 )\n",
      "Patcher: patch loaded from existing file: example-3-1.maxpat\n",
      "PatchCheck: unknown objects : no unknown objects\n",
      "\n",
      "PatchCheck: unlinked js objects : no unlinked js objects\n",
      "\n",
      "PatchCheck: linked js objects (files must be in same folder as patch file): no linked js objects\n",
      "\n",
      "PatchCheck: linked abstractions (files must be in same folder as patch file): no linked abstractions\n",
      "\n",
      "maxpatch saved to example-3-2.maxpat\n"
     ]
    }
   ],
   "source": [
    "#load in the file we just made \n",
    "patch = mp.MaxPatch(load_file = \"example-3-1.maxpat\")\n",
    "\n",
    "\n",
    "#find all the objects in the patch\n",
    "inlet = None\n",
    "metro = None\n",
    "button = None\n",
    "outlet = None\n",
    "for obj_id, obj in patch.objs.items():\n",
    "    if obj.name == \"inlet\":\n",
    "        inlet = obj\n",
    "    elif obj.name == \"metro\":\n",
    "        metro = obj\n",
    "    elif obj.name == \"button\":\n",
    "        button = obj\n",
    "    elif obj.name == \"outlet\":\n",
    "        outlet = obj\n",
    "\n",
    "        \n",
    "#move each object to a new location \n",
    "inlet.move(300, 400)\n",
    "metro.move(300, 500)\n",
    "button.move(300, 600)\n",
    "outlet.move(300, 700)\n",
    "\n",
    "#save the patch\n",
    "patch.save(\"example-3-2.maxpat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cec83f85",
   "metadata": {},
   "source": [
    "# Example 4: Abstractions\n",
    "One of the more powerful aspects of MaxPy is the ability to work with abstractions.  \n",
    "In this example, we'll make a new patch that uses all the patches made previously as abstracted objects. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "19720fb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patcher: new patch created from template file: empty_template.json\n",
      "('example-1', 'example-2', 'example-3-1', 'example-3-2')\n",
      "['example-1', 'example-2', 'example-3-1', 'example-3-2']\n",
      "  ObjectMsg: example-1 : creation : example-1.maxpat file found, abstraction created\n",
      "  ObjectMsg: example-2 : creation : example-2.maxpat file found, abstraction created\n",
      "  ObjectMsg: example-3-1 : creation : example-3-1.maxpat file found, abstraction created\n",
      "  ObjectMsg: example-3-2 : creation : example-3-2.maxpat file found, abstraction created\n",
      "('loadbang',)\n",
      "['loadbang']\n",
      "('button', 'button', 'button')\n",
      "['button', 'button', 'button']\n",
      "Patcher: connected: ( loadbang : outlet 0 ---> example-2 : inlet 0 )\n",
      "Patcher: connected: ( loadbang : outlet 0 ---> example-3-1 : inlet 0 )\n",
      "Patcher: connected: ( loadbang : outlet 0 ---> example-3-2 : inlet 0 )\n",
      "Patcher: connected: ( example-2 : outlet 0 ---> button : inlet 0 )\n",
      "Patcher: connected: ( example-3-1 : outlet 0 ---> button : inlet 0 )\n",
      "Patcher: connected: ( example-3-2 : outlet 0 ---> button : inlet 0 )\n",
      "PatchCheck: unknown objects : no unknown objects\n",
      "\n",
      "PatchCheck: unlinked js objects : no unlinked js objects\n",
      "\n",
      "PatchCheck: linked js objects (files must be in same folder as patch file): no linked js objects\n",
      "\n",
      "PatchCheck: linked abstractions (files must be in same folder as patch file):\n",
      "               obj-1 : example-1 [example-1] --> example-1.maxpat\n",
      "               obj-2 : example-2 [example-2] --> example-2.maxpat\n",
      "               obj-3 : example-3-1 [example-3-1] --> example-3-1.maxpat\n",
      "               obj-4 : example-3-2 [example-3-2] --> example-3-2.maxpat\n",
      "\n",
      "maxpatch saved to example-4.maxpat\n"
     ]
    }
   ],
   "source": [
    "patch = mp.MaxPatch() #make an empty patch\n",
    "\n",
    "ex1, ex2, ex31, ex32 = patch.place(\"example-1\", \"example-2\", \"example-3-1\", \"example-3-2\") #place abstractions\n",
    "\n",
    "loadbang = patch.place(\"loadbang\", #place a loadbang above\n",
    "                                                 spacing_type = \"custom\",\n",
    "                                                 spacing = [[80, 25]])[0]\n",
    "\n",
    "button1, button2, button3 = patch.place(\"button\", \"button\", \"button\", #place three buttons below\n",
    "                                                 spacing_type = \"custom\",\n",
    "                                                 spacing = [[160, 150],\n",
    "                                                            [240, 150],\n",
    "                                                            [320, 150]])\n",
    "\n",
    "\n",
    "patch.connect((loadbang.outs[0], ex2.ins[0]), #connect loadbang to abstractions with inlets \n",
    "              (loadbang.outs[0], ex31.ins[0]),\n",
    "              (loadbang.outs[0], ex32.ins[0]))\n",
    "\n",
    "patch.connect((ex2.outs[0], button1.ins[0]), #connect abstractions with outlets to buttons \n",
    "              (ex31.outs[0], button2.ins[0]),\n",
    "              (ex32.outs[0], button3.ins[0]))\n",
    "\n",
    "\n",
    "patch.save(\"example-4.maxpat\") #save patch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eebb4f74",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}