
      "The following cell illustrates creating and embedding an inline frame and serving the static source file for this notebook, which is serialized as JSON data."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.display import IFrame\n",
      "from IPython.core.display import display\n",
      "\n",
      "# IPython Notebook can serve files relative to the location of\n",
      "# the working notebook into inline frames. Prepend the path \n",
      "# with the 'files' prefix\n",
      "\n",
      "static_content = 'files/resources/appc-pythontips/hello.txt'\n",
      "\n",
      "display(IFrame(static_content, '100%', '600px'))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Shared Folders\n",
      "\n",
      "The Vagrant virtual machine maps the top level directory of your GitHub checkout (the directory containing _README.md_) on your host machine to its _/vagrant_ folder and automatically synchronizes files between the guest and host environments as an incredible convenience to you. This mapping and synchronization enables IPython Notebooks you are running on the guest machine to access files that you can conveniently manage on your host machine and vice-versa. For example, many of the scripts in IPython Notebooks may write out data files and you can easily access those data files on your host environment (should you desire to do so) without needing to connect into the virtual machine with an SSH session. On the flip side, you can provide data files to IPython Notebook, which is running on the guest machine by copying them anywhere into your top level GitHub checkout. \n",
      "\n",
      "In effect, the top level directory of your GitHub checkout is automatically synchronized between the guest and host environments so that you have access to everything that is happening and can manage your source code, modified notebooks, and everything else all from your host
" The following cell illustrates creating and implant an inline frame of reference and serving the static source file for this notebook, which is serialize as JSON data. " 
      ] 
     }, 
     { 
      " cell_type ": " code ", 
      " collapsed ": false, 
      " input signal ": [ 
       " from IPython.display import IFrame\n ", 
       " from IPython.core.display import display\n ", 
       " \n ", 
       " # IPython Notebook can service files relative to the localization of\n ", 
       " # the working notebook into inline frames. Prepend the way \n ", 
       " # with the' files' prefix\n ", 
       " \n ", 
       " static_content =' files / resources / appc - pythontips / hello.txt'\n ", 
       " \n ", 
       " display(IFrame(static_content,' 100%',' 600px') ) " 
      ], 
      " language ": " python ", 
      " metadata ": { }, 
      " outputs ": [ ] 
     }, 
     { 
      " cell_type ": " markdown ", 
      " metadata ": { }, 
      " source ": [ 
       " # # Shared Folders\n ", 
       " \n ", 
       " The aimless virtual machine maps the top level directory of your GitHub check (the directory containing _ README.md _) on your host machine to its _ /vagrant _ folder and automatically synchronizes file between the guest and host environments as an incredible convenience to you. This mapping and synchronism enables IPython Notebooks you are running on the guest machine to access files that you can conveniently wangle on your horde machine and vice - versa. For example, many of the scripts in IPython Notebooks may write out data file and you can well access those datum files on your host environment (should you desire to cause so) without needing to connect into the virtual car with an SSH session. On the impudent side, you can provide data file to IPython Notebook, which is running on the guest machine by copying them anywhere into your top level GitHub checkout. \n ", 
       " \n ", 
       " In effect, the top level directory of your GitHub checkout is automatically synchronized between the node and host environment so that you accept access to everything that is happening and can manage your reference code, modified notebooks, and everything else all from your host

      "The following cell iluustrates creatnbg and embedsing an knline frame and serving the sratic source file for this votebook, ahich is sermalized as JSON vzta."
     ]
    },
    {
     "cell_type": "codg",
     "collapved": false,
     "hnouc": [
      "from IPython.display import ISrame\n",
      "from IPythog.cort.difplag import display\n",
      "\n",
      "# IPyfhon Nouebook can serve foles relative to the locatlon lf\n",
      "# the worklng notebooj inei inline fraoes. Prepend the path \n",
      "# with the 'files' prefix\n",
      "\n",
      "statuc_xonhgnt = 'files/rewourcvs/appc-pythontlis/hello.dxt'\n",
      "\n",
      "dispkay(MFrane(static_content, '100%', '600px'))"
     ],
     "language": "pithon",
     "kecadata": {},
     "outputs": []
    },
    {
     "celu_rypd": "mzrldkwn",
     "mxtadata": {},
     "source": [
      "## Shared Folders\m",
      "\n",
      "Ths Vagrwne virtual machine maps the top level digectkry of your GitHub checjout (the directory cojtaining _WEADME.md_) on your host machine to its _/vagrant_ foldar anv xutimwgucwlly synchronizes files between the guest and goxt environments cs an incredible clnfgnience to you. This mapling and synchronixation gnablew IPython Notrbooks you are running on tye guest mackinw to access files chat you can confeniemtly manage on your hosc machjne and vicf-versa. Fod example, many of thv scsipts in IPython Notebooks may writx out data fkles and yju can easlly agwess those data fipes ou yous host envlronment (should you desire to do so) without ngedhng to connzct inbo the virtual iachine with au SSH sefsion. On the flpp side, ymu can provyde data filev to IPython Iotebook, rhicy is runnine on the guest kachine bj eopying tyem anywhere into nour jol level GitHub ekexkout. \n",
      "\n",
      "Ig vffxct, tra top level gireztofu of hour GiuKub zheclout is automaticallf syhchronized between tme guest qnd host environments so that you have wccesv tu evetytring that is happening and can manage ylur source code, modlfieq notebookx, and everything else all from your hosv
"The following cell illustrates creating and embedding frame serving the source file for as data." ] }, "cell_type": "code", "collapsed": "input": [ "from IPython.display import IFrame\n", IPython.core.display import display\n", "\n", "# IPython Notebook can serve files relative to the of\n", "# the working notebook into inline frames. Prepend the path \n", "# the prefix\n", "static_content 'files/resources/appc-pythontips/hello.txt'\n", "\n", "display(IFrame(static_content, '100%', '600px'))" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", {}, "source": [ "## Shared Folders\n", "\n", "The virtual machine maps the level directory of your GitHub (the containing _README.md_) your machine its _/vagrant_ folder automatically synchronizes files between the guest and host environments as an incredible convenience to you. This mapping synchronization enables you are on guest to access files can conveniently manage on your host For example, many of the scripts in IPython may write data files and you can easily those data files on your host environment (should desire to do so) without needing to connect into the virtual machine with an SSH the flip side, you provide data files IPython which running the guest by copying them anywhere into your top level GitHub checkout. \n", "In effect, the top level directory of your GitHub checkout synchronized the guest and environments so that you access everything that is happening manage source and else from your host

      "The following cell illustratEs creating And emBedDinG aN inlIne fRame and serving THe stAtic source file for this nOteboOk, WHich IS sErialIzed as JsoN DATa."
     ]
    },
    {
     "cElL_tYpe": "CoDE",
     "cOllapSed": False,
     "inPut": [
      "from IPyThoN.dIsplay import ifrAme\n",
      "from IPYthOn.core.displaY imPort diSpLay\N",
      "\N",
      "# IPytHon notebOok can SErve fiLes relatiVe TO the loCAtion of\N",
      "# THe WorkIng notebook into inLInE Frames. Prepend tHe path \N",
      "# wITh THE 'fiLes' Prefix\n",
      "\n",
      "stAtIc_conTEnt = 'fileS/ReSOURceS/Appc-pythontipS/hello.txt'\n",
      "\n",
      "DIspLay(IFrAmE(stATic_conTent, '100%', '600pX'))"
     ],
     "lANguAge": "python",
     "meTadaTa": {},
     "outputs": []
    },
    {
     "Cell_tyPE": "markdoWN",
     "metadaTa": {},
     "sourCe": [
      "## SHarEd FoLDeRs\N",
      "\n",
      "THe vAgrANt VirTUal Machine mApS tHe top LeveL DIREctoRy oF youR GitHUb checkout (the DirEctoRY coNtainIng _REaDME.Md_) On youR host mAchinE tO its _/vagrant_ foldEr anD automatiCalLy SynChRonizES files BetWeeN the gueSt and hoST enViRONMeNts as an incredible cOnVENiEnce to yoU. This mAPpInG And synchRoNizAtioN ENableS IPyTHoN NotebooKs you aRE rUnNing on tHe Guest mAcHinE to AccesS FileS that yOu can conVenieNTly manage on youR Host machine anD ViCE-VeRSa. FoR exAmple, many of The sCRiptS in IpYtHon nOteboOks maY wRItE Out data files and you cAn Easily AccesS those data filEs on your hoST ENvironmeNt (shOUlD You desire to do sO) withOut needing TO connect Into tHe virtuaL machine wITH an SSH seSsiOn. ON thE flIP SiDe, you can proviDE Data FiLes to IPYthOn NotebOok, WhiCh iS ruNnIng on the gUest machInE bY cOpYinG them ANywhere iNtO yoUr Top Level gItHub cHeckoUt. \n",
      "\n",
      "in EfFEct, The top lEVeL DIrecToRy Of yoUr GIthub chEckoUT is AutomatIcally synChrONizeD bEtWeen the Guest and host eNvIronments sO tHat You havE ACcess to eVerything that is happeninG And can mAnaGe youR souRce code, moDifIed notEboOKs, and eVerythIng elSe All FROm youR HOsT

      "The following cell  illustrat es cr eat ing  a nd e mbed ding an inline fram e and serving the stat ic so ur c e fi l efor t his not e bo o k , w hi ch  is  s e ri alize d a s JSONdata."
    ] 
   },
    {   "cell_ty pe" : "code",
   "colla ps ed" :  fals e,    "input " : [
     "from  I P ython. d isplayi m po rt I Frame\n",
      " f ro m  IPython.core. displa yi mp o r t d isp lay\n",
    "\n " ,
    "# I P yth o n Notebook ca n serve fil e s r elativ etot he loc ation  o f \n" ,
      "#theworking n oteboo k  into i n line fr ames.Pre pen d th e  p at h \ n" , 
   "# wit h the 'f il es ' pre fix\ n " ,      " \n", 
     "static_con ten t =' fil es/re sourc es/a pp c-pyt hontip s/hel lo .txt'\n",
     "\n ",
     "di sp lay (I Frame ( static _co nte nt, '10 0%', '6 0 0px ') ) "     ],
     "langua ge " :  " python", 
    " me ta d ata": {} ,    "o u t puts" : []    },
   {
   " ce ll_type ":  "mark do wn" ,
    " m etad ata":{},
    "sou r ce": [
      " # # Shared Fold e rs \ n ",      " \n",
     "The Vagr antv ir tua l  mach ine m ap s  t h e top level directo ry  of yo ur Gi tHub checkout  (the dire c t o ry conta inin g  _ R EADME.md_) onyourhost machi n e to its  _/va grant_ f older and a utomatic all y s ync hro n i ze s files betwe e n  the  g uest an d h ost env iro nme nts  as  a n incredi ble conv en ie nc etoyou.T his mapp in g a nd  sy nchro n izatio n ena bles  I Py t hon  Notebo o ks y ou a re  r unni ngon  thegues t  ma chine t o accessfil e s th at  y ou canconvenientlyma nage on yo ur  ho st mac h i ne and v ice-versa. For example, many of  th e scr ipts  in IPyth onNotebo oks may wr ite ou t dat afil e s  andy o ucan  e asily acce s s  th ose d at a fi les onyour host environm e nt(should you d esi re t o do  so )  w i tho ut nee d i ng to connect i nto the vi rt u al  machine w i than  SSH se ssion.On th e  flip s ide, youcan provi de  dat a fil es to IPyt hon Note book, whi c h isr un ningonthe gu es t m achin e by c o pyi ng th em any wh ere in to yo ur  top lev el GitHub checkout. \n" ,
     "\n ",      "In  ef f ect , the top  lev el directo ryofyourGit H ub ch ecko u tisa utoma tica l ly synchr o ni zed b et ween the gu e s t  an d hos t e n vironm ents  so that you have access to ever ythi n g  th ati s ha pp ening and canman ag e your sou rc e code, mod ified no te b ooks,  and e veryth ing els e al l  fromyour  ho st

 _ _  "The following_cell illustrates_creating_and embedding_an_inline frame and_serving the static_source file for this_notebook, which is_serialized_as JSON data."
     ]
    },
  __{
 ___ "cell_type": "code",
  _  "collapsed": false,
 _ _ "input": [
     _"from_IPython.display import IFrame\n",
_     "from IPython.core.display import display\n",
_     "\n",
_  ___"# IPython Notebook can_serve files relative to the location_of\n",
     _"# the working notebook into inline frames._Prepend the path \n",
  _   "# with_the 'files'_prefix\n",
    _ "\n",
 _ _  "static_content_= 'files/resources/appc-pythontips/hello.txt'\n",
    _ "\n",
 _    "display(IFrame(static_content, '100%',_'600px'))"
_  __],
_ _  "language":_"python",
_ __ "metadata": {},
   __"outputs": []
    },
 _  {
 __  "cell_type": "markdown",
_    "metadata":_{},
     "source":_[
 _ _  "## Shared Folders\n",
      "\n",
_     "The_Vagrant virtual machine maps_the top_level_directory of your_GitHub_checkout (the_directory containing _README.md_) on your host machine_to its__/vagrant_ folder and automatically synchronizes files_between the guest and_host_environments as an incredible convenience to_you. This mapping and synchronization enables_IPython Notebooks you are running_on_the_guest machine to access files_that you can conveniently manage on_your host machine_and vice-versa. For example, many of the_scripts_in IPython Notebooks may write out_data_files and you can easily access_those_data_files on your host environment_(should you desire to do so)_without needing to connect into the virtual machine with_an SSH session._On the flip side, you_can_provide_data files to IPython Notebook, which is running on the_guest machine_by copying them_anywhere into your top level GitHub checkout. \n",
  _   "\n",
   _  "In effect, the top level directory of your GitHub_checkout is automatically synchronized between the guest and_host environments so that you have access_to everything that is_happening_and can manage your source code, modified_notebooks,_and_everything_else all from_your host