<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/"><channel><title>Python 101 for network engineers · Network Doodles</title><link>https://networkdoodles.com/labs/python-101/</link><description>Write Python that turns show output into data, then point it at real devices: Netmiko over SSH, TextFSM and ntc-templates, YAML and a REST API, and a script that inventories every device to CSV. Three CapeOS routers, a switch and an inventory API, in your browser, nothing to install.</description><language>en-us</language><managingEditor>David Henderson</managingEditor><lastBuildDate>Mon, 16 Nov 2026 09:00:00 -0500</lastBuildDate><atom:link href="https://networkdoodles.com/labs/python-101/index.xml" rel="self" type="application/rss+xml"/><item><title>Two options, two sources, one CSV</title><link>https://networkdoodles.com/labs/python-101/task-8-3/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-8-3/</guid><description> new to this? step by stepbeginner Try argparse in the REPL with a parser of your own (the follow-along). In scripts/inventory.py, write parse_args() (TODO 8.3) with argparse.ArgumentParser and two add_argument() calls. python scripts/inventory.py --help, then --source api --out reports/from-api.csv, and diff the two CSVs. make check T=8.3. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>Try argparse in the REPL with a parser of your own (the follow-along).</li>
<li>In <code>scripts/inventory.py</code>, write <code>parse_args()</code> (TODO 8.3) with <code>argparse.ArgumentParser</code> and two <code>add_argument()</code> calls.</li>
<li><code>python scripts/inventory.py --help</code>, then <code>--source api --out reports/from-api.csv</code>, and <code>diff</code> the two CSVs.</li>
<li><code>make check T=8.3</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>A command line, not an edit</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="options-instead-of-editing-the-script">Options instead of editing the script</h3>
<p>Right now, to read the API instead of the YAML, you&rsquo;d have to change the code. A tool other people run takes
<strong>options</strong> on its command line instead, like every command you&rsquo;ve used in a terminal: <code>ls -l</code>,
<code>ping -c 3</code>. <code>main()</code> already reads <code>args.source</code> and <code>args.out</code>. Your job is the function that fills them in.</p>
<h3 id="what-argparse-does">What argparse does</h3>
<p><code>argparse</code>, in the standard library, reads the words after the script&rsquo;s name (<code>sys.argv</code>), checks them
against the options you describe, and returns a <code>Namespace</code>: an object with one attribute per option.</p>
<table>
  <thead>
      <tr>
          <th>You write</th>
          <th>You get</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>ArgumentParser(description=...)</code></td>
          <td>the parser, and the first line of <code>--help</code></td>
      </tr>
      <tr>
          <td><code>add_argument(&quot;--name&quot;, default=...)</code></td>
          <td><code>args.name</code>, set to the default when the option isn&rsquo;t given</td>
      </tr>
      <tr>
          <td><code>choices=[...]</code></td>
          <td>anything else refused, with a usage line and exit code 2</td>
      </tr>
      <tr>
          <td><code>help=&quot;...&quot;</code></td>
          <td>that option&rsquo;s line in <code>--help</code></td>
      </tr>
  </tbody>
</table>
<p><code>--help</code> (and <code>-h</code>) is added for you. So are the error messages: a value not in <code>choices</code>, an option with its
value missing, or an option nobody defined all stop the script <strong>before</strong> any device is touched, with exit
code 2. That&rsquo;s the same 2 as task 8.2&rsquo;s partial failure; the message on stderr says which it was.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Describe the options; argparse writes the parsing, the checking, the help and the errors.</p>
<h3 id="why-parse_args-takes-argv">Why parse_args takes argv</h3>
<p><code>parse_args(argv=None)</code> hands <code>argv</code> to the parser&rsquo;s own <code>parse_args()</code>. <code>None</code> means &ldquo;read the real command
line&rdquo;. A list, such as <code>[&quot;--source&quot;, &quot;api&quot;]</code>, means &ldquo;parse this instead&rdquo;, which is how you try it in the REPL
and how the checks test it without a terminal.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>The help argparse writes</h2>
  </header>
  <div class="lab-stage-body">
    <p>Once <code>parse_args()</code> is done, this is all generated from your <code>description</code> and <code>help</code> strings:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/inventory.py --help
</span></span><span class="line"><span class="cl">usage: inventory.py [-h] [--source {yaml,api}] [--out OUT]
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Inventory every lab device to a CSV file.
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">options:
</span></span><span class="line"><span class="cl">  -h, --help           show this help message and exit
</span></span><span class="line"><span class="cl">  --source {yaml,api}  where the device list comes from (default: yaml, the
</span></span><span class="line"><span class="cl">                       file inventory.yml)
</span></span><span class="line"><span class="cl">  --out OUT            the CSV file to write (default: inventory.csv)
</span></span></code></pre></div><p>And a value it doesn&rsquo;t allow:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/inventory.py --source xml
</span></span><span class="line"><span class="cl">usage: inventory.py [-h] [--source {yaml,api}] [--out OUT]
</span></span><span class="line"><span class="cl">inventory.py: error: argument --source: invalid choice: &#39;xml&#39; (choose from &#39;yaml&#39;, &#39;api&#39;)
</span></span><span class="line"><span class="cl">$ echo $?
</span></span><span class="line"><span class="cl">2
</span></span></code></pre></div>
  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>A parser of your own, in the REPL</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Start the REPL, and build a small parser for an imaginary tool that pings one lab device:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">argparse</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">p</span> <span class="o">=</span> <span class="n">argparse</span><span class="o">.</span><span class="n">ArgumentParser</span><span class="p">(</span><span class="n">prog</span><span class="o">=</span><span class="s2">&#34;ping-one&#34;</span><span class="p">,</span> <span class="n">description</span><span class="o">=</span><span class="s2">&#34;Ping one lab device.&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">p</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s2">&#34;--device&#34;</span><span class="p">,</span> <span class="n">choices</span><span class="o">=</span><span class="p">[</span><span class="s2">&#34;r1&#34;</span><span class="p">,</span> <span class="s2">&#34;r2&#34;</span><span class="p">,</span> <span class="s2">&#34;r3&#34;</span><span class="p">,</span> <span class="s2">&#34;sw1&#34;</span><span class="p">],</span> <span class="n">default</span><span class="o">=</span><span class="s2">&#34;r1&#34;</span><span class="p">,</span> <span class="n">help</span><span class="o">=</span><span class="s2">&#34;which device (default: r1)&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">p</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s2">&#34;--count&#34;</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="nb">int</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">help</span><span class="o">=</span><span class="s2">&#34;how many pings (default: 3)&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>Each <code>add_argument()</code> prints a line describing the option it made. You can ignore it. <code>prog</code> sets the
name in the usage line; in a script, argparse takes it from the file&rsquo;s name.</p>
</li>
<li>
<p>Parse an empty command line, then a full one:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">p</span><span class="o">.</span><span class="n">parse_args</span><span class="p">([])</span>
</span></span><span class="line"><span class="cl"><span class="n">Namespace</span><span class="p">(</span><span class="n">device</span><span class="o">=</span><span class="s1">&#39;r1&#39;</span><span class="p">,</span> <span class="n">count</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">args</span> <span class="o">=</span> <span class="n">p</span><span class="o">.</span><span class="n">parse_args</span><span class="p">([</span><span class="s2">&#34;--device&#34;</span><span class="p">,</span> <span class="s2">&#34;r3&#34;</span><span class="p">,</span> <span class="s2">&#34;--count&#34;</span><span class="p">,</span> <span class="s2">&#34;5&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">args</span><span class="o">.</span><span class="n">device</span><span class="p">,</span> <span class="n">args</span><span class="o">.</span><span class="n">count</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="s1">&#39;r3&#39;</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
</span></span></code></pre></div><p><code>count</code> is the number 5, not the text <code>&quot;5&quot;</code>: <code>type=int</code> converted it. Without <code>type</code>, every value is a
string.</p>
</li>
<li>
<p>Print the help:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">p</span><span class="o">.</span><span class="n">print_help</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">usage</span><span class="p">:</span> <span class="n">ping</span><span class="o">-</span><span class="n">one</span> <span class="p">[</span><span class="o">-</span><span class="n">h</span><span class="p">]</span> <span class="p">[</span><span class="o">--</span><span class="n">device</span> <span class="p">{</span><span class="n">r1</span><span class="p">,</span><span class="n">r2</span><span class="p">,</span><span class="n">r3</span><span class="p">,</span><span class="n">sw1</span><span class="p">}]</span> <span class="p">[</span><span class="o">--</span><span class="n">count</span> <span class="n">COUNT</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">Ping</span> <span class="n">one</span> <span class="n">lab</span> <span class="n">device</span><span class="o">.</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">options</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">  <span class="o">-</span><span class="n">h</span><span class="p">,</span> <span class="o">--</span><span class="n">help</span>            <span class="n">show</span> <span class="n">this</span> <span class="n">help</span> <span class="n">message</span> <span class="ow">and</span> <span class="n">exit</span>
</span></span><span class="line"><span class="cl">  <span class="o">--</span><span class="n">device</span> <span class="p">{</span><span class="n">r1</span><span class="p">,</span><span class="n">r2</span><span class="p">,</span><span class="n">r3</span><span class="p">,</span><span class="n">sw1</span><span class="p">}</span>
</span></span><span class="line"><span class="cl">                        <span class="n">which</span> <span class="n">device</span> <span class="p">(</span><span class="n">default</span><span class="p">:</span> <span class="n">r1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="o">--</span><span class="n">count</span> <span class="n">COUNT</span>         <span class="n">how</span> <span class="n">many</span> <span class="n">pings</span> <span class="p">(</span><span class="n">default</span><span class="p">:</span> <span class="mi">3</span><span class="p">)</span>
</span></span></code></pre></div></li>
<li>
<p>Give it a device that isn&rsquo;t in <code>choices</code>. argparse ends the program when it refuses input, so catch that
here to keep the REPL open:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="n">p</span><span class="o">.</span><span class="n">parse_args</span><span class="p">([</span><span class="s2">&#34;--device&#34;</span><span class="p">,</span> <span class="s2">&#34;r7&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span> <span class="k">except</span> <span class="ne">SystemExit</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="nb">print</span><span class="p">(</span><span class="s2">&#34;exit code&#34;</span><span class="p">,</span> <span class="n">e</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="n">usage</span><span class="p">:</span> <span class="n">ping</span><span class="o">-</span><span class="n">one</span> <span class="p">[</span><span class="o">-</span><span class="n">h</span><span class="p">]</span> <span class="p">[</span><span class="o">--</span><span class="n">device</span> <span class="p">{</span><span class="n">r1</span><span class="p">,</span><span class="n">r2</span><span class="p">,</span><span class="n">r3</span><span class="p">,</span><span class="n">sw1</span><span class="p">}]</span> <span class="p">[</span><span class="o">--</span><span class="n">count</span> <span class="n">COUNT</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">ping</span><span class="o">-</span><span class="n">one</span><span class="p">:</span> <span class="n">error</span><span class="p">:</span> <span class="n">argument</span> <span class="o">--</span><span class="n">device</span><span class="p">:</span> <span class="n">invalid</span> <span class="n">choice</span><span class="p">:</span> <span class="s1">&#39;r7&#39;</span> <span class="p">(</span><span class="n">choose</span> <span class="kn">from</span> <span class="s1">&#39;r1&#39;</span><span class="p">,</span> <span class="s1">&#39;r2&#39;</span><span class="p">,</span> <span class="s1">&#39;r3&#39;</span><span class="p">,</span> <span class="s1">&#39;sw1&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">exit</span> <span class="n">code</span> <span class="mi">2</span>
</span></span></code></pre></div><p>In a script you don&rsquo;t catch it: the usage line and exit code 2 are exactly what you want the user to get.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>parse_args()</code> returns a Namespace; on bad input it prints a usage line and exits with code 2.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>&ndash;source and &ndash;out</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>parse_args()</code> in <code>scripts/inventory.py</code>: <code>--source</code>, which is <code>yaml</code> or <code>api</code> and nothing else
(default <code>yaml</code>), and <code>--out</code>, the CSV file to write (default <code>inventory.csv</code>). Give the parser a description
and each option a help line. Then prove the two sources agree:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python scripts/inventory.py --help
</span></span><span class="line"><span class="cl">python scripts/inventory.py
</span></span><span class="line"><span class="cl">python scripts/inventory.py --source api --out reports/from-api.csv
</span></span><span class="line"><span class="cl">diff inventory.csv reports/from-api.csv
</span></span></code></pre></div><p><code>diff</code> prints nothing when two files are the same. (If a minute rolled over between the two runs, the uptime
column differs: run them again. The check ignores uptime for that reason.)</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>p = argparse.ArgumentParser(description=&quot;...&quot;)</code>, two <code>p.add_argument(...)</code> calls, and
<code>return p.parse_args(argv)</code>. Pass <code>argv</code> on: that&rsquo;s what lets the checks hand it a list.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>choices=[&quot;yaml&quot;, &quot;api&quot;]</code> on <code>--source</code> gives you the refusal and exit code 2 for <code>--source xml</code> without
writing an <code>if</code>.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>scripts/inventory.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=8.3</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">parse_args</span><span class="p">(</span><span class="n">argv</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">p</span> <span class="o">=</span> <span class="n">argparse</span><span class="o">.</span><span class="n">ArgumentParser</span><span class="p">(</span><span class="n">description</span><span class="o">=</span><span class="s2">&#34;Inventory every lab device to a CSV file.&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">p</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s2">&#34;--source&#34;</span><span class="p">,</span> <span class="n">choices</span><span class="o">=</span><span class="p">[</span><span class="s2">&#34;yaml&#34;</span><span class="p">,</span> <span class="s2">&#34;api&#34;</span><span class="p">],</span> <span class="n">default</span><span class="o">=</span><span class="s2">&#34;yaml&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                   <span class="n">help</span><span class="o">=</span><span class="s2">&#34;where the device list comes from (default: yaml, the file inventory.yml)&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">p</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s2">&#34;--out&#34;</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="s2">&#34;inventory.csv&#34;</span><span class="p">,</span> <span class="n">help</span><span class="o">=</span><span class="s2">&#34;the CSV file to write (default: inventory.csv)&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">p</span><span class="o">.</span><span class="n">parse_args</span><span class="p">(</span><span class="n">argv</span><span class="p">)</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/inventory.py --source api --out reports/from-api.csv
</span></span><span class="line"><span class="cl">wrote reports/from-api.csv: 4 of 4 devices
</span></span><span class="line"><span class="cl">$ diff inventory.csv reports/from-api.csv
</span></span></code></pre></div><p>The same four rows from either source, because <code>api_to_inventory()</code> in task 7.2 reshaped the API&rsquo;s JSON into
the same five keys as the YAML, and everything after <code>load_devices()</code> works on that list. <code>--out reports/...</code>
works because <code>write_csv()</code> makes the folder. Your help text can say something else: the check looks for
<code>--source</code> and <code>--out</code> in <code>--help</code>, refuses <code>--source xml</code> with exit code 2, and compares the two CSVs.</p>
  </div>
</details>
<p><strong>When the check passes, that&rsquo;s the lab.</strong> You started with <code>len(&quot;GigabitEthernet1&quot;)</code> at the REPL, and
you&rsquo;ve finished with a tool that reads an inventory from a file or an API, logs in to every device over SSH, parses two CLIs into one shape,
writes a CSV, names the devices it couldn&rsquo;t reach, exits with a code a pipeline can trust, and takes its
settings from the command line. On the way you wrote a parser for <code>show ip interface brief</code> by hand and with
a regex, a TextFSM template, a <code>Device</code> dataclass, and functions a test suite you didn&rsquo;t write could call.</p>
<p><code>netlab/</code> is yours. Give <code>inventory.yml</code> other devices, each with its <code>device_type</code>, and their login in
<code>.env</code>, and the same script inventories them. The
<a href="/lessons/python-101/inventory-to-csv/">capstone lesson</a> covers what a framework such as
<a href="https://nornir.readthedocs.io/">Nornir</a> would add next: many devices at once, an inventory system, and a
result for every host.</p>
<p>Where to go from here:</p>
<ul>
<li><a href="/lessons/ansible-101/">Ansible 101</a>: tasks against an inventory without writing the loop. Python 101 is
recommended first.</li>
<li><span class="link-soon">NetBox</span>: the inventory as a source of truth, with a REST API like the lab&rsquo;s. Python 101 is
required for it, and for <span class="link-soon">network testing</span> and <span class="link-soon">ANTA</span>.</li>
</ul>

  </div>
</section>

]]></content:encoded></item><item><title>A router that's down, a router that isn't there</title><link>https://networkdoodles.com/labs/python-101/task-8-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-8-2/</guid><description> new to this? step by stepbeginner make break T=8.2, then python scripts/inventory.py: it stops with a traceback at r2. In netlab/report.py, make run() (TODO 8.2) catch DeviceError for each device, remember the reason, and carry on. Run the script again, then echo $?: it should be 2. make check T=8.2, then make reset. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>make break T=8.2</code>, then <code>python scripts/inventory.py</code>: it stops with a traceback at r2.</li>
<li>In <code>netlab/report.py</code>, make <code>run()</code> (TODO 8.2) catch <code>DeviceError</code> for each device, remember the reason, and carry on.</li>
<li>Run the script again, then <code>echo $?</code>: it should be 2.</li>
<li><code>make check T=8.2</code>, then <code>make reset</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Carry on, and say what you couldn&rsquo;t do</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="one-dead-device-shouldnt-cost-you-the-others">One dead device shouldn&rsquo;t cost you the others</h3>
<p>A real inventory always has a device that&rsquo;s down, being replaced, or listed by mistake. The starter&rsquo;s <code>run()</code>
calls <code>facts()</code> for each device in a plain loop. When one device fails, <code>facts()</code> raises <code>DeviceError</code>,
nothing catches it, and the script stops: no CSV, even for the devices that had already answered, and the
devices after it never tried.</p>
<p>Where you put the <code>try</code> decides what a failure costs. Around the whole loop, the first failure ends the run.
Around one device, inside the loop, it costs that device&rsquo;s row and nothing else.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Put the <code>try</code> around the smallest piece of work you can lose: here, one device.</p>
<h3 id="catch-only-what-you-mean">Catch only what you mean</h3>
<p><code>facts()</code> raises <code>DeviceError</code> on purpose, for the two failures that are the network&rsquo;s fault: the login was
refused, or the device didn&rsquo;t answer. Catch that, by name. A typo in your own code raises something else, a
<code>KeyError</code> or a <code>NameError</code>, and that should still stop the script with a traceback, because it&rsquo;s a bug you
need to see. <code>except Exception:</code> would hide it as one more &ldquo;couldn&rsquo;t inventory&rdquo;.</p>
<h3 id="failures-are-a-result-too">Failures are a result too</h3>
<p><code>run()</code> returns two things, as a tuple: the rows, and a dict of device name to the reason. <code>main()</code> prints
each reason on <strong>stderr</strong>, standard error, and returns an <strong>exit code</strong>: 0 when every device answered, 2 when
some didn&rsquo;t. The shell keeps that number in <code>$?</code>, and anything that runs the script (cron, a CI pipeline,
<code>&amp;&amp;</code> in a shell) reads it to know whether to trust the CSV.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Partial results, a list of what&rsquo;s missing, and an exit code that isn&rsquo;t 0: that&rsquo;s a tool that tells the truth about the network.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>What the break does</h2>
  </header>
  <div class="lab-stage-body">
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ make break T=8.2
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  setting up task 8.2&#39;s problem
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  docker    stop r2   (as if it lost power)
</span></span><span class="line"><span class="cl">  wrote     r9 at the end of inventory.yml: a device that doesn&#39;t exist
</span></span><span class="line"><span class="cl">  api       r9 in the API&#39;s devices too
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  make reset puts everything back.
</span></span></code></pre></div><p>With the starter&rsquo;s <code>run()</code>, the script gets as far as r2:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/inventory.py
</span></span><span class="line"><span class="cl">Traceback (most recent call last):
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/scripts/inventory.py&#34;, line 37, in &lt;module&gt;
</span></span><span class="line"><span class="cl">    sys.exit(main())
</span></span><span class="line"><span class="cl">             ^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/scripts/inventory.py&#34;, line 28, in main
</span></span><span class="line"><span class="cl">    rows, failures = run(devices)
</span></span><span class="line"><span class="cl">                     ^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/netlab/report.py&#34;, line 102, in run
</span></span><span class="line"><span class="cl">    rows.append(facts(d))
</span></span><span class="line"><span class="cl">                ^^^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/netlab/report.py&#34;, line 55, in facts
</span></span><span class="line"><span class="cl">    raise DeviceError(f&#34;{device[&#39;name&#39;]}: no answer from {device[&#39;host&#39;]}&#34;) from None
</span></span><span class="line"><span class="cl">netlab.devices.DeviceError: r2: no answer from 172.80.111.12
</span></span></code></pre></div>
  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Read the traceback, find r9</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Set up the problem, and run the script:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">make <span class="nb">break</span> <span class="nv">T</span><span class="o">=</span>8.2
</span></span><span class="line"><span class="cl">python scripts/inventory.py
</span></span></code></pre></div></li>
<li>
<p>Read the traceback from the bottom up. The last line says <em>what</em>: <code>DeviceError</code>, for r2, which didn&rsquo;t
answer. The lines above say <em>where</em>, innermost last: raised in <code>facts()</code>, called from <code>run()</code>, called from
<code>main()</code>. Nothing in between caught it.</p>
</li>
<li>
<p>Check that no CSV was written for the devices that did answer. r1 came before r2 in the inventory:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">ls inventory.csv
</span></span></code></pre></div><p>If it&rsquo;s there, it&rsquo;s from task 8.1, not from this run: look at its time with <code>ls -l</code>.</p>
</li>
<li>
<p>Look at the end of the inventory, where the break added r9:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">tail -8 inventory.yml
</span></span></code></pre></div><p>r9 is at <code>172.80.111.19</code>, an address nothing on the management network answers. To the script it looks
exactly like r2: a timeout. A device that&rsquo;s in the inventory and was never built is a real and common
problem, and the inventory script is often how you find it.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> The traceback&rsquo;s bottom line names the device; the line above it names the function that raised; the frames above that are who didn&rsquo;t catch it.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>Make run() carry on</h2>
  </header>
  <div class="lab-stage-body">
    <p>Change <code>run()</code> so that it calls <code>facts()</code> for <strong>every</strong> device, keeps the rows of the ones that answered (in
inventory order), and returns a dict of the ones that didn&rsquo;t: device name to the <code>DeviceError</code>&rsquo;s message.
<code>main()</code> does the rest. Then:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python scripts/inventory.py
</span></span><span class="line"><span class="cl"><span class="nb">echo</span> <span class="nv">$?</span>
</span></span></code></pre></div><p>The script should write three of five devices, list r2 and r9 as failures, and print 2.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Move a <code>try:</code> inside the <code>for</code> loop, around the one line that calls <code>facts(d)</code>.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>except DeviceError as e:</code> gives you the exception as <code>e</code>, and <code>str(e)</code> is its message, such as
<code>r2: no answer from 172.80.111.12</code>.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Start with <code>failures = {}</code> next to <code>rows = []</code>, and set <code>failures[d[&quot;name&quot;]]</code> in the <code>except</code>.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/report.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=8.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">run</span><span class="p">(</span><span class="n">devices</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">rows</span><span class="p">,</span> <span class="n">failures</span> <span class="o">=</span> <span class="p">[],</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="n">devices</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">rows</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">facts</span><span class="p">(</span><span class="n">d</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">        <span class="k">except</span> <span class="n">DeviceError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">failures</span><span class="p">[</span><span class="n">d</span><span class="p">[</span><span class="s2">&#34;name&#34;</span><span class="p">]]</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">e</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">rows</span><span class="p">,</span> <span class="n">failures</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ time python scripts/inventory.py
</span></span><span class="line"><span class="cl">wrote inventory.csv: 3 of 5 devices
</span></span><span class="line"><span class="cl">  couldn&#39;t inventory r2: no answer from 172.80.111.12
</span></span><span class="line"><span class="cl">  couldn&#39;t inventory r9: no answer from 172.80.111.19
</span></span><span class="line"><span class="cl">python scripts/inventory.py  0.59s user 0.10s system 6% cpu 11.285 total
</span></span><span class="line"><span class="cl">$ cat inventory.csv
</span></span><span class="line"><span class="cl">hostname,model,version,serial,uptime,ip_interfaces
</span></span><span class="line"><span class="cl">r1,CapeOS-Bolt,0.11.2,CAPEHFI5RPW,0 minutes,5
</span></span><span class="line"><span class="cl">r3,CapeOS-Pulse,4.99.0C,CAPE4S5VG44,0 minutes,4
</span></span><span class="line"><span class="cl">sw1,CapeOS-Bolt,0.11.2,CAPEEXIN1H1,0 minutes,2
</span></span></code></pre></div><p>The <code>try</code> around one call to <code>facts()</code> means a failure costs that device and nothing more: the loop goes on to
the next. Catching <code>DeviceError</code> and not <code>Exception</code> keeps your own bugs visible. The run took about 11
seconds, mostly the two 5-second timeouts, one for r2 and one for r9: the loop waits for each device in turn.</p>
<p>The check runs <code>run()</code> with a device of its own that doesn&rsquo;t exist, then runs the whole script and checks the
CSV, the failures on stderr and the exit code. It passes with the break in place or without it. Afterwards,
put the lab back, because tasks 8.1 and 8.3 need r2:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">make reset
</span></span></code></pre></div>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>Every device, one CSV</title><link>https://networkdoodles.com/labs/python-101/task-8-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-8-1/</guid><description> new to this? step by stepbeginner Starting the lab at chapter 8? make skip CH=8 solves chapters 1 to 7 first: this task calls their functions. In netlab/report.py, write load_devices(), write_csv() and facts() (TODO 8.1a, 8.1c, 8.1b). Try facts() in the REPL on r1. Challenge: make it work on r3 (arista_eos) too. python scripts/inventory.py, cat inventory.csv, then make check T=8.1. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>Starting the lab at chapter 8? <code>make skip CH=8</code> solves chapters 1 to 7 first: this task calls their functions.</li>
<li>In <code>netlab/report.py</code>, write <code>load_devices()</code>, <code>write_csv()</code> and <code>facts()</code> (TODO 8.1a, 8.1c, 8.1b).</li>
<li>Try <code>facts()</code> in the REPL on r1. Challenge: make it work on r3 (<code>arista_eos</code>) too.</li>
<li><code>python scripts/inventory.py</code>, <code>cat inventory.csv</code>, then <code>make check T=8.1</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Inventory in, one function per step, results out</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="the-shape-of-the-tool">The shape of the tool</h3>
<p><code>scripts/inventory.py</code> is given, and its <code>main()</code> is four lines of steps: read the options, load the devices,
get a row from each, write the CSV. The steps are functions in <code>netlab/report.py</code>, and in this task you write
three of them:</p>
<table>
  <thead>
      <tr>
          <th>Function</th>
          <th>Takes</th>
          <th>Gives back</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>load_devices(source)</code></td>
          <td><code>&quot;yaml&quot;</code> or <code>&quot;api&quot;</code></td>
          <td>the inventory: a list of dicts, one per device</td>
      </tr>
      <tr>
          <td><code>facts(device)</code></td>
          <td>one of those dicts</td>
          <td>one row: a dict with the six keys in <code>COLUMNS</code></td>
      </tr>
      <tr>
          <td><code>write_csv(rows, path)</code></td>
          <td>a list of rows, a file name</td>
          <td>nothing: it writes the file</td>
      </tr>
  </tbody>
</table>
<p>Most of the work is already done. Chapter 7 loads the inventory from YAML and from the API, and chapter 6
logs in. The new parts are shaping one row and writing the CSV.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> One function per step means you can try each one in the REPL before the script runs them all.</p>
<h3 id="two-device-types-one-row">Two device types, one row</h3>
<p><code>show version</code>, parsed by ntc-templates, gives each device type different keys. r1, r2 and sw1 are
<code>cisco_ios</code>: the release is <code>version</code>, and the serial is <code>serial</code>, a <strong>list</strong> (a switch stack has one per
member). r3 is <code>arista_eos</code>: the release is <code>image</code>, the serial is <code>serial_number</code>, a string. Only <code>uptime</code> is
the same on both. <strong>Normalizing</strong> is mapping each type&rsquo;s keys onto one set of column names, so the CSV doesn&rsquo;t
care which device a row came from.</p>
<p>Two columns don&rsquo;t come from <code>show version</code> at all. The hostname is <code>conn.base_prompt</code>, which Netmiko works
out from the prompt (<code>r1#</code> gives <code>r1</code>), so it&rsquo;s there on every device. The model is in the template&rsquo;s output,
but empty on these devices, so it comes from the inventory&rsquo;s <code>model</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Pick the column names first, then find where each one is reliable on each device type.</p>
<h3 id="csvdictwriter">csv.DictWriter</h3>
<p><code>csv.DictWriter(f, fieldnames=COLUMNS)</code> writes dicts as CSV rows: <code>writeheader()</code> writes the column names,
<code>writerows(rows)</code> writes every row, each value in the column its key names. A missing key gives an empty
field; a key that isn&rsquo;t in <code>fieldnames</code> raises <code>ValueError</code>. Open the file with <code>newline=&quot;&quot;</code>, as the
<a href="https://docs.python.org/3/library/csv.html">csv documentation</a> asks, because the module writes its own line
endings.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>Two rows, two device types</h2>
  </header>
  <div class="lab-stage-body">
    <p><code>facts()</code> for r1 and for r3, in the REPL (<code>devices</code> is <code>load_devices(&quot;yaml&quot;)</code>):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">facts</span><span class="p">(</span><span class="n">devices</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;hostname&#39;</span><span class="p">:</span> <span class="s1">&#39;r1&#39;</span><span class="p">,</span> <span class="s1">&#39;model&#39;</span><span class="p">:</span> <span class="s1">&#39;CapeOS-Bolt&#39;</span><span class="p">,</span> <span class="s1">&#39;version&#39;</span><span class="p">:</span> <span class="s1">&#39;0.11.2&#39;</span><span class="p">,</span> <span class="s1">&#39;serial&#39;</span><span class="p">:</span> <span class="s1">&#39;CAPEHFI5RPW&#39;</span><span class="p">,</span> <span class="s1">&#39;uptime&#39;</span><span class="p">:</span> <span class="s1">&#39;10 minutes&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_interfaces&#39;</span><span class="p">:</span> <span class="mi">5</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">facts</span><span class="p">(</span><span class="n">devices</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;hostname&#39;</span><span class="p">:</span> <span class="s1">&#39;r3&#39;</span><span class="p">,</span> <span class="s1">&#39;model&#39;</span><span class="p">:</span> <span class="s1">&#39;CapeOS-Pulse&#39;</span><span class="p">,</span> <span class="s1">&#39;version&#39;</span><span class="p">:</span> <span class="s1">&#39;4.99.0C&#39;</span><span class="p">,</span> <span class="s1">&#39;serial&#39;</span><span class="p">:</span> <span class="s1">&#39;CAPE4S5VG44&#39;</span><span class="p">,</span> <span class="s1">&#39;uptime&#39;</span><span class="p">:</span> <span class="s1">&#39;10 minutes&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_interfaces&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">}</span>
</span></span></code></pre></div><p>And the whole script, with the CSV it wrote:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/inventory.py
</span></span><span class="line"><span class="cl">wrote inventory.csv: 4 of 4 devices
</span></span><span class="line"><span class="cl">$ cat inventory.csv
</span></span><span class="line"><span class="cl">hostname,model,version,serial,uptime,ip_interfaces
</span></span><span class="line"><span class="cl">r1,CapeOS-Bolt,0.11.2,CAPEHFI5RPW,0 minutes,5
</span></span><span class="line"><span class="cl">r2,CapeOS-Bolt,0.11.2,CAPED9P9655,0 minutes,5
</span></span><span class="line"><span class="cl">r3,CapeOS-Pulse,4.99.0C,CAPE4S5VG44,0 minutes,4
</span></span><span class="line"><span class="cl">sw1,CapeOS-Bolt,0.11.2,CAPEEXIN1H1,0 minutes,2
</span></span></code></pre></div><p>Your serials are different: the lab makes new ones every time it starts.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Load, write, and a row for r1</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Open <code>netlab/report.py</code>. Each function has a docstring that says what it should do, and a
<code>raise NotImplementedError</code> line where your code goes. Replace that line in each, and keep the docstring.</p>
</li>
<li>
<p><strong>TODO 8.1a.</strong> The inventory, from either source. Chapter 7 wrote both halves:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/report.py</code><span class="lab-file-how">Ctrl+P → report.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">load_devices</span><span class="p">(</span><span class="n">source</span><span class="o">=</span><span class="s2">&#34;yaml&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="n">source</span> <span class="o">==</span> <span class="s2">&#34;api&#34;</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">load_env</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">api_to_inventory</span><span class="p">(</span><span class="n">get_devices</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_API_URL&#34;</span><span class="p">],</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_API_TOKEN&#34;</span><span class="p">]))</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">load_inventory</span><span class="p">(</span><span class="n">ROOT</span> <span class="o">/</span> <span class="s2">&#34;inventory.yml&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p><code>load_env()</code> reads <code>.env</code> into the environment, so <code>LAB_API_URL</code> and <code>LAB_API_TOKEN</code> are there to read.
<code>ROOT</code> is the repository&rsquo;s folder, so the script finds <code>inventory.yml</code> from any folder you run it in.</p>
</li>
<li>
<p><strong>TODO 8.1c.</strong> The CSV:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/report.py</code><span class="lab-file-how">Ctrl+P → report.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">write_csv</span><span class="p">(</span><span class="n">rows</span><span class="p">,</span> <span class="n">path</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">path</span> <span class="o">=</span> <span class="n">pathlib</span><span class="o">.</span><span class="n">Path</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">path</span><span class="o">.</span><span class="n">parent</span><span class="o">.</span><span class="n">mkdir</span><span class="p">(</span><span class="n">parents</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">exist_ok</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">with</span> <span class="n">path</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s2">&#34;w&#34;</span><span class="p">,</span> <span class="n">newline</span><span class="o">=</span><span class="s2">&#34;&#34;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">writer</span> <span class="o">=</span> <span class="n">csv</span><span class="o">.</span><span class="n">DictWriter</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">fieldnames</span><span class="o">=</span><span class="n">COLUMNS</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">writer</span><span class="o">.</span><span class="n">writeheader</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="n">writer</span><span class="o">.</span><span class="n">writerows</span><span class="p">(</span><span class="n">rows</span><span class="p">)</span>
</span></span></code></pre></div><p><code>mkdir(parents=True, exist_ok=True)</code> makes the folder if it isn&rsquo;t there, so <code>--out reports/x.csv</code> works in
task 8.3, and does nothing if it is.</p>
</li>
<li>
<p><strong>TODO 8.1b.</strong> One device&rsquo;s row. First the login, with Netmiko&rsquo;s two exceptions turned into <code>DeviceError</code>
as <code>collect()</code> did in task 6.2. Then the two commands, and <code>disconnect()</code> in a <code>finally:</code> so the SSH
session closes even if a command fails:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/report.py</code><span class="lab-file-how">Ctrl+P → report.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">facts</span><span class="p">(</span><span class="n">device</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">conn</span> <span class="o">=</span> <span class="n">connect</span><span class="p">(</span><span class="n">device</span><span class="p">[</span><span class="s2">&#34;host&#34;</span><span class="p">],</span> <span class="n">device</span><span class="p">[</span><span class="s2">&#34;device_type&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="n">NetmikoAuthenticationException</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="n">DeviceError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">device</span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">: login failed&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="n">NetmikoTimeoutException</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="n">DeviceError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">device</span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">: no answer from </span><span class="si">{</span><span class="n">device</span><span class="p">[</span><span class="s1">&#39;host&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">version</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show version&#34;</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="n">brief</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">hostname</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">base_prompt</span>
</span></span><span class="line"><span class="cl">    <span class="k">finally</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">conn</span><span class="o">.</span><span class="n">disconnect</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="n">release</span><span class="p">,</span> <span class="n">serial</span> <span class="o">=</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;version&#34;</span><span class="p">],</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;serial&#34;</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;hostname&#34;</span><span class="p">:</span> <span class="n">hostname</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;model&#34;</span><span class="p">:</span> <span class="n">device</span><span class="p">[</span><span class="s2">&#34;model&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;version&#34;</span><span class="p">:</span> <span class="n">release</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;serial&#34;</span><span class="p">:</span> <span class="n">serial</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;uptime&#34;</span><span class="p">:</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;uptime&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;ip_interfaces&#34;</span><span class="p">:</span> <span class="nb">sum</span><span class="p">(</span><span class="mi">1</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">brief</span> <span class="k">if</span> <span class="n">i</span><span class="p">[</span><span class="s2">&#34;ip_address&#34;</span><span class="p">]</span> <span class="o">!=</span> <span class="s2">&#34;unassigned&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span></code></pre></div><p><code>[0]</code> after <code>show version</code> takes the one dict out of the list ntc-templates returns. <code>sum(1 for ...)</code> counts
the interfaces that have an address: one for each row that passes the test.</p>
</li>
<li>
<p>Try it on r1, the first device in the inventory. Start the REPL from the repository&rsquo;s folder:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.report</span> <span class="kn">import</span> <span class="n">load_devices</span><span class="p">,</span> <span class="n">facts</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">devices</span> <span class="o">=</span> <span class="n">load_devices</span><span class="p">(</span><span class="s2">&#34;yaml&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">facts</span><span class="p">(</span><span class="n">devices</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
</span></span></code></pre></div><p>You get r1&rsquo;s row, as in the Show stage. If you change <code>report.py</code>, <code>exit()</code> and start the REPL again:
Python reads a module once, when you import it.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>facts()</code> logs in, runs two commands, disconnects, and returns a dict with the same six keys every time.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>The same row from r3</h2>
  </header>
  <div class="lab-stage-body">
    <p><code>devices[2]</code> is r3, on CapeOS Pulse (<code>arista_eos</code>). Call <code>facts(devices[2])</code>: it stops with a <code>KeyError</code>.
Make <code>facts()</code> give r3 a row with the same six keys, then run the whole script and look at the CSV:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python scripts/inventory.py
</span></span><span class="line"><span class="cl">cat inventory.csv
</span></span></code></pre></div><details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Look at what r3&rsquo;s parsed <code>show version</code> has. In the REPL:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.devices</span> <span class="kn">import</span> <span class="n">connect</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span> <span class="o">=</span> <span class="n">connect</span><span class="p">(</span><span class="s2">&#34;172.80.111.13&#34;</span><span class="p">,</span> <span class="s2">&#34;arista_eos&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show version&#34;</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
</span></span></code></pre></div><p>then <code>conn.disconnect()</code>. Which keys hold the release and the serial?</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>The device&rsquo;s own dict says which kind it is: <code>device[&quot;device_type&quot;]</code>. An <code>if</code> on it can pick the keys.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>r3&rsquo;s serial is already a string. Only the <code>cisco_ios</code> one needs <code>[0]</code>.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/report.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=8.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">facts</span><span class="p">(</span><span class="n">device</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">conn</span> <span class="o">=</span> <span class="n">connect</span><span class="p">(</span><span class="n">device</span><span class="p">[</span><span class="s2">&#34;host&#34;</span><span class="p">],</span> <span class="n">device</span><span class="p">[</span><span class="s2">&#34;device_type&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="n">NetmikoAuthenticationException</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="n">DeviceError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">device</span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">: login failed&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="n">NetmikoTimeoutException</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="n">DeviceError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">device</span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">: no answer from </span><span class="si">{</span><span class="n">device</span><span class="p">[</span><span class="s1">&#39;host&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">version</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show version&#34;</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="n">brief</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">hostname</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">base_prompt</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="n">DROPPED</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="n">DeviceError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">device</span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">: the session broke (</span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="n">e</span><span class="p">)</span><span class="o">.</span><span class="vm">__name__</span><span class="si">}</span><span class="s2">)&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">finally</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">conn</span><span class="o">.</span><span class="n">disconnect</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="k">except</span> <span class="n">DROPPED</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">pass</span>                    <span class="c1"># already gone: nothing left to close</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="n">device</span><span class="p">[</span><span class="s2">&#34;device_type&#34;</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;arista_eos&#34;</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">release</span><span class="p">,</span> <span class="n">serial</span> <span class="o">=</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;image&#34;</span><span class="p">],</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;serial_number&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="k">else</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">release</span><span class="p">,</span> <span class="n">serial</span> <span class="o">=</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;version&#34;</span><span class="p">],</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;serial&#34;</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;hostname&#34;</span><span class="p">:</span> <span class="n">hostname</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;model&#34;</span><span class="p">:</span> <span class="n">device</span><span class="p">[</span><span class="s2">&#34;model&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;version&#34;</span><span class="p">:</span> <span class="n">release</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;serial&#34;</span><span class="p">:</span> <span class="n">serial</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;uptime&#34;</span><span class="p">:</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;uptime&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;ip_interfaces&#34;</span><span class="p">:</span> <span class="nb">sum</span><span class="p">(</span><span class="mi">1</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">brief</span> <span class="k">if</span> <span class="n">i</span><span class="p">[</span><span class="s2">&#34;ip_address&#34;</span><span class="p">]</span> <span class="o">!=</span> <span class="s2">&#34;unassigned&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span></code></pre></div><p><code>DROPPED</code>, at the top of <code>report.py</code>, is the lab&rsquo;s list of what Netmiko raises when a device it had
already logged in to drops the session: a read that timed out, an SSH error, a closed socket. Catching it
here means one device that falls over halfway through a command becomes a failure for that device, not the
end of the run (task 8.2 is about that). The <code>try</code> around <code>disconnect()</code> is for the same case: there&rsquo;s nothing
left to close.</p>
<p>This is r3&rsquo;s <code>show version</code> with the <code>cisco_ios</code> key, and then what it does have:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">version</span><span class="p">[</span><span class="s2">&#34;version&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">  <span class="n">File</span> <span class="s2">&#34;&lt;stdin&gt;&#34;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">1</span><span class="p">,</span> <span class="ow">in</span> <span class="o">&lt;</span><span class="n">module</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="ne">KeyError</span><span class="p">:</span> <span class="s1">&#39;version&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">version</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;model&#39;</span><span class="p">:</span> <span class="s1">&#39;&#39;</span><span class="p">,</span> <span class="s1">&#39;hw_version&#39;</span><span class="p">:</span> <span class="s1">&#39;&#39;</span><span class="p">,</span> <span class="s1">&#39;serial_number&#39;</span><span class="p">:</span> <span class="s1">&#39;CAPE4S5VG44&#39;</span><span class="p">,</span> <span class="s1">&#39;sys_mac&#39;</span><span class="p">:</span> <span class="s1">&#39;cae2.b268.c68e&#39;</span><span class="p">,</span> <span class="s1">&#39;image&#39;</span><span class="p">:</span> <span class="s1">&#39;4.99.0C&#39;</span><span class="p">,</span> <span class="s1">&#39;total_memory&#39;</span><span class="p">:</span> <span class="s1">&#39;8025148&#39;</span><span class="p">,</span> <span class="s1">&#39;free_memory&#39;</span><span class="p">:</span> <span class="s1">&#39;5733076&#39;</span><span class="p">,</span> <span class="s1">&#39;uptime&#39;</span><span class="p">:</span> <span class="s1">&#39;15 minutes&#39;</span><span class="p">}</span>
</span></span></code></pre></div><p>The <code>if</code> is on the inventory&rsquo;s <code>device_type</code>, the same field that told Netmiko which CLI to expect, so one
field picks both the dialect and the keys. The mapping lives in one place: a third device type later is one
more <code>elif</code>, and nothing after <code>facts()</code> changes. <code>ip_interfaces</code> needs no <code>if</code>, because both templates call
the address <code>ip_address</code> (r3&rsquo;s includes the prefix, <code>10.0.13.2/30</code>, which is still not <code>unassigned</code>).</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>The same inventory from an API</title><link>https://networkdoodles.com/labs/python-101/task-7-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-7-2/</guid><description> new to this? step by stepbeginner curl -i http://api:8000/api/devices/: a 403, because there’s no token. In the REPL, requests.get() the same URL with the Authorization header and timeout=5; look at .status_code and .json(). Challenge: get_devices() (TODO 7.2a) with raise_for_status() and an ApiError, and api_to_inventory() (TODO 7.2b). make check T=7.2. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>curl -i http://api:8000/api/devices/</code>: a 403, because there&rsquo;s no token.</li>
<li>In the REPL, <code>requests.get()</code> the same URL with the <code>Authorization</code> header and <code>timeout=5</code>; look at <code>.status_code</code> and <code>.json()</code>.</li>
<li>Challenge: <code>get_devices()</code> (TODO 7.2a) with <code>raise_for_status()</code> and an <code>ApiError</code>, and <code>api_to_inventory()</code> (TODO 7.2b).</li>
<li><code>make check T=7.2</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Asking a server instead of a file</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="a-get-request">A GET request</h3>
<p>A <strong>REST API</strong> holds data at URLs, and you ask for it over HTTP. <code>GET</code> means <em>read</em>. The answer has a
<strong>status code</strong> (200 for OK, 403 for Forbidden, 404 for Not Found), <strong>headers</strong>, and a body, here in JSON.
In Python, <code>requests.get(url, headers={...}, timeout=5)</code> sends the request and returns a <strong>response object</strong>:
<code>r.status_code</code> is the code, <code>r.json()</code> parses the body.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>requests.get()</code> asks; <code>r.status_code</code> says how it went; <code>r.json()</code> is the data.</p>
<h3 id="the-token">The token</h3>
<p>The lab&rsquo;s API, like NetBox, wants a <strong>token</strong> in a header: <code>Authorization: Token &lt;token&gt;</code>. A token is a
password for a program, so it lives in <code>.env</code>, not in the code. Your function gets it as an argument.</p>
<h3 id="an-error-status-isnt-an-exception">An error status isn&rsquo;t an exception</h3>
<p>A wrong token gets an answer: 403, and a JSON body that says why. requests doesn&rsquo;t raise for that. Your code
has to look, and <code>r.raise_for_status()</code> does it for you: it raises <code>requests.HTTPError</code> for any 4xx or 5xx
status. A server that doesn&rsquo;t answer at all raises <code>requests.ConnectionError</code> (or <code>Timeout</code>); all of them are
<code>requests.RequestException</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Call <code>raise_for_status()</code> before you trust the body.</p>
<h3 id="nested-json">Nested JSON</h3>
<p>The API answers the way NetBox does: a device&rsquo;s role is <code>{&quot;name&quot;: &quot;Router&quot;, &quot;slug&quot;: &quot;router&quot;}</code>, not
<code>&quot;router&quot;</code>, and its address is inside <code>primary_ip</code>. To compare with <code>inventory.yml</code>, you reshape each device
into the same five flat keys.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>200, 403, and r1 as the API sees it</h2>
  </header>
  <div class="lab-stage-body">
    <p>With the token:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">r</span> <span class="o">=</span> <span class="n">requests</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;http://api:8000/api/devices/&#34;</span><span class="p">,</span> <span class="n">headers</span><span class="o">=</span><span class="p">{</span><span class="s2">&#34;Authorization&#34;</span><span class="p">:</span> <span class="s2">&#34;Token 0123456789abcdef0123456789abcdef01234567&#34;</span><span class="p">},</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">r</span>
</span></span><span class="line"><span class="cl"><span class="o">&lt;</span><span class="n">Response</span> <span class="p">[</span><span class="mi">200</span><span class="p">]</span><span class="o">&gt;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">data</span> <span class="o">=</span> <span class="n">r</span><span class="o">.</span><span class="n">json</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">data</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">dict_keys</span><span class="p">([</span><span class="s1">&#39;count&#39;</span><span class="p">,</span> <span class="s1">&#39;next&#39;</span><span class="p">,</span> <span class="s1">&#39;previous&#39;</span><span class="p">,</span> <span class="s1">&#39;results&#39;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">data</span><span class="p">[</span><span class="s2">&#34;count&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="mi">4</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">data</span><span class="p">[</span><span class="s2">&#34;results&#34;</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;id&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;url&#39;</span><span class="p">:</span> <span class="s1">&#39;http://api:8000/api/devices/1/&#39;</span><span class="p">,</span> <span class="s1">&#39;name&#39;</span><span class="p">:</span> <span class="s1">&#39;r1&#39;</span><span class="p">,</span> <span class="s1">&#39;device_type&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;model&#39;</span><span class="p">:</span> <span class="s1">&#39;CapeOS-Bolt&#39;</span><span class="p">,</span> <span class="s1">&#39;manufacturer&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;name&#39;</span><span class="p">:</span> <span class="s1">&#39;Network Doodles&#39;</span><span class="p">,</span> <span class="s1">&#39;slug&#39;</span><span class="p">:</span> <span class="s1">&#39;network-doodles&#39;</span><span class="p">}},</span> <span class="s1">&#39;role&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;name&#39;</span><span class="p">:</span> <span class="s1">&#39;Router&#39;</span><span class="p">,</span> <span class="s1">&#39;slug&#39;</span><span class="p">:</span> <span class="s1">&#39;router&#39;</span><span class="p">},</span> <span class="s1">&#39;platform&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;name&#39;</span><span class="p">:</span> <span class="s1">&#39;cisco_ios&#39;</span><span class="p">,</span> <span class="s1">&#39;slug&#39;</span><span class="p">:</span> <span class="s1">&#39;cisco_ios&#39;</span><span class="p">},</span> <span class="s1">&#39;serial&#39;</span><span class="p">:</span> <span class="s1">&#39;&#39;</span><span class="p">,</span> <span class="s1">&#39;site&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;name&#39;</span><span class="p">:</span> <span class="s1">&#39;LAB&#39;</span><span class="p">,</span> <span class="s1">&#39;slug&#39;</span><span class="p">:</span> <span class="s1">&#39;lab&#39;</span><span class="p">},</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;value&#39;</span><span class="p">:</span> <span class="s1">&#39;active&#39;</span><span class="p">,</span> <span class="s1">&#39;label&#39;</span><span class="p">:</span> <span class="s1">&#39;Active&#39;</span><span class="p">},</span> <span class="s1">&#39;primary_ip&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;address&#39;</span><span class="p">:</span> <span class="s1">&#39;172.80.111.11/24&#39;</span><span class="p">,</span> <span class="s1">&#39;family&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;value&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s1">&#39;label&#39;</span><span class="p">:</span> <span class="s1">&#39;IPv4&#39;</span><span class="p">}}}</span>
</span></span></code></pre></div><p>With a wrong one:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">bad</span> <span class="o">=</span> <span class="n">requests</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;http://api:8000/api/devices/&#34;</span><span class="p">,</span> <span class="n">headers</span><span class="o">=</span><span class="p">{</span><span class="s2">&#34;Authorization&#34;</span><span class="p">:</span> <span class="s2">&#34;Token nope&#34;</span><span class="p">},</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">bad</span><span class="o">.</span><span class="n">status_code</span><span class="p">,</span> <span class="n">bad</span><span class="o">.</span><span class="n">json</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="mi">403</span><span class="p">,</span> <span class="p">{</span><span class="s1">&#39;detail&#39;</span><span class="p">:</span> <span class="s1">&#39;Invalid token&#39;</span><span class="p">})</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">bad</span><span class="o">.</span><span class="n">raise_for_status</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">  <span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="n">requests</span><span class="o">.</span><span class="n">exceptions</span><span class="o">.</span><span class="n">HTTPError</span><span class="p">:</span> <span class="mi">403</span> <span class="n">Client</span> <span class="n">Error</span><span class="p">:</span> <span class="n">Forbidden</span> <span class="k">for</span> <span class="n">url</span><span class="p">:</span> <span class="n">http</span><span class="p">:</span><span class="o">//</span><span class="n">api</span><span class="p">:</span><span class="mi">8000</span><span class="o">/</span><span class="n">api</span><span class="o">/</span><span class="n">devices</span><span class="o">/</span>
</span></span></code></pre></div><p>And what the check reports for a <code>get_devices()</code> that skips the status and goes straight for <code>results</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">________________________________ test_bad_token ________________________________
</span></span><span class="line"><span class="cl">checks/test_7_2.py:29: in test_bad_token
</span></span><span class="line"><span class="cl">    call(get_devices, env[&#34;LAB_API_URL&#34;], &#34;not-the-token&#34;)
</span></span><span class="line"><span class="cl">checks/conftest.py:20: in call
</span></span><span class="line"><span class="cl">    return func(*args, **kwargs)
</span></span><span class="line"><span class="cl">           ^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">netlab/inventory.py:47: in get_devices
</span></span><span class="line"><span class="cl">    return r.json()[&#34;results&#34;]
</span></span><span class="line"><span class="cl">           ^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">E   KeyError: &#39;results&#39;
</span></span></code></pre></div><p>A <code>KeyError</code> about <code>results</code>, when the real problem was the token.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Your first request</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Ask the API with <code>curl</code>, without a token, and look at the status line:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">curl -i http://api:8000/api/devices/1/
</span></span></code></pre></div><p><code>HTTP/1.0 403 Forbidden</code>, and a body saying <em>Authentication credentials were not provided.</em></p>
</li>
<li>
<p>Now from Python, with the token read from <code>.env</code>, the way your code will get it:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">os</span><span class="o">,</span> <span class="nn">requests</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.env</span> <span class="kn">import</span> <span class="n">load_env</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">load_env</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">h</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&#34;Authorization&#34;</span><span class="p">:</span> <span class="sa">f</span><span class="s2">&#34;Token </span><span class="si">{</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s1">&#39;LAB_API_TOKEN&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">page</span> <span class="o">=</span> <span class="n">requests</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;http://api:8000/api/devices/&#34;</span><span class="p">,</span> <span class="n">headers</span><span class="o">=</span><span class="n">h</span><span class="p">,</span> <span class="n">params</span><span class="o">=</span><span class="p">{</span><span class="s2">&#34;limit&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">},</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span><span class="o">.</span><span class="n">json</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">page</span><span class="p">[</span><span class="s2">&#34;count&#34;</span><span class="p">],</span> <span class="n">page</span><span class="p">[</span><span class="s2">&#34;next&#34;</span><span class="p">],</span> <span class="n">page</span><span class="p">[</span><span class="s2">&#34;previous&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="s1">&#39;http://api:8000/api/devices/?limit=2&amp;offset=2&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="p">[</span><span class="n">d</span><span class="p">[</span><span class="s2">&#34;name&#34;</span><span class="p">]</span> <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="n">page</span><span class="p">[</span><span class="s2">&#34;results&#34;</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;r1&#39;</span><span class="p">,</span> <span class="s1">&#39;r2&#39;</span><span class="p">]</span>
</span></span></code></pre></div><p><code>params=</code> adds <code>?limit=2</code> to the URL. Two devices to a page, <code>count</code> says there are four, and <code>next</code> is
the URL of the second page. Without <code>limit</code>, a page holds 50, so the lab&rsquo;s four devices arrive in one.</p>
</li>
<li>
<p>Try a device that doesn&rsquo;t exist, and a method the API doesn&rsquo;t allow:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">requests</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;http://api:8000/api/devices/99/&#34;</span><span class="p">,</span> <span class="n">headers</span><span class="o">=</span><span class="n">h</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span><span class="o">.</span><span class="n">status_code</span>
</span></span><span class="line"><span class="cl"><span class="mi">404</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">requests</span><span class="o">.</span><span class="n">post</span><span class="p">(</span><span class="s2">&#34;http://api:8000/api/devices/&#34;</span><span class="p">,</span> <span class="n">headers</span><span class="o">=</span><span class="n">h</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span><span class="o">.</span><span class="n">status_code</span>
</span></span><span class="line"><span class="cl"><span class="mi">405</span>
</span></span></code></pre></div></li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> Every answer has a status code; only 2xx means the body is the data you asked for.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>get_devices() and api_to_inventory()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write the two functions in <code>netlab/inventory.py</code>:</p>
<ul>
<li><code>get_devices(base_url, token)</code> (TODO 7.2a): <code>GET &lt;base_url&gt;/api/devices/</code> with the token header and a
5-second timeout, and return the JSON&rsquo;s <code>results</code> list as it is. For an error status, raise <code>ApiError</code> with
one line that includes the status code (the check looks for <code>403</code>). For no answer at all, raise <code>ApiError</code>
too.</li>
<li><code>api_to_inventory(results)</code> (TODO 7.2b): each API device as the five keys of <code>inventory.yml</code>.</li>
</ul>
<p>When they work, this is <code>True</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">api_to_inventory</span><span class="p">(</span><span class="n">get_devices</span><span class="p">(</span><span class="s2">&#34;http://api:8000&#34;</span><span class="p">,</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_API_TOKEN&#34;</span><span class="p">]))</span> <span class="o">==</span> <span class="n">load_inventory</span><span class="p">(</span><span class="s2">&#34;inventory.yml&#34;</span><span class="p">)</span>
</span></span></code></pre></div><details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Put <code>requests.get(...)</code> and <code>r.raise_for_status()</code> together in one <code>try:</code>. Then <code>except requests.HTTPError:</code>
first, because it&rsquo;s the more specific one, and <code>except requests.RequestException</code> after it, for everything
else.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>In the <code>HTTPError</code> branch, <code>r</code> exists: use <code>r.status_code</code>, and the API&rsquo;s own reason from <code>r.json()[&quot;detail&quot;]</code>.
In the other branch there&rsquo;s no response, only the exception: <code>type(e).__name__</code> names what went wrong.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>For the reshape, the docstring has the map: <code>primary_ip.address</code> without its prefix (<code>split(&quot;/&quot;)[0]</code>),
<code>platform.slug</code>, <code>role.slug</code>, <code>device_type.model</code>. Each <code>a.b</code> is <code>d[&quot;a&quot;][&quot;b&quot;]</code>.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/inventory.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=7.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">get_devices</span><span class="p">(</span><span class="n">base_url</span><span class="p">,</span> <span class="n">token</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">r</span> <span class="o">=</span> <span class="n">requests</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">base_url</span><span class="si">}</span><span class="s2">/api/devices/&#34;</span><span class="p">,</span> <span class="n">headers</span><span class="o">=</span><span class="p">{</span><span class="s2">&#34;Authorization&#34;</span><span class="p">:</span> <span class="sa">f</span><span class="s2">&#34;Token </span><span class="si">{</span><span class="n">token</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">},</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">r</span><span class="o">.</span><span class="n">raise_for_status</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="n">requests</span><span class="o">.</span><span class="n">HTTPError</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">detail</span> <span class="o">=</span> <span class="n">r</span><span class="o">.</span><span class="n">json</span><span class="p">()</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;detail&#34;</span><span class="p">,</span> <span class="n">r</span><span class="o">.</span><span class="n">reason</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>          <span class="c1"># an error page that isn&#39;t JSON, from a proxy or a web server</span>
</span></span><span class="line"><span class="cl">            <span class="n">detail</span> <span class="o">=</span> <span class="n">r</span><span class="o">.</span><span class="n">reason</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="n">ApiError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;the API answered </span><span class="si">{</span><span class="n">r</span><span class="o">.</span><span class="n">status_code</span><span class="si">}</span><span class="s2">: </span><span class="si">{</span><span class="n">detail</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">except</span> <span class="n">requests</span><span class="o">.</span><span class="n">RequestException</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">raise</span> <span class="n">ApiError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;no answer from the API at </span><span class="si">{</span><span class="n">base_url</span><span class="si">}</span><span class="s2">: </span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="n">e</span><span class="p">)</span><span class="o">.</span><span class="vm">__name__</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">r</span><span class="o">.</span><span class="n">json</span><span class="p">()[</span><span class="s2">&#34;results&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">api_to_inventory</span><span class="p">(</span><span class="n">results</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">devices</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="n">results</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">devices</span><span class="o">.</span><span class="n">append</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;name&#34;</span><span class="p">:</span> <span class="n">d</span><span class="p">[</span><span class="s2">&#34;name&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;host&#34;</span><span class="p">:</span> <span class="n">d</span><span class="p">[</span><span class="s2">&#34;primary_ip&#34;</span><span class="p">][</span><span class="s2">&#34;address&#34;</span><span class="p">]</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s2">&#34;/&#34;</span><span class="p">)[</span><span class="mi">0</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;device_type&#34;</span><span class="p">:</span> <span class="n">d</span><span class="p">[</span><span class="s2">&#34;platform&#34;</span><span class="p">][</span><span class="s2">&#34;slug&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;role&#34;</span><span class="p">:</span> <span class="n">d</span><span class="p">[</span><span class="s2">&#34;role&#34;</span><span class="p">][</span><span class="s2">&#34;slug&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;model&#34;</span><span class="p">:</span> <span class="n">d</span><span class="p">[</span><span class="s2">&#34;device_type&#34;</span><span class="p">][</span><span class="s2">&#34;model&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">devices</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">&gt;&gt;&gt; get_devices(&#34;http://api:8000&#34;, &#34;nope&#34;)
</span></span><span class="line"><span class="cl">Traceback (most recent call last):
</span></span><span class="line"><span class="cl">  File &#34;&lt;stdin&gt;&#34;, line 1, in &lt;module&gt;
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/netlab/inventory.py&#34;, line 59, in get_devices
</span></span><span class="line"><span class="cl">    raise ApiError(f&#34;the API answered {r.status_code}: {detail}&#34;) from None
</span></span><span class="line"><span class="cl">netlab.inventory.ApiError: the API answered 403: Invalid token
</span></span></code></pre></div><p>The order of the <code>except</code>s matters: <code>HTTPError</code> is itself a <code>RequestException</code>, so with the general one first,
a 403 would be reported as <em>no answer</em>. <code>.get(&quot;detail&quot;, r.reason)</code> falls back to the status&rsquo;s own name
(<code>Forbidden</code>) for an answer without a <code>detail</code>, and the inner <code>try</code> does the same for an error page that
isn&rsquo;t JSON at all, the kind a proxy in front of an API sends (the check serves one). Note the two meanings of <code>device_type</code>: in the API it&rsquo;s the
hardware model, as in NetBox; in the inventory it&rsquo;s Netmiko&rsquo;s name for the CLI, which NetBox calls the
platform.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>The inventory in YAML and JSON</title><link>https://networkdoodles.com/labs/python-101/task-7-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-7-1/</guid><description> new to this? step by stepbeginner cat inventory.yml, then in the REPL: import yaml, doc = yaml.safe_load(open("inventory.yml")), doc["devices"][0]. Write load_inventory() (TODO 7.1a), save_json() (7.1b) and load_json() (7.1c), each with a with open(...). Challenge (TODO 7.1d): print doc without devices, find the four values that aren’t what the file says, and quote them in inventory.yml. make check T=7.1. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>cat inventory.yml</code>, then in the REPL: <code>import yaml</code>, <code>doc = yaml.safe_load(open(&quot;inventory.yml&quot;))</code>, <code>doc[&quot;devices&quot;][0]</code>.</li>
<li>Write <code>load_inventory()</code> (TODO 7.1a), <code>save_json()</code> (7.1b) and <code>load_json()</code> (7.1c), each with a <code>with open(...)</code>.</li>
<li>Challenge (TODO 7.1d): print <code>doc</code> without <code>devices</code>, find the four values that aren&rsquo;t what the file says, and quote them in inventory.yml.</li>
<li><code>make check T=7.1</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Two spellings of one list</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="yaml-and-json">YAML and JSON</h3>
<p>Both write down the same shapes: lists and dicts of strings, numbers, booleans and nothing. In YAML, <code>key: value</code> is a dict entry, <code>- </code> starts a list item, and indentation (spaces only) shows what&rsquo;s inside what. JSON
writes the same thing with <code>{}</code>, <code>[]</code> and double quotes. Loaded into Python, they&rsquo;re identical.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Load a YAML or a JSON file, and you get the same lists and dicts.</p>
<h3 id="safe_load">safe_load</h3>
<p><code>yaml.safe_load(f)</code> builds only plain values. <code>yaml.load()</code> with PyYAML&rsquo;s full loader can build any Python
object a file asks for, which means a YAML file can run code on your machine. An inventory needs only plain
values, so there&rsquo;s never a reason to use anything else.</p>
<h3 id="jsondump-and-jsonload">json.dump and json.load</h3>
<p><code>json.dump(data, f, indent=2)</code> writes Python values to an open file as JSON, indented so a person can read it;
<code>json.load(f)</code> reads them back. (With an <code>s</code> on the end, <code>dumps</code> and <code>loads</code> work on strings instead of files.)</p>
<h3 id="what-yaml-guesses">What YAML guesses</h3>
<p>YAML decides a value&rsquo;s type from how it looks, and PyYAML follows YAML 1.1&rsquo;s rules, which guess more than you&rsquo;d
expect: some words are booleans, a leading zero means octal, and colons can make a number. When a value has to
stay a string, put it in quotes.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> If it must be a string, quote it.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>One device, three ways</h2>
  </header>
  <div class="lab-stage-body">
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">yaml</span><span class="o">,</span> <span class="nn">json</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">doc</span> <span class="o">=</span> <span class="n">yaml</span><span class="o">.</span><span class="n">safe_load</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="s2">&#34;inventory.yml&#34;</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">doc</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">dict_keys</span><span class="p">([</span><span class="s1">&#39;site&#39;</span><span class="p">,</span> <span class="s1">&#39;country&#39;</span><span class="p">,</span> <span class="s1">&#39;rack&#39;</span><span class="p">,</span> <span class="s1">&#39;backup&#39;</span><span class="p">,</span> <span class="s1">&#39;devices&#39;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">doc</span><span class="p">[</span><span class="s2">&#34;devices&#34;</span><span class="p">][</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;name&#39;</span><span class="p">:</span> <span class="s1">&#39;r3&#39;</span><span class="p">,</span> <span class="s1">&#39;host&#39;</span><span class="p">:</span> <span class="s1">&#39;172.80.111.13&#39;</span><span class="p">,</span> <span class="s1">&#39;device_type&#39;</span><span class="p">:</span> <span class="s1">&#39;arista_eos&#39;</span><span class="p">,</span> <span class="s1">&#39;role&#39;</span><span class="p">:</span> <span class="s1">&#39;router&#39;</span><span class="p">,</span> <span class="s1">&#39;model&#39;</span><span class="p">:</span> <span class="s1">&#39;CapeOS-Pulse&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">print</span><span class="p">(</span><span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">doc</span><span class="p">[</span><span class="s2">&#34;devices&#34;</span><span class="p">][</span><span class="mi">2</span><span class="p">],</span> <span class="n">indent</span><span class="o">=</span><span class="mi">2</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="s2">&#34;name&#34;</span><span class="p">:</span> <span class="s2">&#34;r3&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="s2">&#34;host&#34;</span><span class="p">:</span> <span class="s2">&#34;172.80.111.13&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="s2">&#34;device_type&#34;</span><span class="p">:</span> <span class="s2">&#34;arista_eos&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="s2">&#34;role&#34;</span><span class="p">:</span> <span class="s2">&#34;router&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="s2">&#34;model&#34;</span><span class="p">:</span> <span class="s2">&#34;CapeOS-Pulse&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>And the starter&rsquo;s check, before you&rsquo;ve started: one assertion, and two functions still to write.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">________________________ test_the_surprises_are_quoted _________________________
</span></span><span class="line"><span class="cl">checks/test_7_1.py:13: in test_the_surprises_are_quoted
</span></span><span class="line"><span class="cl">    assert doc[&#34;country&#34;] == &#34;NO&#34;, f&#34;country loads as {doc[&#39;country&#39;]!r}: Norway&#39;s code should stay the string &#39;NO&#39;&#34;
</span></span><span class="line"><span class="cl">E   AssertionError: country loads as False: Norway&#39;s code should stay the string &#39;NO&#39;
</span></span><span class="line"><span class="cl">E   assert False == &#39;NO&#39;
</span></span><span class="line"><span class="cl">______________________________ test_lab_inventory ______________________________
</span></span><span class="line"><span class="cl">TODO 7.1a is still open: write load_inventory() in netlab/inventory.py, then check again
</span></span><span class="line"><span class="cl">____________________________ test_unseen_round_trip ____________________________
</span></span><span class="line"><span class="cl">TODO 7.1a is still open: write load_inventory() in netlab/inventory.py, then check again
</span></span><span class="line"><span class="cl">3 failed, 1 passed in 0.08s
</span></span></code></pre></div>
  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Load, save, load again</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Open <code>netlab/inventory.py</code> and find TODO 7.1a. The devices are the list under the file&rsquo;s top-level
<code>devices:</code> key:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/inventory.py</code><span class="lab-file-how">Ctrl+P → inventory.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">load_inventory</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;...the docstring stays as it is...&#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">path</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">yaml</span><span class="o">.</span><span class="n">safe_load</span><span class="p">(</span><span class="n">f</span><span class="p">)[</span><span class="s2">&#34;devices&#34;</span><span class="p">]</span>
</span></span></code></pre></div></li>
<li>
<p>TODO 7.1b writes the list to a JSON file, opened for writing with <code>&quot;w&quot;</code>:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/inventory.py</code><span class="lab-file-how">Ctrl+P → inventory.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">save_json</span><span class="p">(</span><span class="n">devices</span><span class="p">,</span> <span class="n">path</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="s2">&#34;w&#34;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">json</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">devices</span><span class="p">,</span> <span class="n">f</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p><code>json.dump</code> doesn&rsquo;t end the file with a newline; the last line adds one, the way text files on Linux end.</p>
</li>
<li>
<p>TODO 7.1c reads it back. That one&rsquo;s yours: <code>with open(...)</code>, and the <code>json</code> function that reads from a file.</p>
</li>
<li>
<p>Try the round trip in the REPL:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.inventory</span> <span class="kn">import</span> <span class="n">load_inventory</span><span class="p">,</span> <span class="n">save_json</span><span class="p">,</span> <span class="n">load_json</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">devices</span> <span class="o">=</span> <span class="n">load_inventory</span><span class="p">(</span><span class="s2">&#34;inventory.yml&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">save_json</span><span class="p">(</span><span class="n">devices</span><span class="p">,</span> <span class="s2">&#34;scratch/inventory.json&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">load_json</span><span class="p">(</span><span class="s2">&#34;scratch/inventory.json&#34;</span><span class="p">)</span> <span class="o">==</span> <span class="n">devices</span>
</span></span><span class="line"><span class="cl"><span class="kc">True</span>
</span></span></code></pre></div><p>Open <code>scratch/inventory.json</code> in the editor: the same four devices, in JSON.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> YAML in, JSON out, JSON in: the same list of dicts all the way around.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>Four values YAML reads its own way</h2>
  </header>
  <div class="lab-stage-body">
    <p>TODO 7.1d is in <code>inventory.yml</code> itself. The block above <code>devices:</code> has four values that don&rsquo;t load the way
they read. Load the file in the REPL, look at what each of <code>country</code>, <code>rack</code> and <code>backup</code> became, and quote
the four so YAML keeps them as the strings the comments describe. Don&rsquo;t change what they say, only how
they&rsquo;re written.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Print everything except the devices: <code>{k: v for k, v in doc.items() if k != &quot;devices&quot;}</code>. Compare each value
with the line in the file. Look at the keys of <code>backup</code> as well as its values.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Lesson 7 has a table of what YAML 1.1 does to <code>NO</code>, <code>on</code>, <code>0123</code> and <code>2:30</code>, and why.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>A key can be quoted too: <code>&quot;on&quot;: sunday</code>.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>inventory.yml</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=7.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-yaml" data-lang="yaml"><span class="line"><span class="cl"><span class="nt">site</span><span class="p">:</span><span class="w"> </span><span class="l">lab</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nt">country</span><span class="p">:</span><span class="w"> </span><span class="s2">&#34;NO&#34;</span><span class="w">               </span><span class="c"># Norway</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nt">rack</span><span class="p">:</span><span class="w"> </span><span class="s2">&#34;0123&#34;</span><span class="w">                </span><span class="c"># the label on the rack</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nt">backup</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="nt">&#34;on&#34;: </span><span class="l">sunday             </span><span class="w"> </span><span class="c"># which day the configs are backed up</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="nt">at</span><span class="p">:</span><span class="w"> </span><span class="s2">&#34;2:30&#34;</span><span class="w">                </span><span class="c"># and when</span><span class="w">
</span></span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">yaml</span><span class="o">.</span><span class="n">safe_load</span><span class="p">(</span><span class="s2">&#34;country: NO</span><span class="se">\n</span><span class="s2">rack: 0123</span><span class="se">\n</span><span class="s2">backup:</span><span class="se">\n</span><span class="s2">  on: sunday</span><span class="se">\n</span><span class="s2">  at: 2:30</span><span class="se">\n</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;country&#39;</span><span class="p">:</span> <span class="kc">False</span><span class="p">,</span> <span class="s1">&#39;rack&#39;</span><span class="p">:</span> <span class="mi">83</span><span class="p">,</span> <span class="s1">&#39;backup&#39;</span><span class="p">:</span> <span class="p">{</span><span class="kc">True</span><span class="p">:</span> <span class="s1">&#39;sunday&#39;</span><span class="p">,</span> <span class="s1">&#39;at&#39;</span><span class="p">:</span> <span class="mi">150</span><span class="p">}}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">yaml</span><span class="o">.</span><span class="n">safe_load</span><span class="p">(</span><span class="s1">&#39;country: &#34;NO&#34;</span><span class="se">\n</span><span class="s1">rack: &#34;0123&#34;</span><span class="se">\n</span><span class="s1">backup:</span><span class="se">\n</span><span class="s1">  &#34;on&#34;: sunday</span><span class="se">\n</span><span class="s1">  at: &#34;2:30&#34;</span><span class="se">\n</span><span class="s1">&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;country&#39;</span><span class="p">:</span> <span class="s1">&#39;NO&#39;</span><span class="p">,</span> <span class="s1">&#39;rack&#39;</span><span class="p">:</span> <span class="s1">&#39;0123&#39;</span><span class="p">,</span> <span class="s1">&#39;backup&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;on&#39;</span><span class="p">:</span> <span class="s1">&#39;sunday&#39;</span><span class="p">,</span> <span class="s1">&#39;at&#39;</span><span class="p">:</span> <span class="s1">&#39;2:30&#39;</span><span class="p">}}</span>
</span></span></code></pre></div><p><code>NO</code> and <code>on</code> are YAML 1.1 booleans, <code>0123</code> is octal (83), and <code>2:30</code> is base 60 (2×60 + 30 = 150). Quoting
makes each a string. And <code>load_json()</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">load_json</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">path</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">json</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
</span></span></code></pre></div><p>None of the four affects the devices, which is why the round trip passed before you fixed them. That&rsquo;s the
danger: the file loads without an error, and the wrong value turns up later, in whatever reads <code>country</code>.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>Every device, and a login that fails</title><link>https://networkdoodles.com/labs/python-101/task-6-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-6-2/</guid><description> new to this? step by stepbeginner Replace Device = None (TODO 6.2a) with a dataclass of three fields: name, host, device_type. Challenge: collect(devices) (TODO 6.2b): for each device, connect(), send_command(..., use_textfsm=True), disconnect(). python scripts/collect.py: four lines, one per device. make break T=6.2, run the script again: one error: line, no traceback. Then make check T=6.2 and make reset. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>Replace <code>Device = None</code> (TODO 6.2a) with a dataclass of three fields: <code>name</code>, <code>host</code>, <code>device_type</code>.</li>
<li>Challenge: <code>collect(devices)</code> (TODO 6.2b): for each device, <code>connect()</code>, <code>send_command(..., use_textfsm=True)</code>, <code>disconnect()</code>.</li>
<li><code>python scripts/collect.py</code>: four lines, one per device.</li>
<li><code>make break T=6.2</code>, run the script again: one <code>error:</code> line, no traceback. Then <code>make check T=6.2</code> and <code>make reset</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Objects of your own, and failures in one line</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="a-dataclass">A dataclass</h3>
<p>A <strong>class</strong> is a kind of object; Netmiko&rsquo;s connection is one you&rsquo;ve already used. A <strong>dataclass</strong> is the
simplest class you can write yourself: a named group of fields, with Python writing the code that creates one,
prints it and compares two of them.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nd">@dataclass</span>
</span></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">Device</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">name</span><span class="p">:</span> <span class="nb">str</span>
</span></span><span class="line"><span class="cl">    <span class="n">host</span><span class="p">:</span> <span class="nb">str</span>
</span></span></code></pre></div><p><code>Device(&quot;r1&quot;, &quot;172.80.111.11&quot;)</code> makes one, and <code>d.host</code> reads a field. A field can have a default, like a
function&rsquo;s argument: <code>device_type: str = &quot;cisco_ios&quot;</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> A dataclass is a dict with fixed, named keys that you read with a dot.</p>
<h3 id="two-device-types-one-function">Two device types, one function</h3>
<p>r3 runs CapeOS Pulse, which Netmiko and ntc-templates know as <code>arista_eos</code>. If each <code>Device</code> carries its own
<code>device_type</code>, the same <code>connect()</code> and <code>send_command()</code> work on all four devices: Netmiko picks a different
class for r3, with the same methods. One thing does change: r3&rsquo;s template has different keys (<code>protocol</code>
where Bolt&rsquo;s has <code>proto</code>). <code>collect()</code> returns each table as it comes, so that doesn&rsquo;t matter here.</p>
<h3 id="catching-what-you-can-explain">Catching what you can explain</h3>
<p>A refused login raises <code>NetmikoAuthenticationException</code>; a device that doesn&rsquo;t answer raises
<code>NetmikoTimeoutException</code> (both are imported at the top of the file). Left alone, either one ends the script
with two screens of traceback. Caught, it becomes one line that says which device and what to check.</p>
<p><code>raise NewError(...) from None</code> raises your exception <em>instead of</em> the one you caught, without printing the
original underneath.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Catch the exceptions you can explain, and re-raise them as one line that names the device.</p>
<h3 id="always-disconnect">Always disconnect</h3>
<p>A <code>try:</code> block with <code>finally:</code> runs the <code>finally</code> part whether the <code>try</code> part worked or raised. Put
<code>disconnect()</code> there, and a command that fails still closes its SSH session.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>Four devices, then one that says no</h2>
  </header>
  <div class="lab-stage-body">
    <p>The finished script, with the lab as it starts:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/collect.py
</span></span><span class="line"><span class="cl">r1   6 IP interfaces, 5 up
</span></span><span class="line"><span class="cl">r2   6 IP interfaces, 5 up
</span></span><span class="line"><span class="cl">sw1  10 IP interfaces, 4 up
</span></span><span class="line"><span class="cl">r3   4 IP interfaces, 4 up
</span></span></code></pre></div><p><code>make break T=6.2</code> changes r2&rsquo;s password:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">  setting up task 6.2&#39;s problem
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  r2        username admin privilege 15 secret not-the-lab-password
</span></span><span class="line"><span class="cl">            r2 now refuses the lab&#39;s password: your code has to say so in one clear line
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  make reset puts everything back.
</span></span></code></pre></div><p>The same script, now:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/collect.py
</span></span><span class="line"><span class="cl">error: r2: login failed (check LAB_USER and LAB_PASSWORD)
</span></span></code></pre></div><p>It exits 1. Without the <code>except</code>, a refused login ends in Netmiko&rsquo;s own traceback. Here&rsquo;s the end of one, from
a wrong password typed for r1 in the REPL:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">netmiko.exceptions.NetmikoAuthenticationException: Authentication to device failed.
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Common causes of this problem are:
</span></span><span class="line"><span class="cl">1. Invalid username and password
</span></span><span class="line"><span class="cl">2. Incorrect SSH-key file
</span></span><span class="line"><span class="cl">3. Connecting to the wrong device
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Device settings: cisco_ios r1:22
</span></span></code></pre></div><p>Clear enough once you know where to look, and it comes after thirty lines of paramiko&rsquo;s and Netmiko&rsquo;s code.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>The Device dataclass</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Open <code>netlab/devices.py</code> and find TODO 6.2a. <code>dataclass</code> is already imported. Replace <code>Device = None</code> with
the class:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/devices.py</code><span class="lab-file-how">Ctrl+P → devices.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nd">@dataclass</span>
</span></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">Device</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">name</span><span class="p">:</span> <span class="nb">str</span>
</span></span><span class="line"><span class="cl">    <span class="n">host</span><span class="p">:</span> <span class="nb">str</span>
</span></span><span class="line"><span class="cl">    <span class="n">device_type</span><span class="p">:</span> <span class="nb">str</span> <span class="o">=</span> <span class="s2">&#34;cisco_ios&#34;</span>
</span></span></code></pre></div><p>The order of the fields is the order of the arguments: <code>scripts/collect.py</code> writes
<code>Device(&quot;r3&quot;, &quot;172.80.111.13&quot;, &quot;arista_eos&quot;)</code>.</p>
</li>
<li>
<p>Try it in the REPL:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.devices</span> <span class="kn">import</span> <span class="n">Device</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">d</span> <span class="o">=</span> <span class="n">Device</span><span class="p">(</span><span class="s2">&#34;r3&#34;</span><span class="p">,</span> <span class="s2">&#34;172.80.111.13&#34;</span><span class="p">,</span> <span class="s2">&#34;arista_eos&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">d</span>
</span></span><span class="line"><span class="cl"><span class="n">Device</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s1">&#39;r3&#39;</span><span class="p">,</span> <span class="n">host</span><span class="o">=</span><span class="s1">&#39;172.80.111.13&#39;</span><span class="p">,</span> <span class="n">device_type</span><span class="o">=</span><span class="s1">&#39;arista_eos&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">Device</span><span class="p">(</span><span class="s2">&#34;r1&#34;</span><span class="p">,</span> <span class="s2">&#34;172.80.111.11&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">Device</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s1">&#39;r1&#39;</span><span class="p">,</span> <span class="n">host</span><span class="o">=</span><span class="s1">&#39;172.80.111.11&#39;</span><span class="p">,</span> <span class="n">device_type</span><span class="o">=</span><span class="s1">&#39;cisco_ios&#39;</span><span class="p">)</span>
</span></span></code></pre></div><p>The second one took the default <code>device_type</code>. Two <code>Device</code>s with the same fields are <code>==</code>, which a plain
class wouldn&rsquo;t give you without more code.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>@dataclass</code> turns a list of fields into a class you can create, print and compare.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>collect()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>collect(devices, command=&quot;show ip interface brief&quot;)</code> (TODO 6.2b). It returns a dict:
<code>{device name: parsed output}</code>, one entry per device, using your <code>connect()</code> from task 6.1.</p>
<ul>
<li>Parse with ntc-templates, and disconnect from each device when you&rsquo;re done with it.</li>
<li>A refused login raises <code>DeviceError(&quot;r2: login failed (check LAB_USER and LAB_PASSWORD)&quot;)</code>, naming the
device.</li>
<li>A device that doesn&rsquo;t answer raises <code>DeviceError</code> too, naming the device (the check tries an <code>r9</code> at
172.80.111.19, which doesn&rsquo;t exist).</li>
</ul>
<p>Run <code>python scripts/collect.py</code> with the lab as it is, then <code>make break T=6.2</code> and run it again. <code>make reset</code>
when you&rsquo;re done.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Start with the loop and no error handling: <code>results = {}</code>, then for each <code>d</code> in <code>devices</code>, <code>connect(d.host, d.device_type)</code>, store <code>send_command(command, use_textfsm=True)</code> under <code>results[d.name]</code>, <code>disconnect()</code>. Get
the four lines first.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Only <code>connect()</code> can raise the login and timeout exceptions, so the <code>try:</code> goes around that one line, with one
<code>except</code> for each exception, each raising <code>DeviceError(...) from None</code>.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Then a second <code>try:</code> around <code>send_command()</code>, with <code>finally: conn.disconnect()</code>. Don&rsquo;t put the <code>disconnect()</code>
in the first <code>try</code>: if <code>connect()</code> failed, there&rsquo;s no <code>conn</code> to disconnect.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/devices.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=6.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nd">@dataclass</span>
</span></span><span class="line"><span class="cl"><span class="k">class</span> <span class="nc">Device</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">name</span><span class="p">:</span> <span class="nb">str</span>
</span></span><span class="line"><span class="cl">    <span class="n">host</span><span class="p">:</span> <span class="nb">str</span>
</span></span><span class="line"><span class="cl">    <span class="n">device_type</span><span class="p">:</span> <span class="nb">str</span> <span class="o">=</span> <span class="s2">&#34;cisco_ios&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">collect</span><span class="p">(</span><span class="n">devices</span><span class="p">,</span> <span class="n">command</span><span class="o">=</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">results</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="n">devices</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">conn</span> <span class="o">=</span> <span class="n">connect</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">host</span><span class="p">,</span> <span class="n">d</span><span class="o">.</span><span class="n">device_type</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">except</span> <span class="n">NetmikoAuthenticationException</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">raise</span> <span class="n">DeviceError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">d</span><span class="o">.</span><span class="n">name</span><span class="si">}</span><span class="s2">: login failed (check LAB_USER and LAB_PASSWORD)&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">        <span class="k">except</span> <span class="n">NetmikoTimeoutException</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">raise</span> <span class="n">DeviceError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">d</span><span class="o">.</span><span class="n">name</span><span class="si">}</span><span class="s2">: no answer from </span><span class="si">{</span><span class="n">d</span><span class="o">.</span><span class="n">host</span><span class="si">}</span><span class="s2"> on port 22&#34;</span><span class="p">)</span> <span class="kn">from</span> <span class="bp">None</span>
</span></span><span class="line"><span class="cl">        <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">results</span><span class="p">[</span><span class="n">d</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="n">command</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">finally</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">conn</span><span class="o">.</span><span class="n">disconnect</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">results</span>
</span></span></code></pre></div><p><code>collect()</code> doesn&rsquo;t print anything: it raises, and <code>scripts/collect.py</code> decides what to do with that (print
<code>error:</code> and the message, and exit 1). Keeping the two apart lets the checker call your function directly,
and lets lesson 8 decide differently: carry on past a failed device instead of stopping. The first failure
still stops <code>collect()</code> here, so with the break in place, r1&rsquo;s table is fetched and then thrown away when r2
refuses.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>Log in to r1 from Python</title><link>https://networkdoodles.com/labs/python-101/task-6-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-6-1/</guid><description> new to this? step by stepbeginner cat .env: the login is there. (No .env? make setup makes it.) In the REPL: from netmiko import ConnectHandler, then log in to r1 with the values from os.environ and try find_prompt(). Write connect() in netlab/devices.py (TODO 6.1a) the same way. Challenge: interface_table() (TODO 6.1b), one line with use_textfsm=True. python scripts/r1_interfaces.py, then make check T=6.1. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>cat .env</code>: the login is there. (No <code>.env</code>? <code>make setup</code> makes it.)</li>
<li>In the REPL: <code>from netmiko import ConnectHandler</code>, then log in to r1 with the values from <code>os.environ</code> and try <code>find_prompt()</code>.</li>
<li>Write <code>connect()</code> in <code>netlab/devices.py</code> (TODO 6.1a) the same way.</li>
<li>Challenge: <code>interface_table()</code> (TODO 6.1b), one line with <code>use_textfsm=True</code>.</li>
<li><code>python scripts/r1_interfaces.py</code>, then <code>make check T=6.1</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>SSH from code</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="what-netmiko-does">What Netmiko does</h3>
<p><strong>Netmiko</strong> logs in to a network device over SSH and runs CLI commands for you. Underneath it is paramiko,
the Python SSH library. On top, Netmiko does what you&rsquo;d do at a terminal: it learns the prompt, turns paging
off (<code>terminal length 0</code>) so long output doesn&rsquo;t stop at <code>--More--</code>, and waits for the prompt to come back
before it hands you a command&rsquo;s output.</p>
<p><code>ConnectHandler()</code> opens the session and returns a <strong>connection object</strong>. Its <strong>methods</strong>, functions you call
with a dot, do the work: <code>conn.find_prompt()</code>, <code>conn.send_command(&quot;show ...&quot;)</code>, <code>conn.disconnect()</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>ConnectHandler(...)</code> logs in; <code>conn.send_command(...)</code> runs a command; <code>conn.disconnect()</code> logs out.</p>
<h3 id="device_type">device_type</h3>
<p>Netmiko needs to know which CLI it&rsquo;s talking to. CapeOS Bolt behaves like the CLI Netmiko calls <code>cisco_ios</code>,
so r1, r2 and sw1 are <code>device_type=&quot;cisco_ios&quot;</code>. The same name tells ntc-templates which template to use when
you add <code>use_textfsm=True</code>, and then <code>send_command()</code> returns a list of dicts instead of text.</p>
<h3 id="the-password-lives-in-env">The password lives in .env</h3>
<p>The code names an <strong>environment variable</strong>, never the value: <code>os.environ[&quot;LAB_PASSWORD&quot;]</code>. The value is in
<code>.env</code>, a file Git ignores, and <code>load_env()</code> reads it into <code>os.environ</code>. The check proves it two ways: it looks
for the lab&rsquo;s password in your code, and it sets a wrong <code>LAB_PASSWORD</code> and expects your <code>connect()</code> to be
refused.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> If changing the environment doesn&rsquo;t change what your code logs in with, the password is still in the code.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>Netmiko on r1</h2>
  </header>
  <div class="lab-stage-body">
    <p>A login in the REPL, and the same command twice, as text and parsed:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span> <span class="o">=</span> <span class="n">ConnectHandler</span><span class="p">(</span><span class="n">device_type</span><span class="o">=</span><span class="s2">&#34;cisco_ios&#34;</span><span class="p">,</span> <span class="n">host</span><span class="o">=</span><span class="s2">&#34;r1&#34;</span><span class="p">,</span> <span class="n">username</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_USER&#34;</span><span class="p">],</span> <span class="n">password</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_PASSWORD&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span><span class="o">.</span><span class="n">find_prompt</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;r1#&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">rows</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">type</span><span class="p">(</span><span class="n">rows</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">rows</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="o">&lt;</span><span class="k">class</span> <span class="err">&#39;</span><span class="nc">list</span><span class="s1">&#39;&gt;, 6)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">rows</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet1&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;192.168.10.1&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;proto&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}</span>
</span></span></code></pre></div><p>The finished script:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/r1_interfaces.py
</span></span><span class="line"><span class="cl">logged in to r1#
</span></span><span class="line"><span class="cl">GigabitEthernet0     172.80.111.11    up/up
</span></span><span class="line"><span class="cl">GigabitEthernet1     192.168.10.1     up/up
</span></span><span class="line"><span class="cl">GigabitEthernet2     10.0.12.1        up/up
</span></span><span class="line"><span class="cl">GigabitEthernet3     10.0.13.1        up/up
</span></span><span class="line"><span class="cl">GigabitEthernet4     unassigned       administratively down/down
</span></span><span class="line"><span class="cl">Loopback0            10.255.0.1       up/up
</span></span></code></pre></div><p>And what the check says about a <code>connect()</code> that works but has the password typed into it:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">_________________________ test_no_password_in_the_code _________________________
</span></span><span class="line"><span class="cl">checks/test_6_1.py:8: in test_no_password_in_the_code
</span></span><span class="line"><span class="cl">    assert &#34;capeos-lab&#34; not in f.read_text(), f&#34;the lab&#39;s password is written in {f.relative_to(ROOT)}: read it from the environment&#34;
</span></span><span class="line"><span class="cl">E   AssertionError: the lab&#39;s password is written in netlab/devices.py: read it from the environment
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">__________________ test_credentials_come_from_the_environment __________________
</span></span><span class="line"><span class="cl">checks/test_6_1.py:30: in test_credentials_come_from_the_environment
</span></span><span class="line"><span class="cl">    with pytest.raises(NetmikoAuthenticationException):
</span></span><span class="line"><span class="cl">E   Failed: DID NOT RAISE NetmikoAuthenticationException
</span></span><span class="line"><span class="cl">2 failed, 2 passed in 3.18s
</span></span></code></pre></div><p><em>DID NOT RAISE</em> means the check gave it a wrong password and the login still worked.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>connect()</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Look at the login the lab gave you:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">cat .env
</span></span></code></pre></div><p><code>LAB_USER</code> and <code>LAB_PASSWORD</code> are the two you need. (<code>LAB_API_URL</code> and <code>LAB_API_TOKEN</code> are for chapter 7.)</p>
</li>
<li>
<p>Try it in the REPL first. Start <code>python</code> in the repository&rsquo;s folder, then:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">os</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netmiko</span> <span class="kn">import</span> <span class="n">ConnectHandler</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.env</span> <span class="kn">import</span> <span class="n">load_env</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">load_env</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span> <span class="o">=</span> <span class="n">ConnectHandler</span><span class="p">(</span><span class="n">device_type</span><span class="o">=</span><span class="s2">&#34;cisco_ios&#34;</span><span class="p">,</span> <span class="n">host</span><span class="o">=</span><span class="s2">&#34;r1&#34;</span><span class="p">,</span> <span class="n">username</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_USER&#34;</span><span class="p">],</span> <span class="n">password</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_PASSWORD&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span><span class="o">.</span><span class="n">find_prompt</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;r1#&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">print</span><span class="p">(</span><span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span><span class="o">.</span><span class="n">disconnect</span><span class="p">()</span>
</span></span></code></pre></div><p>The login takes a second or two. If it fails, the last line of the traceback says why: <em>Authentication</em>
(the login) or <em>TCP connection</em> (the device didn&rsquo;t answer).</p>
</li>
<li>
<p>Now put the same thing in <code>connect()</code>. Open <code>netlab/devices.py</code> and find TODO 6.1a. <code>os</code>, <code>ConnectHandler</code>
and <code>load_env</code> are already imported at the top. Replace the <code>raise NotImplementedError(...)</code> line:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/devices.py</code><span class="lab-file-how">Ctrl+P → devices.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">connect</span><span class="p">(</span><span class="n">host</span><span class="p">,</span> <span class="n">device_type</span><span class="o">=</span><span class="s2">&#34;cisco_ios&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;...the docstring stays as it is...&#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="n">load_env</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">ConnectHandler</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">device_type</span><span class="o">=</span><span class="n">device_type</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">host</span><span class="o">=</span><span class="n">host</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">username</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_USER&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="n">password</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_PASSWORD&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="n">conn_timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span></code></pre></div><p><code>conn_timeout=5</code> gives up after 5 seconds if nothing answers on port 22, instead of Netmiko&rsquo;s default 10.</p>
</li>
<li>
<p>Try your function. In a new REPL (so it imports your saved file):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.devices</span> <span class="kn">import</span> <span class="n">connect</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span> <span class="o">=</span> <span class="n">connect</span><span class="p">(</span><span class="s2">&#34;r1&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span><span class="o">.</span><span class="n">find_prompt</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;r1#&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">conn</span><span class="o">.</span><span class="n">disconnect</span><span class="p">()</span>
</span></span></code></pre></div></li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>connect()</code> reads the login from the environment every time it&rsquo;s called, so the check can change it underneath.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>interface_table()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>interface_table(conn)</code> (TODO 6.1b): given a connection, return <code>show ip interface brief</code> parsed by
ntc-templates, as a list of dicts. Then run the given script:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python scripts/r1_interfaces.py
</span></span></code></pre></div><p>It should print r1&rsquo;s six interfaces, the way the show stage does.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>send_command()</code> takes one more argument that hands the output to ntc-templates before returning it.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>The connection already knows its <code>device_type</code>, so ntc-templates knows which template to pick. You pass only
the command and <code>use_textfsm=True</code>.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/devices.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=6.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">connect</span><span class="p">(</span><span class="n">host</span><span class="p">,</span> <span class="n">device_type</span><span class="o">=</span><span class="s2">&#34;cisco_ios&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">load_env</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">ConnectHandler</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="n">device_type</span><span class="o">=</span><span class="n">device_type</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">host</span><span class="o">=</span><span class="n">host</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">username</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_USER&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="n">password</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s2">&#34;LAB_PASSWORD&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="n">conn_timeout</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">interface_table</span><span class="p">(</span><span class="n">conn</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">conn</span><span class="o">.</span><span class="n">send_command</span><span class="p">(</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">,</span> <span class="n">use_textfsm</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span></code></pre></div><p><code>interface_table()</code> takes a connection rather than a host, so the caller logs in once and can run several
commands on the same session. That&rsquo;s how <code>scripts/r1_interfaces.py</code> uses it: <code>connect()</code>, <code>find_prompt()</code>,
<code>interface_table()</code>, then <code>disconnect()</code>. The check compares what the script prints with what r1 says at that
moment, so it would notice if you&rsquo;d copied the table from the show stage.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>A template of your own</title><link>https://networkdoodles.com/labs/python-101/task-5-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-5-2/</guid><description> new to this? step by stepbeginner Open checks/data/ntp-r1.txt and templates/ntp_associations.textfsm side by side. Write parse_ntp_associations() from the follow-along: four lines that run your template. Try it on r1’s output in the REPL: the skeleton finds the header and the legend as servers. Challenge: fix the template, a Value per column and a state for the server lines, then make check T=5.2. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>Open <code>checks/data/ntp-r1.txt</code> and <code>templates/ntp_associations.textfsm</code> side by side.</li>
<li>Write <code>parse_ntp_associations()</code> from the follow-along: four lines that run your template.</li>
<li>Try it on r1&rsquo;s output in the REPL: the skeleton finds the header and the legend as servers.</li>
<li>Challenge: fix the template, a Value per column and a state for the server lines, then <code>make check T=5.2</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Values, states and rules</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="when-theres-no-template">When there&rsquo;s no template</h3>
<p><code>parse_output()</code> from ntc-templates raises an exception when it has nothing for a command:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">ntc_templates.parse.ParsingException: Unable to parse command &#34;show ntp associations&#34; on platform cisco_ios - No template found for attributes: &#34;{&#39;Command&#39;: &#39;show ntp associations&#39;, &#39;Platform&#39;: &#39;cisco_ios&#39;}&#34;
</span></span></code></pre></div><p>ntc-templates&rsquo; own templates are TextFSM files like the one you&rsquo;re writing, so <code>textfsm</code> can run yours the same
way.</p>
<h3 id="a-template">A template</h3>
<p><a href="/lessons/python-101/regex-and-textfsm/">Lesson 5</a> used this one, for two columns of <code>show ip interface brief</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Value INTERFACE (\S+)
</span></span><span class="line"><span class="cl">Value STATUS (up|down|administratively down)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Start
</span></span><span class="line"><span class="cl">  ^${INTERFACE}\s+\S+\s+(YES|NO)\s+\S+\s+${STATUS}\s -&gt; Record
</span></span></code></pre></div><p>A template has two parts:</p>
<ul>
<li><strong>Values</strong>: <code>Value NAME (regex)</code>, one per column you want. <code>Required</code> before the name drops any row
without that value.</li>
<li><strong>States</strong>: a name on its own line, then indented <strong>rules</strong>, each a regex starting with <code>^</code>. <code>${NAME}</code> in a
rule stands for that Value&rsquo;s regex, and saves what it matches. Every template starts in <code>Start</code>.</li>
</ul>
<p>TextFSM reads a line at a time and tries the current state&rsquo;s rules in order; the first that matches wins, and a
line that matches nothing is skipped. After <code>-&gt;</code> comes what to do: <code>Record</code> saves the values as one row,
a state&rsquo;s name moves to that state, and <code>Error</code> stops with an error. <code>$$</code> is a literal end of line (one <code>$</code>
starts a value&rsquo;s name).</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Values say what a column looks like; states and rules say which lines are rows.</p>
<h3 id="the-output">The output</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">  address         ref clock       st   when   poll reach  delay  offset   disp
</span></span><span class="line"><span class="cl">*~172.80.111.12   .LOCL.           3     22     64    17  0.621  -0.159  0.002
</span></span><span class="line"><span class="cl"> ~172.80.111.99   .INIT.          16      -    128     0  0.000   0.000  0.000
</span></span><span class="line"><span class="cl"> * sys.peer, # selected, + candidate, - outlyer, x falseticker, ~ configured
</span></span></code></pre></div><p>A header, one line per server, and a legend. Each server line starts with two characters, the <strong>tally</strong>: <code>*</code>
for the server the clock is synced to, then <code>~</code> for &ldquo;configured&rdquo;. 172.80.111.12 is r2, which serves time
(<code>ntp master 3</code> in its config); nothing answers at 172.80.111.99, so it&rsquo;s stuck at stratum 16 with a reach of 0.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Skip the header, record each server line, and don&rsquo;t mistake the legend for a server.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>What the skeleton finds</h2>
  </header>
  <div class="lab-stage-body">
    <p>The starting template has one Value and one rule:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Value ADDRESS (\S+)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Start
</span></span><span class="line"><span class="cl">  ^\s*${ADDRESS} -&gt; Record
</span></span></code></pre></div><p>With <code>parse_ntp_associations()</code> written, on r1&rsquo;s output, it gives four &ldquo;servers&rdquo; for two:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.parsers</span> <span class="kn">import</span> <span class="n">parse_ntp_associations</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parse_ntp_associations</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="s2">&#34;checks/data/ntp-r1.txt&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">())</span>
</span></span><span class="line"><span class="cl"><span class="p">[{</span><span class="s1">&#39;address&#39;</span><span class="p">:</span> <span class="s1">&#39;address&#39;</span><span class="p">},</span> <span class="p">{</span><span class="s1">&#39;address&#39;</span><span class="p">:</span> <span class="s1">&#39;*~172.80.111.12&#39;</span><span class="p">},</span> <span class="p">{</span><span class="s1">&#39;address&#39;</span><span class="p">:</span> <span class="s1">&#39;~172.80.111.99&#39;</span><span class="p">},</span> <span class="p">{</span><span class="s1">&#39;address&#39;</span><span class="p">:</span> <span class="s1">&#39;*&#39;</span><span class="p">}]</span>
</span></span></code></pre></div><p><code>\S+</code> matches any word, so the header&rsquo;s <code>address</code> is a row, the tally is stuck to each address, and the
legend&rsquo;s <code>*</code> is a row too. The check says the same, more briefly:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">checks/test_5_2.py::test_template_exists PASSED                          [ 20%]
</span></span><span class="line"><span class="cl">checks/test_5_2.py::test_the_keys FAILED                                 [ 40%]
</span></span><span class="line"><span class="cl">checks/test_5_2.py::test_real_outputs FAILED                             [ 60%]
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">E   AssertionError: each row needs the keys address, ref_clock, stratum, reach (Values in capitals become lower case). Missing: [&#39;ref_clock&#39;, &#39;stratum&#39;, &#39;reach&#39;]
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">E   AssertionError: ntp-r1.txt has 2 servers, the template found 4
</span></span></code></pre></div>
  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Run the template from Python</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Write <code>parse_ntp_associations()</code>. It opens the template, runs it over the text, and turns each row into a
dict with lower-case keys:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/parsers.py</code><span class="lab-file-how">Ctrl+P → parsers.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">parse_ntp_associations</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;`show ntp associations` (CapeOS Bolt), parsed by your template templates/ntp_associations.textfsm.
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">    ntc-templates has no template for this command, so you write one. It returns a list of dicts, one
</span></span></span><span class="line"><span class="cl"><span class="s2">    per server, with keys in lower case. These four must be there: address, ref_clock, stratum and
</span></span></span><span class="line"><span class="cl"><span class="s2">    reach. The header line and the legend at the bottom (&#34;* sys.peer, # selected, ...&#34;) aren&#39;t servers.
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">TEMPLATES</span> <span class="o">/</span> <span class="s2">&#34;ntp_associations.textfsm&#34;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">fsm</span> <span class="o">=</span> <span class="n">textfsm</span><span class="o">.</span><span class="n">TextFSM</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">keys</span> <span class="o">=</span> <span class="p">[</span><span class="n">h</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="k">for</span> <span class="n">h</span> <span class="ow">in</span> <span class="n">fsm</span><span class="o">.</span><span class="n">header</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">[</span><span class="nb">dict</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">row</span><span class="p">))</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">fsm</span><span class="o">.</span><span class="n">ParseText</span><span class="p">(</span><span class="n">text</span><span class="p">)]</span>
</span></span></code></pre></div><p><code>TEMPLATES</code> is set at the top of the module: the repository&rsquo;s <code>templates/</code> folder. <code>fsm.header</code> is the list
of Value names, <code>fsm.ParseText()</code> a list of rows in the same order, and <code>zip()</code> pairs them up.</p>
</li>
<li>
<p>Try it in a new REPL, and get the four wrong rows above:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.parsers</span> <span class="kn">import</span> <span class="n">parse_ntp_associations</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parse_ntp_associations</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="s2">&#34;checks/data/ntp-r1.txt&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">())</span>
</span></span></code></pre></div><p>The function reads the template every time it&rsquo;s called, so from now on you can edit the template, save it,
and run the same line again, without restarting the REPL.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> The Python part is four lines; the parsing lives in the template.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>The template</h2>
  </header>
  <div class="lab-stage-body">
    <p>Rewrite <code>templates/ntp_associations.textfsm</code> so it returns one row per server, and nothing for the header or
the legend. It needs a Value for at least <code>ADDRESS</code>, <code>REF_CLOCK</code>, <code>STRATUM</code> and <code>REACH</code>, and the address
without the tally. With no servers configured, only the header and the legend are printed, and the result
should be <code>[]</code>.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Give <code>ADDRESS</code> a stricter regex than <code>\S+</code>: four groups of digits with dots, <code>\d+\.\d+\.\d+\.\d+</code>. Then
neither <code>address</code> nor <code>*</code> can match it.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Use two states. In <code>Start</code>, a rule that matches the header line moves to a state of your own, say <code>Servers</code>,
and records nothing. In <code>Servers</code>, one rule matches a whole server line, column by column with <code>\s+</code> between,
and ends <code>-&gt; Record</code>.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>The tally is up to two characters before the address: <code>*~</code>, <code>+~</code>, <code>-~</code>, <code>x~</code>, or a space and <code>~</code>. A Value
for it, like <code>([*#+\-x ]?~?)</code>, keeps them out of the address. Mark <code>ADDRESS</code> as <code>Required</code>, so a line
without one can never become a row.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>templates/ntp_associations.textfsm</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=5.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Value Required ADDRESS (\d+\.\d+\.\d+\.\d+)
</span></span><span class="line"><span class="cl">Value TALLY ([*#+\-x ]?~?)
</span></span><span class="line"><span class="cl">Value REF_CLOCK (\S+)
</span></span><span class="line"><span class="cl">Value STRATUM (\d+)
</span></span><span class="line"><span class="cl">Value WHEN (\S+)
</span></span><span class="line"><span class="cl">Value POLL (\d+)
</span></span><span class="line"><span class="cl">Value REACH (\d+)
</span></span><span class="line"><span class="cl">Value DELAY (\S+)
</span></span><span class="line"><span class="cl">Value OFFSET (\S+)
</span></span><span class="line"><span class="cl">Value DISP (\S+)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Start
</span></span><span class="line"><span class="cl">  ^\s+address\s+ref clock -&gt; Servers
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Servers
</span></span><span class="line"><span class="cl">  ^${TALLY}${ADDRESS}\s+${REF_CLOCK}\s+${STRATUM}\s+${WHEN}\s+${POLL}\s+${REACH}\s+${DELAY}\s+${OFFSET}\s+${DISP}\s*$$ -&gt; Record
</span></span><span class="line"><span class="cl">  ^\s+\*\s+sys\.peer
</span></span><span class="line"><span class="cl">  ^\s*$$
</span></span><span class="line"><span class="cl">  ^. -&gt; Error
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parse_ntp_associations</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="s2">&#34;checks/data/ntp-r1.txt&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">())</span>
</span></span><span class="line"><span class="cl"><span class="p">[{</span><span class="s1">&#39;address&#39;</span><span class="p">:</span> <span class="s1">&#39;172.80.111.12&#39;</span><span class="p">,</span> <span class="s1">&#39;tally&#39;</span><span class="p">:</span> <span class="s1">&#39;*~&#39;</span><span class="p">,</span> <span class="s1">&#39;ref_clock&#39;</span><span class="p">:</span> <span class="s1">&#39;.LOCL.&#39;</span><span class="p">,</span> <span class="s1">&#39;stratum&#39;</span><span class="p">:</span> <span class="s1">&#39;3&#39;</span><span class="p">,</span> <span class="s1">&#39;when&#39;</span><span class="p">:</span> <span class="s1">&#39;22&#39;</span><span class="p">,</span> <span class="s1">&#39;poll&#39;</span><span class="p">:</span> <span class="s1">&#39;64&#39;</span><span class="p">,</span> <span class="s1">&#39;reach&#39;</span><span class="p">:</span> <span class="s1">&#39;17&#39;</span><span class="p">,</span> <span class="s1">&#39;delay&#39;</span><span class="p">:</span> <span class="s1">&#39;0.621&#39;</span><span class="p">,</span> <span class="s1">&#39;offset&#39;</span><span class="p">:</span> <span class="s1">&#39;-0.159&#39;</span><span class="p">,</span> <span class="s1">&#39;disp&#39;</span><span class="p">:</span> <span class="s1">&#39;0.002&#39;</span><span class="p">},</span> <span class="p">{</span><span class="s1">&#39;address&#39;</span><span class="p">:</span> <span class="s1">&#39;172.80.111.99&#39;</span><span class="p">,</span> <span class="s1">&#39;tally&#39;</span><span class="p">:</span> <span class="s1">&#39; ~&#39;</span><span class="p">,</span> <span class="s1">&#39;ref_clock&#39;</span><span class="p">:</span> <span class="s1">&#39;.INIT.&#39;</span><span class="p">,</span> <span class="s1">&#39;stratum&#39;</span><span class="p">:</span> <span class="s1">&#39;16&#39;</span><span class="p">,</span> <span class="s1">&#39;when&#39;</span><span class="p">:</span> <span class="s1">&#39;-&#39;</span><span class="p">,</span> <span class="s1">&#39;poll&#39;</span><span class="p">:</span> <span class="s1">&#39;128&#39;</span><span class="p">,</span> <span class="s1">&#39;reach&#39;</span><span class="p">:</span> <span class="s1">&#39;0&#39;</span><span class="p">,</span> <span class="s1">&#39;delay&#39;</span><span class="p">:</span> <span class="s1">&#39;0.000&#39;</span><span class="p">,</span> <span class="s1">&#39;offset&#39;</span><span class="p">:</span> <span class="s1">&#39;0.000&#39;</span><span class="p">,</span> <span class="s1">&#39;disp&#39;</span><span class="p">:</span> <span class="s1">&#39;0.000&#39;</span><span class="p">}]</span>
</span></span></code></pre></div><p><code>Start</code> skips everything until the header, then hands over to <code>Servers</code>. There, a server line is recorded,
the legend and blank lines match a rule that does nothing, and anything else is an <code>Error</code>. That last rule is
the strict part: if a new release adds a column or a kind of line, the template stops with
<code>TextFSMError: State Error raised</code> and names the line, instead of quietly returning rows that are wrong. <code>WHEN</code>
is <code>\S+</code> because a server that&rsquo;s never answered shows <code>-</code>. Every value comes back as a string, <code>'3'</code> and not
<code>3</code>: TextFSM finds text, and turning it into numbers is your code&rsquo;s job. The check runs the template on 40
made-up outputs with up to five servers each, references that are addresses as well as <code>.GPS.</code> and <code>.LOCL.</code>,
and one with no servers at all.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>One table, two parsers</title><link>https://networkdoodles.com/labs/python-101/task-5-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-5-1/</guid><description> new to this? step by stepbeginner Open checks/data/brief-r1.txt and netlab/parsers.py side by side. Write BRIEF_LINE, a regex with a named group per column, and try it in the REPL on one line. Write parse_brief_regex(): the regex on every line, a dict for each line that matches. Challenge: parse_brief_ntc(), the same rows from ntc-templates. Then make check T=5.1. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>Open <code>checks/data/brief-r1.txt</code> and <code>netlab/parsers.py</code> side by side.</li>
<li>Write <code>BRIEF_LINE</code>, a regex with a named group per column, and try it in the REPL on one line.</li>
<li>Write <code>parse_brief_regex()</code>: the regex on every line, a dict for each line that matches.</li>
<li>Challenge: <code>parse_brief_ntc()</code>, the same rows from ntc-templates. Then <code>make check T=5.1</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>A pattern per line, or a template per command</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="a-regular-expression">A regular expression</h3>
<p>A <strong>regex</strong> is a pattern for text. <code>\S+</code> is a run of non-space characters (a word), <code>\s+</code> is a run of spaces,
<code>up|down</code> is either one, and <code>^</code> and <code>$</code> are the start and end of the line. Parentheses make a <strong>group</strong>, and
<code>(?P&lt;name&gt;...)</code> a <strong>named group</strong>: the part of the line you want back, under that name.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">m</span> <span class="o">=</span> <span class="n">BRIEF_LINE</span><span class="o">.</span><span class="k">match</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>      <span class="c1"># a match object, or None if the line doesn&#39;t fit</span>
</span></span><span class="line"><span class="cl"><span class="n">m</span><span class="p">[</span><span class="s2">&#34;interface&#34;</span><span class="p">]</span>                  <span class="c1"># one named group&#39;s text</span>
</span></span></code></pre></div><p>Write patterns as raw strings, <code>r&quot;...&quot;</code>, so Python leaves the backslashes for <code>re</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> One named group per column, and <code>match()</code> on each line: a line that doesn&rsquo;t fit, like the header, gives <code>None</code>.</p>
<h3 id="the-tricky-column">The tricky column</h3>
<p>Status can be two words, <code>administratively down</code>, so <code>\S+</code> isn&rsquo;t enough there. List the three values it can
have: <code>(?P&lt;status&gt;up|down|administratively down)</code>. The <code>OK?</code> column is always <code>YES</code> or <code>NO</code>, and being that
strict is what stops the header line from matching.</p>
<h3 id="ntc-templates">ntc-templates</h3>
<p><strong>ntc-templates</strong> is a library of TextFSM templates for common commands. <code>parse_output()</code> picks one from the
<strong>platform</strong> and the <strong>command</strong>, and returns a list of dicts:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">ntc_templates.parse</span> <span class="kn">import</span> <span class="n">parse_output</span>
</span></span><span class="line"><span class="cl"><span class="n">parse_output</span><span class="p">(</span><span class="n">platform</span><span class="o">=</span><span class="s2">&#34;cisco_ios&#34;</span><span class="p">,</span> <span class="n">command</span><span class="o">=</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="n">text</span><span class="p">)</span>
</span></span></code></pre></div><p>CapeOS Bolt prints this command the way the platform ntc-templates calls <code>cisco_ios</code> does, so that&rsquo;s the
platform. Its keys are its own, though, so you map them to the lab&rsquo;s.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Two parsers, one shape: that&rsquo;s what lets you compare them, and swap one for the other later.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>One line, the pattern, the rows</h2>
  </header>
  <div class="lab-stage-body">
    <p><code>split()</code> can&rsquo;t tell where a two-word status ends:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">line</span> <span class="o">=</span> <span class="s2">&#34;GigabitEthernet4       unassigned      YES unset  administratively down down&#34;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;GigabitEthernet4&#39;</span><span class="p">,</span> <span class="s1">&#39;unassigned&#39;</span><span class="p">,</span> <span class="s1">&#39;YES&#39;</span><span class="p">,</span> <span class="s1">&#39;unset&#39;</span><span class="p">,</span> <span class="s1">&#39;administratively&#39;</span><span class="p">,</span> <span class="s1">&#39;down&#39;</span><span class="p">,</span> <span class="s1">&#39;down&#39;</span><span class="p">]</span>
</span></span></code></pre></div><p>A regex with a group per column can. With <code>BRIEF_LINE</code> and <code>parse_brief_regex()</code> written, r1&rsquo;s whole table:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.parsers</span> <span class="kn">import</span> <span class="n">parse_brief_regex</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">text</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s2">&#34;checks/data/brief-r1.txt&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">parse_brief_regex</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="nb">print</span><span class="p">(</span><span class="n">row</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet0&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;172.80.111.11&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet1&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;192.168.10.1&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet2&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;10.0.12.1&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet3&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;10.0.13.1&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet4&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="kc">None</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;administratively down&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;down&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;Loopback0&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;10.255.0.1&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}</span>
</span></span></code></pre></div><p>And what ntc-templates gives for the same text, before any mapping:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">ntc_templates.parse</span> <span class="kn">import</span> <span class="n">parse_output</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parse_output</span><span class="p">(</span><span class="n">platform</span><span class="o">=</span><span class="s2">&#34;cisco_ios&#34;</span><span class="p">,</span> <span class="n">command</span><span class="o">=</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="n">text</span><span class="p">)[:</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">[{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet0&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;172.80.111.11&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;proto&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">},</span> <span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet1&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;192.168.10.1&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;proto&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}]</span>
</span></span></code></pre></div>
  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>The regex parser</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Build the pattern a column at a time, in the REPL, on the hardest line:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">re</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">line</span> <span class="o">=</span> <span class="s2">&#34;GigabitEthernet4       unassigned      YES unset  administratively down down&#34;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">m</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="k">match</span><span class="p">(</span><span class="sa">r</span><span class="s2">&#34;(\S+)\s+(\S+)&#34;</span><span class="p">,</span> <span class="n">line</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">m</span><span class="o">.</span><span class="n">groups</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="s1">&#39;GigabitEthernet4&#39;</span><span class="p">,</span> <span class="s1">&#39;unassigned&#39;</span><span class="p">)</span>
</span></span></code></pre></div><p>Two columns. Keep adding a <code>\s+</code> and a group until all six are there, then name them.</p>
</li>
<li>
<p>Put the finished pattern in the module. It&rsquo;s split over two lines: Python joins strings that sit next to
each other inside parentheses.</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/parsers.py</code><span class="lab-file-how">Ctrl+P → parsers.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">BRIEF_LINE</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="sa">r</span><span class="s2">&#34;^(?P&lt;interface&gt;\S+)\s+(?P&lt;ip_address&gt;\S+)\s+(?P&lt;ok&gt;YES|NO)\s+(?P&lt;method&gt;\S+)\s+&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="sa">r</span><span class="s2">&#34;(?P&lt;status&gt;up|down|administratively down)\s+(?P&lt;protocol&gt;\S+)\s*$&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p><code>\s*$</code> at the end allows trailing spaces and nothing else. <code>re.compile()</code> builds the pattern once, so the
loop doesn&rsquo;t rebuild it on every line.</p>
</li>
<li>
<p>Write <code>parse_brief_regex()</code>. Every line that matches becomes a dict with the four keys; <code>unassigned</code>
becomes <code>None</code>, as in chapter 2:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/parsers.py</code><span class="lab-file-how">Ctrl+P → parsers.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">parse_brief_regex</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;`show ip interface brief` (CapeOS Bolt) with BRIEF_LINE, as a list of dicts (see the top of this file).&#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="n">rows</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">        <span class="n">m</span> <span class="o">=</span> <span class="n">BRIEF_LINE</span><span class="o">.</span><span class="k">match</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">m</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">address</span> <span class="o">=</span> <span class="n">m</span><span class="p">[</span><span class="s2">&#34;ip_address&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">            <span class="n">rows</span><span class="o">.</span><span class="n">append</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">                <span class="s2">&#34;interface&#34;</span><span class="p">:</span> <span class="n">m</span><span class="p">[</span><span class="s2">&#34;interface&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">                <span class="s2">&#34;ip_address&#34;</span><span class="p">:</span> <span class="kc">None</span> <span class="k">if</span> <span class="n">address</span> <span class="o">==</span> <span class="s2">&#34;unassigned&#34;</span> <span class="k">else</span> <span class="n">address</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">                <span class="s2">&#34;status&#34;</span><span class="p">:</span> <span class="n">m</span><span class="p">[</span><span class="s2">&#34;status&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">                <span class="s2">&#34;protocol&#34;</span><span class="p">:</span> <span class="n">m</span><span class="p">[</span><span class="s2">&#34;protocol&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">rows</span>
</span></span></code></pre></div><p><code>if m:</code> is what skips the header and blank lines: <code>match()</code> returns <code>None</code> for them.</p>
</li>
<li>
<p>In a new REPL, check r1&rsquo;s table looks like the one above. <code>make check T=5.1</code> now passes
<code>test_regex_unseen</code>, and fails the other two on <code>TODO 5.1c</code>.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> A strict pattern and <code>if m:</code> together decide which lines are rows.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>parse_brief_ntc()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>parse_brief_ntc(text, platform=&quot;cisco_ios&quot;)</code>: the same table through ntc-templates, returning exactly
what <code>parse_brief_regex()</code> returns for the same text. Same four keys, same values, same order.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>parse_output(platform=platform, command=&quot;show ip interface brief&quot;, data=text)</code> gives a list of dicts. Loop
over it and build a new dict for each row.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Compare one row of each in the REPL. Two things differ: ntc-templates calls the protocol column <code>proto</code>, and
it leaves <code>unassigned</code> as it is.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/parsers.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=5.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">parse_brief_ntc</span><span class="p">(</span><span class="n">text</span><span class="p">,</span> <span class="n">platform</span><span class="o">=</span><span class="s2">&#34;cisco_ios&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;The same table, parsed by ntc-templates&#39; template for `show ip interface brief` on this platform.
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">    ntc-templates calls the protocol column &#34;proto&#34;. Return the same keys and values as
</span></span></span><span class="line"><span class="cl"><span class="s2">    parse_brief_regex, so the two can be compared.
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="n">rows</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">parse_output</span><span class="p">(</span><span class="n">platform</span><span class="o">=</span><span class="n">platform</span><span class="p">,</span> <span class="n">command</span><span class="o">=</span><span class="s2">&#34;show ip interface brief&#34;</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="n">text</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="n">rows</span><span class="o">.</span><span class="n">append</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;interface&#34;</span><span class="p">:</span> <span class="n">r</span><span class="p">[</span><span class="s2">&#34;interface&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;ip_address&#34;</span><span class="p">:</span> <span class="kc">None</span> <span class="k">if</span> <span class="n">r</span><span class="p">[</span><span class="s2">&#34;ip_address&#34;</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;unassigned&#34;</span> <span class="k">else</span> <span class="n">r</span><span class="p">[</span><span class="s2">&#34;ip_address&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;status&#34;</span><span class="p">:</span> <span class="n">r</span><span class="p">[</span><span class="s2">&#34;status&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;protocol&#34;</span><span class="p">:</span> <span class="n">r</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;proto&#34;</span><span class="p">,</span> <span class="n">r</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;protocol&#34;</span><span class="p">)),</span>
</span></span><span class="line"><span class="cl">        <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">rows</span>
</span></span></code></pre></div><p>The check runs the regex on outputs it makes up fresh each time, blank lines included, and ntc-templates on
more of them, with sub-interfaces, loopbacks and VLAN interfaces. Then it runs both on the recorded r1, r2 and
sw1 outputs in <code>checks/data/</code> and expects them to agree row for row. Notice what each one needed from you: the
regex, a pattern you had to get right; ntc-templates, two renamed fields. Someone else had already got the
pattern right.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>Survive a bad file</title><link>https://networkdoodles.com/labs/python-101/task-4-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-4-2/</guid><description> new to this? step by stepbeginner make break T=4.2, then python scripts/ntp_report.py: a traceback. Read it from the bottom: which exception, which file, which line of yours? Challenge: write load_configs_safe() with try/except inside the loop, for PermissionError and UnicodeDecodeError only. Run the script again (it lists two skipped files and exits 1), make check T=4.2, then make reset. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>make break T=4.2</code>, then <code>python scripts/ntp_report.py</code>: a traceback.</li>
<li>Read it from the bottom: which exception, which file, which line of yours?</li>
<li>Challenge: write <code>load_configs_safe()</code> with <code>try</code>/<code>except</code> inside the loop, for <code>PermissionError</code> and <code>UnicodeDecodeError</code> only.</li>
<li>Run the script again (it lists two skipped files and exits 1), <code>make check T=4.2</code>, then <code>make reset</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Catch it, report it, carry on</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="exceptions">Exceptions</h3>
<p>When Python can&rsquo;t do something, it <strong>raises an exception</strong>: an object whose type says what went wrong.
Reading files, you meet these:</p>
<table>
  <thead>
      <tr>
          <th>Exception</th>
          <th>Meaning</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>PermissionError</code></td>
          <td>the file&rsquo;s there, and you&rsquo;re not allowed to read it</td>
      </tr>
      <tr>
          <td><code>UnicodeDecodeError</code></td>
          <td>the bytes aren&rsquo;t valid UTF-8 (or whatever encoding you asked for)</td>
      </tr>
      <tr>
          <td><code>FileNotFoundError</code></td>
          <td>there&rsquo;s no such file</td>
      </tr>
      <tr>
          <td><code>IsADirectoryError</code></td>
          <td>that name is a folder</td>
      </tr>
  </tbody>
</table>
<p>If nothing catches it, the program stops with a traceback. Read it from the bottom: the last line is the exception
and its message, and the lowest frame in your own files is where to look.</p>
<h3 id="try-and-except">try and except</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">text</span> <span class="o">=</span> <span class="n">path</span><span class="o">.</span><span class="n">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="k">except</span> <span class="ne">PermissionError</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="o">...</span>             <span class="c1"># runs only if the try block raised a PermissionError</span>
</span></span></code></pre></div><p>Python runs the <code>try</code> block. If it raises an exception that an <code>except</code> names, Python runs that block and
carries on after the whole <code>try</code>. <code>except UnicodeDecodeError as e:</code> also keeps the exception in <code>e</code>; a
<code>UnicodeDecodeError</code> knows where the bad byte was, in <code>e.start</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Put the <code>try</code> around the one line that can fail, inside the loop, so one bad file costs one file.</p>
<h3 id="only-what-you-can-handle">Only what you can handle</h3>
<p>A locked file or a Latin-1 file is bad <strong>data</strong>: skipping it and saying so is the right answer. A <em>folder</em>
called <code>something.cfg</code>, or a typo in your code, isn&rsquo;t bad data; it&rsquo;s a mistake, and it should still stop the
program with a traceback, so someone fixes it. <code>except Exception:</code> would hide both kinds. The check tests
that: it puts a folder named <code>not-a-file.cfg</code> in the folder, and expects your function to raise
<code>IsADirectoryError</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Name the exceptions you expect. Everything else is a bug, and a bug should be loud.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>Two bad files</h2>
  </header>
  <div class="lab-stage-body">
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ make break T=4.2
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  setting up task 4.2&#39;s problem
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  wrote     configs/old-r9.cfg: saved in Latin-1, so the é isn&#39;t valid UTF-8
</span></span><span class="line"><span class="cl">  wrote     configs/locked.cfg: and took away every permission on it (chmod 000)
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  make reset puts everything back.
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">$ ls -l configs
</span></span><span class="line"><span class="cl">total 24
</span></span><span class="line"><span class="cl">---------- 1 vscode vscode  37 Nov 11 05:52 locked.cfg
</span></span><span class="line"><span class="cl">-rw-r--r-- 1 vscode vscode 102 Nov 11 05:52 old-r9.cfg
</span></span><span class="line"><span class="cl">-rw-r--r-- 1 vscode vscode 802 Nov 11 05:52 r1.cfg
</span></span><span class="line"><span class="cl">-rw-r--r-- 1 vscode vscode 748 Nov 11 05:52 r2.cfg
</span></span><span class="line"><span class="cl">-rw-r--r-- 1 vscode vscode 641 Nov 11 05:52 r3.cfg
</span></span><span class="line"><span class="cl">-rw-r--r-- 1 vscode vscode 854 Nov 11 05:52 sw1.cfg
</span></span></code></pre></div><p><code>----------</code> is <code>chmod 000</code>: no one may read it, you included. With 4.1 done and 4.2 not, the report stops at
the first bad file in sorted order, <code>locked.cfg</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/ntp_report.py
</span></span><span class="line"><span class="cl">Traceback (most recent call last):
</span></span><span class="line"><span class="cl">  ...
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/netlab/configs.py&#34;, line 27, in load_configs
</span></span><span class="line"><span class="cl">    configs[path.stem] = path.read_text(encoding=&#34;utf-8&#34;)
</span></span><span class="line"><span class="cl">                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/usr/local/lib/python3.11/pathlib.py&#34;, line 1058, in read_text
</span></span><span class="line"><span class="cl">    with self.open(mode=&#39;r&#39;, encoding=encoding, errors=errors) as f:
</span></span><span class="line"><span class="cl">         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/usr/local/lib/python3.11/pathlib.py&#34;, line 1044, in open
</span></span><span class="line"><span class="cl">    return io.open(self, mode, buffering, encoding, errors, newline)
</span></span><span class="line"><span class="cl">           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">PermissionError: [Errno 13] Permission denied: &#39;/workspaces/python-101/configs/locked.cfg&#39;
</span></span></code></pre></div><p>When it&rsquo;s done, the same run finishes:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/ntp_report.py configs reports/ntp.csv
</span></span><span class="line"><span class="cl">wrote reports/ntp.csv (4 devices)
</span></span><span class="line"><span class="cl">skipped locked.cfg: permission denied
</span></span><span class="line"><span class="cl">skipped old-r9.cfg: not UTF-8 text (byte 64)
</span></span><span class="line"><span class="cl">$ echo $?
</span></span><span class="line"><span class="cl">1
</span></span></code></pre></div>
  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Meet the two files</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Set up the problem, and run the report:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">make <span class="nb">break</span> <span class="nv">T</span><span class="o">=</span>4.2
</span></span><span class="line"><span class="cl">python scripts/ntp_report.py
</span></span></code></pre></div><p>Read the traceback from the bottom. The exception is <code>PermissionError</code>, the file is <code>locked.cfg</code>, and the
lowest frame in your code is the <code>read_text()</code> line in <code>load_configs()</code>. Your line number may differ.</p>
</li>
<li>
<p>Meet the other one in the REPL. It&rsquo;s readable, but not as UTF-8:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">pathlib</span> <span class="kn">import</span> <span class="n">Path</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">Path</span><span class="p">(</span><span class="s2">&#34;configs/old-r9.cfg&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read_text</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">  <span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="ne">UnicodeDecodeError</span><span class="p">:</span> <span class="s1">&#39;utf-8&#39;</span> <span class="n">codec</span> <span class="n">can</span><span class="s1">&#39;t decode byte 0xe9 in position 64: invalid continuation byte</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">Path</span><span class="p">(</span><span class="s2">&#34;configs/old-r9.cfg&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read_bytes</span><span class="p">()[</span><span class="mi">60</span><span class="p">:</span><span class="mi">80</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="sa">b</span><span class="s1">&#39; Caf</span><span class="se">\xe9</span><span class="s1"> network ^C</span><span class="se">\n</span><span class="s1">ntp&#39;</span>
</span></span></code></pre></div><p><code>\xe9</code> is <code>é</code> in Latin-1, a single byte. In UTF-8, <code>é</code> takes two bytes, so this one on its own is invalid.
The banner was saved by an older tool.</p>
</li>
<li>
<p>Try catching it, once, at the prompt:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="n">Path</span><span class="p">(</span><span class="s2">&#34;configs/old-r9.cfg&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span> <span class="k">except</span> <span class="ne">UnicodeDecodeError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="nb">print</span><span class="p">(</span><span class="s2">&#34;skipped:&#34;</span><span class="p">,</span> <span class="n">e</span><span class="o">.</span><span class="n">reason</span><span class="p">,</span> <span class="s2">&#34;at byte&#34;</span><span class="p">,</span> <span class="n">e</span><span class="o">.</span><span class="n">start</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="n">skipped</span><span class="p">:</span> <span class="n">invalid</span> <span class="n">continuation</span> <span class="n">byte</span> <span class="n">at</span> <span class="n">byte</span> <span class="mi">64</span>
</span></span></code></pre></div></li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> Each bad file raises its own exception type, and that type is what an <code>except</code> matches on.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>load_configs_safe()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>load_configs_safe(folder)</code>. It reads the same <code>*.cfg</code> files as <code>load_configs()</code>, and returns two dicts:</p>
<ul>
<li><code>configs</code>: device name to text, for every file that read cleanly;</li>
<li><code>problems</code>: file name (<code>&quot;old-r9.cfg&quot;</code>) to a short reason, for every file that raised <code>PermissionError</code> or
<code>UnicodeDecodeError</code>.</li>
</ul>
<p>Catch only those two. Then run the script: two <code>skipped</code> lines, a CSV of the other four, and exit code 1.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Start from <code>load_configs()</code>: the same loop, with a <code>try</code> around the line that reads the file. A <code>try</code> outside
the loop would stop at the first bad file, which is what you have now.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Two <code>except</code> blocks, one per exception, each putting <code>path.name</code> and a reason in <code>problems</code>.
<code>f&quot;not UTF-8 text (byte {e.start})&quot;</code> says where.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>If the check says <code>DID NOT RAISE IsADirectoryError</code>, your <code>except</code> is too broad. This is <code>except Exception</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">checks/test_4_2.py::test_only_what_you_can_handle FAILED                 [ 66%]
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">E   Failed: DID NOT RAISE IsADirectoryError
</span></span></code></pre></div></div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/configs.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=4.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">load_configs_safe</span><span class="p">(</span><span class="n">folder</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;Like load_configs, but a file that can&#39;t be read doesn&#39;t stop the others.
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">    Returns two dicts: (configs, problems). configs is device name -&gt; text for every file that read
</span></span></span><span class="line"><span class="cl"><span class="s2">    cleanly. problems is file name (like &#34;r9.cfg&#34;) -&gt; a short reason, for every *.cfg file that
</span></span></span><span class="line"><span class="cl"><span class="s2">    couldn&#39;t be read: one you&#39;re not allowed to read (PermissionError), or one that isn&#39;t UTF-8 text
</span></span></span><span class="line"><span class="cl"><span class="s2">    (UnicodeDecodeError). Catch only those two: anything else is a bug, and should still stop you.
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="n">configs</span><span class="p">,</span> <span class="n">problems</span> <span class="o">=</span> <span class="p">{},</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">path</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">pathlib</span><span class="o">.</span><span class="n">Path</span><span class="p">(</span><span class="n">folder</span><span class="p">)</span><span class="o">.</span><span class="n">glob</span><span class="p">(</span><span class="s2">&#34;*.cfg&#34;</span><span class="p">)):</span>
</span></span><span class="line"><span class="cl">        <span class="k">try</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">configs</span><span class="p">[</span><span class="n">path</span><span class="o">.</span><span class="n">stem</span><span class="p">]</span> <span class="o">=</span> <span class="n">path</span><span class="o">.</span><span class="n">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">except</span> <span class="ne">PermissionError</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">problems</span><span class="p">[</span><span class="n">path</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="s2">&#34;permission denied&#34;</span>
</span></span><span class="line"><span class="cl">        <span class="k">except</span> <span class="ne">UnicodeDecodeError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">problems</span><span class="p">[</span><span class="n">path</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="sa">f</span><span class="s2">&#34;not UTF-8 text (byte </span><span class="si">{</span><span class="n">e</span><span class="o">.</span><span class="n">start</span><span class="si">}</span><span class="s2">)&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">configs</span><span class="p">,</span> <span class="n">problems</span>
</span></span></code></pre></div><p>The function only collects the problems; the script decides what to do with them: print each one to
stderr, so they don&rsquo;t mix with the normal output, and exit 1, so a cron job or a pipeline can tell. The check
builds a folder of its own with a Latin-1 file and a locked one under made-up names, and a third folder with
a directory called <code>not-a-file.cfg</code>. When you&rsquo;re done, <code>make reset</code> removes the two files from <code>configs/</code>.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>Saved configs to a report</title><link>https://networkdoodles.com/labs/python-101/task-4-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-4-1/</guid><description> new to this? step by stepbeginner Open configs/r1.cfg and find its ntp server lines. Open netlab/configs.py and find TODO 4.1a. Write has_ntp() and load_configs() from the follow-along, trying each in the REPL. Challenge: write write_report() with the csv module. python scripts/ntp_report.py, open reports/ntp.csv, then make check T=4.1. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>Open <code>configs/r1.cfg</code> and find its <code>ntp server</code> lines. Open <code>netlab/configs.py</code> and find <code>TODO 4.1a</code>.</li>
<li>Write <code>has_ntp()</code> and <code>load_configs()</code> from the follow-along, trying each in the REPL.</li>
<li>Challenge: write <code>write_report()</code> with the <code>csv</code> module.</li>
<li><code>python scripts/ntp_report.py</code>, open <code>reports/ntp.csv</code>, then <code>make check T=4.1</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>A module, a script, and a folder of files</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="reading-a-file">Reading a file</h3>
<p><code>pathlib.Path</code> names a file, and <code>read_text()</code> reads all of it into one string:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="kn">from</span> <span class="nn">pathlib</span> <span class="kn">import</span> <span class="n">Path</span>
</span></span><span class="line"><span class="cl"><span class="n">text</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="s2">&#34;configs/r1.cfg&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p><code>Path(&quot;configs&quot;).glob(&quot;*.cfg&quot;)</code> finds every <code>.cfg</code> file in the folder. It returns them in no particular
order, so wrap it in <code>sorted()</code>. Each one is a <code>Path</code>, and <code>path.stem</code> is the name without <code>.cfg</code>: in this lab,
the device&rsquo;s name.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>sorted(Path(folder).glob(&quot;*.cfg&quot;))</code> is every config, in order; <code>path.stem</code> is the device.</p>
<h3 id="writing-one">Writing one</h3>
<p><code>open(path, &quot;w&quot;)</code> opens a file for writing, and <code>with</code> closes it again when the block ends, whatever happens
inside it. A CSV file goes through <code>csv.writer</code>, which takes one list per row and gets the commas and quoting
right. Open it with <code>newline=&quot;&quot;</code>, as the <code>csv</code> module asks.</p>
<h3 id="module-and-script">Module and script</h3>
<p>The functions go in a <strong>module</strong>, <code>netlab/configs.py</code>, so the checker and other scripts can import them and
call them on any folder. <code>scripts/ntp_report.py</code> is given: it picks the folder and the output file, calls
your functions, and prints one line. It&rsquo;s already written for task 4.2, so it calls <code>load_configs_safe()</code>,
which until 4.2 calls your <code>load_configs()</code>.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Functions in <code>netlab/</code>, a thin script in <code>scripts/</code> on top: the script runs, the functions get tested.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>Before and after</h2>
  </header>
  <div class="lab-stage-body">
    <p>Before any TODO is written, the script stops at the first one it reaches. Read the traceback from the bottom:
the last line says which TODO, and the frame above it says where.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/ntp_report.py
</span></span><span class="line"><span class="cl">Traceback (most recent call last):
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/scripts/ntp_report.py&#34;, line 29, in &lt;module&gt;
</span></span><span class="line"><span class="cl">    sys.exit(main(sys.argv))
</span></span><span class="line"><span class="cl">             ^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/scripts/ntp_report.py&#34;, line 20, in main
</span></span><span class="line"><span class="cl">    configs, problems = load_configs_safe(folder)
</span></span><span class="line"><span class="cl">                        ^^^^^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/netlab/configs.py&#34;, line 48, in load_configs_safe
</span></span><span class="line"><span class="cl">    return load_configs(folder), {}
</span></span><span class="line"><span class="cl">           ^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">  File &#34;/workspaces/python-101/netlab/configs.py&#34;, line 22, in load_configs
</span></span><span class="line"><span class="cl">    raise NotImplementedError(&#34;TODO 4.1b is still open&#34;)
</span></span><span class="line"><span class="cl">NotImplementedError: TODO 4.1b is still open
</span></span></code></pre></div><p>And with the three functions written:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python scripts/ntp_report.py
</span></span><span class="line"><span class="cl">wrote /workspaces/python-101/reports/ntp.csv (4 devices)
</span></span><span class="line"><span class="cl">$ cat reports/ntp.csv
</span></span><span class="line"><span class="cl">device,has_ntp
</span></span><span class="line"><span class="cl">r1,yes
</span></span><span class="line"><span class="cl">r2,no
</span></span><span class="line"><span class="cl">r3,yes
</span></span><span class="line"><span class="cl">sw1,yes
</span></span></code></pre></div><p>r2 has <code>ntp master 3</code> instead: it&rsquo;s the clock the others use, at 172.80.111.12, not a client of anyone.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>has_ntp() and load_configs()</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Look at the data first. In the REPL, at the top of the repository:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">pathlib</span> <span class="kn">import</span> <span class="n">Path</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">text</span> <span class="o">=</span> <span class="n">Path</span><span class="p">(</span><span class="s2">&#34;configs/r1.cfg&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">()[:</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;Building configuration...&#39;</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">,</span> <span class="s1">&#39;Current configuration : 741 bytes&#39;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="p">[</span><span class="n">line</span> <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">()</span> <span class="k">if</span> <span class="n">line</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">&#34;ntp server&#34;</span><span class="p">)]</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;ntp server 172.80.111.12&#39;</span><span class="p">,</span> <span class="s1">&#39;ntp server 172.80.111.99&#39;</span><span class="p">]</span>
</span></span></code></pre></div><p>The first lines are CapeOS&rsquo;s, from saving <code>show running-config</code>. They don&rsquo;t matter: you&rsquo;re looking for
lines that <em>start</em> with <code>ntp server</code>.</p>
</li>
<li>
<p>Write <code>has_ntp()</code>. <code>True</code> when any line starts with <code>ntp server</code>, otherwise <code>False</code>:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/configs.py</code><span class="lab-file-how">Ctrl+P → configs.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">has_ntp</span><span class="p">(</span><span class="n">config_text</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;True when the config has at least one line that starts with &#34;ntp server&#34;, otherwise False.&#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">config_text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">line</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">&#34;ntp server&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">True</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">False</span>
</span></span></code></pre></div><p><code>startswith</code> on each line, rather than <code>&quot;ntp server&quot; in config_text</code>, matters: a comment like
<code>! ntp server 10.0.0.1</code> or an indented line inside another block isn&rsquo;t a configured server, and the check
tries both.</p>
</li>
<li>
<p>Write <code>load_configs()</code>: every <code>.cfg</code> file in the folder, as a dict of device name to text:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/configs.py</code><span class="lab-file-how">Ctrl+P → configs.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">load_configs</span><span class="p">(</span><span class="n">folder</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;Every *.cfg file in the folder, as a dict of device name -&gt; the file&#39;s text, sorted by name.
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">    Other files (a README, a .txt) are ignored. Read the files as UTF-8.
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="n">configs</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">path</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">pathlib</span><span class="o">.</span><span class="n">Path</span><span class="p">(</span><span class="n">folder</span><span class="p">)</span><span class="o">.</span><span class="n">glob</span><span class="p">(</span><span class="s2">&#34;*.cfg&#34;</span><span class="p">)):</span>
</span></span><span class="line"><span class="cl">        <span class="n">configs</span><span class="p">[</span><span class="n">path</span><span class="o">.</span><span class="n">stem</span><span class="p">]</span> <span class="o">=</span> <span class="n">path</span><span class="o">.</span><span class="n">read_text</span><span class="p">(</span><span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">configs</span>
</span></span></code></pre></div><p><code>pathlib.Path(folder)</code> works whether you&rsquo;re given a string, <code>&quot;configs&quot;</code>, or a <code>Path</code> already. The
module imports <code>pathlib</code> at the top, so the name is <code>pathlib.Path</code> here.</p>
</li>
<li>
<p>Try both. Leave the REPL and start a new one, so it imports your saved file (a module is imported once
per session):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.configs</span> <span class="kn">import</span> <span class="n">has_ntp</span><span class="p">,</span> <span class="n">load_configs</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">configs</span> <span class="o">=</span> <span class="n">load_configs</span><span class="p">(</span><span class="s2">&#34;configs&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="p">{</span><span class="n">name</span><span class="p">:</span> <span class="n">has_ntp</span><span class="p">(</span><span class="n">text</span><span class="p">)</span> <span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">text</span> <span class="ow">in</span> <span class="n">configs</span><span class="o">.</span><span class="n">items</span><span class="p">()}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;r1&#39;</span><span class="p">:</span> <span class="kc">True</span><span class="p">,</span> <span class="s1">&#39;r2&#39;</span><span class="p">:</span> <span class="kc">False</span><span class="p">,</span> <span class="s1">&#39;r3&#39;</span><span class="p">:</span> <span class="kc">True</span><span class="p">,</span> <span class="s1">&#39;sw1&#39;</span><span class="p">:</span> <span class="kc">True</span><span class="p">}</span>
</span></span></code></pre></div></li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> Read every file once into a dict; then any question about the configs is a loop over the dict.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>write_report()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>write_report(configs, out_path)</code>: a CSV file with the header <code>device,has_ntp</code>, then one row per device,
sorted by name, with <code>yes</code> or <code>no</code>. Create the folder the file goes in if it isn&rsquo;t there yet (<code>reports/</code> isn&rsquo;t,
in a new codespace). Then run <code>python scripts/ntp_report.py</code> and open <code>reports/ntp.csv</code>.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>pathlib.Path(out_path).parent</code> is the folder. <code>.mkdir(parents=True, exist_ok=True)</code> makes it, and does
nothing if it&rsquo;s already there.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>with path.open(&quot;w&quot;, newline=&quot;&quot;) as f:</code>, then <code>writer = csv.writer(f)</code> and <code>writer.writerow([...])</code> once for
the header and once per device.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>sorted(configs)</code> gives the device names in order. <code>&quot;yes&quot; if has_ntp(configs[name]) else &quot;no&quot;</code> is the second
column.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/configs.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=4.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">write_report</span><span class="p">(</span><span class="n">configs</span><span class="p">,</span> <span class="n">out_path</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;Write the NTP report as a CSV file with a header row and one row per device, sorted by name:
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">        device,has_ntp
</span></span></span><span class="line"><span class="cl"><span class="s2">        r1,yes
</span></span></span><span class="line"><span class="cl"><span class="s2">        r2,no
</span></span></span><span class="line"><span class="cl"><span class="s2">
</span></span></span><span class="line"><span class="cl"><span class="s2">    Create the folder the file goes in if it isn&#39;t there yet.
</span></span></span><span class="line"><span class="cl"><span class="s2">    &#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="n">out_path</span> <span class="o">=</span> <span class="n">pathlib</span><span class="o">.</span><span class="n">Path</span><span class="p">(</span><span class="n">out_path</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">out_path</span><span class="o">.</span><span class="n">parent</span><span class="o">.</span><span class="n">mkdir</span><span class="p">(</span><span class="n">parents</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">exist_ok</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">with</span> <span class="n">out_path</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s2">&#34;w&#34;</span><span class="p">,</span> <span class="n">newline</span><span class="o">=</span><span class="s2">&#34;&#34;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">writer</span> <span class="o">=</span> <span class="n">csv</span><span class="o">.</span><span class="n">writer</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">writer</span><span class="o">.</span><span class="n">writerow</span><span class="p">([</span><span class="s2">&#34;device&#34;</span><span class="p">,</span> <span class="s2">&#34;has_ntp&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">configs</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">            <span class="n">writer</span><span class="o">.</span><span class="n">writerow</span><span class="p">([</span><span class="n">name</span><span class="p">,</span> <span class="s2">&#34;yes&#34;</span> <span class="k">if</span> <span class="n">has_ntp</span><span class="p">(</span><span class="n">configs</span><span class="p">[</span><span class="n">name</span><span class="p">])</span> <span class="k">else</span> <span class="s2">&#34;no&#34;</span><span class="p">])</span>
</span></span></code></pre></div><p>The function calls <code>has_ntp()</code> rather than repeating its loop: one place decides what &ldquo;has NTP&rdquo; means. The
check runs the script on a folder of six made-up configs it writes fresh each time, with a <code>README.txt</code> that
mentions <code>ntp server</code> too, so <code>load_configs()</code> must only read <code>*.cfg</code>, and the rows must come out sorted.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>VLAN ranges</title><link>https://networkdoodles.com/labs/python-101/task-3-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-3-2/</guid><description> new to this? step by stepbeginner python, then sorted(set([20, 12, 10, 11, 11])): sorted, and no duplicates. Loop over the sorted list with enumerate() and compare each number with the next one. Challenge: write vlan_ranges() under TODO 3.2. make check T=3.2. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>python</code>, then <code>sorted(set([20, 12, 10, 11, 11]))</code>: sorted, and no duplicates.</li>
<li>Loop over the sorted list with <code>enumerate()</code> and compare each number with the next one.</li>
<li>Challenge: write <code>vlan_ranges()</code> under <code>TODO 3.2</code>.</li>
<li><code>make check T=3.2</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Runs of numbers</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="the-notation">The notation</h3>
<p>On an IOS-style switch, the VLANs a trunk carries are written as a list with ranges folded up:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">switchport trunk allowed vlan 10-12,20
</span></span></code></pre></div><p><code>10-12</code> means 10, 11 and 12. <code>20</code> stands alone. sw1&rsquo;s four VLANs, <code>[10, 11, 12, 20]</code>, written that way are
<code>10-12,20</code>. Two numbers in a row are a range too: <code>[5, 6]</code> is <code>5-6</code>.</p>
<h3 id="thinking-in-runs">Thinking in runs</h3>
<p>A <strong>run</strong> is a stretch of numbers where each is one more than the one before. Walk the sorted list from the
left and every number does one of two things: it carries on the run you&rsquo;re in, or it starts a new one. A run
ends when the next number isn&rsquo;t one more than this one, or when there is no next number.</p>
<table>
  <thead>
      <tr>
          <th>Number</th>
          <th>Next</th>
          <th>The run so far</th>
          <th>What happens</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>10</td>
          <td>11</td>
          <td>10</td>
          <td>carries on</td>
      </tr>
      <tr>
          <td>11</td>
          <td>12</td>
          <td>10, 11</td>
          <td>carries on</td>
      </tr>
      <tr>
          <td>12</td>
          <td>20</td>
          <td>10, 11, 12</td>
          <td>ends: write <code>10-12</code></td>
      </tr>
      <tr>
          <td>20</td>
          <td>none</td>
          <td>20</td>
          <td>ends: write <code>20</code></td>
      </tr>
  </tbody>
</table>
<p>So you need to remember where the current run started, and look at the next number.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Sort first. Then a run ends where the next number isn&rsquo;t this one plus one, or where the list ends.</p>
<h3 id="dont-touch-what-you-were-given">Don&rsquo;t touch what you were given</h3>
<p>A function that receives a list shouldn&rsquo;t reorder it: the caller may still need it as it was. <code>vlans.sort()</code>
sorts the list <em>in place</em>, the caller&rsquo;s list included. <code>sorted(vlans)</code> makes a sorted copy and leaves the
original alone.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>In and out</h2>
  </header>
  <div class="lab-stage-body">
    <p>The examples from the function&rsquo;s docstring and the check&rsquo;s edge cases:</p>
<table>
  <thead>
      <tr>
          <th><code>vlans</code></th>
          <th><code>vlan_ranges(vlans)</code></th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>[10, 11, 12, 20]</code></td>
          <td><code>'10-12,20'</code></td>
      </tr>
      <tr>
          <td><code>[20, 12, 10, 11, 11, 30, 31]</code></td>
          <td><code>'10-12,20,30-31'</code></td>
      </tr>
      <tr>
          <td><code>[20, 10, 11, 10, 12, 20]</code></td>
          <td><code>'10-12,20'</code></td>
      </tr>
      <tr>
          <td><code>[1, 3, 5]</code></td>
          <td><code>'1,3,5'</code></td>
      </tr>
      <tr>
          <td><code>[5, 6]</code></td>
          <td><code>'5-6'</code></td>
      </tr>
      <tr>
          <td><code>[4094, 4093]</code></td>
          <td><code>'4093-4094'</code></td>
      </tr>
      <tr>
          <td><code>[1]</code></td>
          <td><code>'1'</code></td>
      </tr>
      <tr>
          <td><code>[]</code></td>
          <td><code>''</code></td>
      </tr>
  </tbody>
</table>
<p>The check also tries 100 random lists, and checks that the list you were given is unchanged afterwards. A
version that sorts in place and never folds anything up fails all four checks, for instance:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">E   AssertionError: assert &#39;10,11,12,20&#39; == &#39;10-12,20&#39;
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">E   AssertionError: vlan_ranges changed the list it was given: sort a copy (sorted() makes one)
</span></span><span class="line"><span class="cl">E   assert [10, 10, 20, 30] == [30, 10, 20, 10]
</span></span></code></pre></div><p>In pytest&rsquo;s <code>assert ... == ...</code> line, your answer is on the left and the expected one on the right.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Sort, then look next door</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Start the REPL. A <strong>set</strong> is a collection with no duplicates and no order; <code>sorted()</code> turns anything you
can loop over into a new, sorted list:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">set</span><span class="p">([</span><span class="mi">20</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">11</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">12</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">([</span><span class="mi">20</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">11</span><span class="p">]))</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">20</span><span class="p">]</span>
</span></span></code></pre></div><p>The set dropped the second 11, and came out in an order of its own. Never rely on a set&rsquo;s order: sort it.</p>
</li>
<li>
<p>See the difference between <code>sorted()</code> and <code>.sort()</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">trunk</span> <span class="o">=</span> <span class="p">[</span><span class="mi">30</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">10</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">trunk</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">trunk</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="mi">30</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">10</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">trunk</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">trunk</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">]</span>
</span></span></code></pre></div><p><code>sorted()</code> gave back a copy and left <code>trunk</code> alone. <code>.sort()</code> returned nothing and changed <code>trunk</code> itself.</p>
</li>
<li>
<p>Walk a sorted list with <code>enumerate()</code>, which gives each number&rsquo;s position as well. The position tells you
whether this is the last number, and lets you look at the next one:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">vlans</span> <span class="o">=</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">20</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">n</span><span class="p">,</span> <span class="n">vlan</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">vlans</span><span class="p">):</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="nb">print</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">vlan</span><span class="p">,</span> <span class="n">n</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">vlans</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="mi">0</span> <span class="mi">10</span> <span class="kc">False</span>
</span></span><span class="line"><span class="cl"><span class="mi">1</span> <span class="mi">11</span> <span class="kc">False</span>
</span></span><span class="line"><span class="cl"><span class="mi">2</span> <span class="mi">12</span> <span class="kc">False</span>
</span></span><span class="line"><span class="cl"><span class="mi">3</span> <span class="mi">20</span> <span class="kc">True</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">vlans</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">):</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="nb">print</span><span class="p">(</span><span class="n">vlans</span><span class="p">[</span><span class="n">n</span><span class="p">],</span> <span class="n">vlans</span><span class="p">[</span><span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">],</span> <span class="n">vlans</span><span class="p">[</span><span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="n">vlans</span><span class="p">[</span><span class="n">n</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="mi">10</span> <span class="mi">11</span> <span class="kc">True</span>
</span></span><span class="line"><span class="cl"><span class="mi">11</span> <span class="mi">12</span> <span class="kc">True</span>
</span></span><span class="line"><span class="cl"><span class="mi">12</span> <span class="mi">20</span> <span class="kc">False</span>
</span></span></code></pre></div><p>The <code>False</code> in the second loop is where a run ends: 12 is followed by 20, not 13.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>sorted(set(...))</code> for a clean copy; the position from <code>enumerate()</code> to look at the next number.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>vlan_ranges()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>vlan_ranges(vlans)</code> under <code>TODO 3.2</code>, in place of the <code>raise NotImplementedError(...)</code> line, so that
every row in the table above comes out right, and the list it&rsquo;s given is left as it was.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Make the clean list first: <code>numbers = sorted(set(vlans))</code>. Then collect the pieces as strings in a list,
<code>parts = []</code>, and finish with <code>&quot;,&quot;.join(parts)</code>. An empty list of parts joins to <code>&quot;&quot;</code>, which is the right
answer for no VLANs.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Keep a variable for where the current run started, <code>start = None</code>. In the loop, if <code>start is None</code>, this
number starts a run. Then ask: is this the last number, or is the next one not <code>n + 1</code>? If so, the run ends
here.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>When a run ends at <code>n</code>, it&rsquo;s one number if <code>start == n</code> (write <code>str(n)</code>) and a range otherwise (write
<code>f&quot;{start}-{n}&quot;</code>). Then set <code>start = None</code> so the next number starts a new run.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/interfaces.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=3.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">vlan_ranges</span><span class="p">(</span><span class="n">vlans</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">parts</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="n">numbers</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">vlans</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">    <span class="n">start</span> <span class="o">=</span> <span class="kc">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">numbers</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">start</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">start</span> <span class="o">=</span> <span class="n">n</span>
</span></span><span class="line"><span class="cl">        <span class="n">last</span> <span class="o">=</span> <span class="n">i</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">numbers</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">last</span> <span class="ow">or</span> <span class="n">numbers</span><span class="p">[</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">!=</span> <span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">parts</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">start</span><span class="p">)</span> <span class="k">if</span> <span class="n">start</span> <span class="o">==</span> <span class="n">n</span> <span class="k">else</span> <span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">start</span><span class="si">}</span><span class="s2">-</span><span class="si">{</span><span class="n">n</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">start</span> <span class="o">=</span> <span class="kc">None</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="s2">&#34;,&#34;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">parts</span><span class="p">)</span>
</span></span></code></pre></div><p><code>sorted(set(vlans))</code> is a new list, so the caller&rsquo;s list is never touched. <code>start</code> remembers where the run
began, and <code>None</code> means <em>no run open</em>. The test <code>last or numbers[i + 1] != n + 1</code> relies on how <code>or</code> works:
Python stops at the first true part, so on the last number it never looks at <code>numbers[i + 1]</code>, which would be
past the end. Each run becomes one string, and <code>join</code> puts commas between them. The result is the form you&rsquo;d
write in a trunk&rsquo;s config, and the one a report should print: <code>10-12,20</code> reads better than four numbers.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>Which interfaces are down?</title><link>https://networkdoodles.com/labs/python-101/task-3-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-3-1/</guid><description> new to this? step by stepbeginner In netlab/interfaces.py, write down_interfaces() under TODO 3.1a: the code is in step 2 of the follow-along. python, then try it on r1’s interfaces (step 3). Challenge: count_by_status() under TODO 3.1b, a dict of each status and how many interfaces have it. make check T=3.1. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>In netlab/interfaces.py, write <code>down_interfaces()</code> under <code>TODO 3.1a</code>: the code is in step 2 of the follow-along.</li>
<li><code>python</code>, then try it on r1&rsquo;s interfaces (step 3).</li>
<li>Challenge: <code>count_by_status()</code> under <code>TODO 3.1b</code>, a dict of each status and how many interfaces have it.</li>
<li><code>make check T=3.1</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>A loop, a question, an answer</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="the-shape-of-both-functions">The shape of both functions</h3>
<p>Both functions in this task follow the same pattern: start with an empty result, loop over the interfaces,
decide something about each one with <code>if</code>, and <strong>return</strong> the result when the loop is done.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>                 <span class="c1"># or {} for a dict</span>
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">interfaces</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="o">...</span><span class="p">:</span>                 <span class="c1"># a question about this one interface</span>
</span></span><span class="line"><span class="cl">        <span class="o">...</span>                 <span class="c1"># add to the result</span>
</span></span><span class="line"><span class="cl"><span class="k">return</span> <span class="n">result</span>
</span></span></code></pre></div><p>The function takes its data as a <strong>parameter</strong> and gives its answer back with <code>return</code>. It doesn&rsquo;t print,
log in to anything, or read a file. That&rsquo;s why the check can call it on interface lists it made up a moment
before, and know the right answer.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Empty result, loop, <code>if</code>, add, return: most functions in this lab start out like that.</p>
<h3 id="what-down-means">What <em>down</em> means</h3>
<p><code>show ip interface brief</code> has two state columns: <strong>Status</strong>, the interface itself, and <strong>Protocol</strong>, the line
protocol running on it. An interface is working only when both are <code>up</code>. It isn&rsquo;t working when:</p>
<table>
  <thead>
      <tr>
          <th>Status</th>
          <th>Protocol</th>
          <th>Means</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>down</code></td>
          <td><code>down</code></td>
          <td>nothing at the other end, or a fault</td>
      </tr>
      <tr>
          <td><code>administratively down</code></td>
          <td><code>down</code></td>
          <td>someone configured <code>shutdown</code></td>
      </tr>
      <tr>
          <td><code>up</code></td>
          <td><code>down</code></td>
          <td>the interface is up but the protocol isn&rsquo;t: a mismatch, or no keepalives</td>
      </tr>
  </tbody>
</table>
<p>Testing <code>status == &quot;down&quot;</code> catches only the first row. Ask the question the other way around, <em>is it fully
up?</em>, and everything else is down, whatever words the OS uses.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Test for what working looks like; treat everything else as not working.</p>
<h3 id="a-dict-as-a-counter">A dict as a counter</h3>
<p>To count things, keep a dict whose keys are the things and whose values are the counts. <code>get(key, 0)</code> gives
the count so far, or <code>0</code> for a key you haven&rsquo;t seen yet, so adding one always works.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>r1 and sw1</h2>
  </header>
  <div class="lab-stage-body">
    <p>r1 has one interface shut down. sw1, the lab&rsquo;s switch, has eight ports (GigabitEthernet1 to 8) and cables on
only two of them. Its saved output is in <code>checks/data/</code>, and <code>open(...).read()</code> reads a file into one string
(chapter 4 covers files):</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">down_interfaces</span><span class="p">(</span><span class="n">interfaces</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;GigabitEthernet4&#39;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">text</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="s2">&#34;checks/data/brief-sw1.txt&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">sw1</span> <span class="o">=</span> <span class="n">interfaces_to_dicts</span><span class="p">(</span><span class="n">text</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">down_interfaces</span><span class="p">(</span><span class="n">sw1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;GigabitEthernet3&#39;</span><span class="p">,</span> <span class="s1">&#39;GigabitEthernet4&#39;</span><span class="p">,</span> <span class="s1">&#39;GigabitEthernet5&#39;</span><span class="p">,</span> <span class="s1">&#39;GigabitEthernet6&#39;</span><span class="p">,</span> <span class="s1">&#39;GigabitEthernet7&#39;</span><span class="p">,</span> <span class="s1">&#39;GigabitEthernet8&#39;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">count_by_status</span><span class="p">(</span><span class="n">sw1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;up&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s1">&#39;down&#39;</span><span class="p">:</span> <span class="mi">6</span><span class="p">}</span>
</span></span></code></pre></div><p>And a version of <code>down_interfaces()</code> that tests <code>status == &quot;down&quot;</code>, as <code>make check</code> sees it. The message gives
the input (a list of ten interfaces, shortened here), what the check expected, and what came back:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">E   AssertionError: for these interfaces
</span></span><span class="line"><span class="cl">E     [{&#39;interface&#39;: &#39;GigabitEthernet0&#39;, ... &#39;status&#39;: &#39;down&#39;, &#39;protocol&#39;: &#39;down&#39;}, ... ]
</span></span><span class="line"><span class="cl">E     we expected [&#39;GigabitEthernet0&#39;, &#39;GigabitEthernet2&#39;, &#39;GigabitEthernet3&#39;, &#39;Loopback0&#39;, &#39;Vlan20&#39;]
</span></span><span class="line"><span class="cl">E     and got      [&#39;GigabitEthernet0&#39;, &#39;GigabitEthernet3&#39;]
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">__________________________ test_up_but_protocol_down ___________________________
</span></span><span class="line"><span class="cl">checks/test_3_1.py:18: in test_up_but_protocol_down
</span></span><span class="line"><span class="cl">    assert call(down_interfaces, rows) == [&#34;Gi1&#34;], &#34;status up but protocol down still isn&#39;t working&#34;
</span></span><span class="line"><span class="cl">E   AssertionError: status up but protocol down still isn&#39;t working
</span></span><span class="line"><span class="cl">E   assert [] == [&#39;Gi1&#39;]
</span></span></code></pre></div><p>GigabitEthernet2 and Vlan20 were <em>administratively down</em>, and Loopback0 was up with its protocol down. None of
them said <code>&quot;down&quot;</code> in the Status column.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>down_interfaces()</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Open <code>netlab/interfaces.py</code> and read the docstring under <code>TODO 3.1a</code>, the text in triple quotes. It&rsquo;s the
spec: names, in the order they came, of the interfaces that aren&rsquo;t fully up.</p>
</li>
<li>
<p>Replace its <code>raise NotImplementedError(...)</code> line with:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/interfaces.py</code><span class="lab-file-how">Ctrl+P → interfaces.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl">    <span class="n">down</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">interfaces</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="n">i</span><span class="p">[</span><span class="s2">&#34;status&#34;</span><span class="p">]</span> <span class="o">!=</span> <span class="s2">&#34;up&#34;</span> <span class="ow">or</span> <span class="n">i</span><span class="p">[</span><span class="s2">&#34;protocol&#34;</span><span class="p">]</span> <span class="o">!=</span> <span class="s2">&#34;up&#34;</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="n">down</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">i</span><span class="p">[</span><span class="s2">&#34;interface&#34;</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">down</span>
</span></span></code></pre></div><p>Read it aloud: <em>for each interface, if its status isn&rsquo;t up or its protocol isn&rsquo;t up, add its name.</em> <code>or</code>
means either one is enough. The <code>return</code> is level with the <code>for</code>, so it runs once, after the loop; one
level further in and it would return after the first interface.</p>
</li>
<li>
<p>Save, start a REPL, and try it on r1. This uses your <code>interfaces_to_dicts()</code> from task 2.2 (skipped it?
<code>make solve T=2.2</code> puts it in):</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.parse</span> <span class="kn">import</span> <span class="n">SAMPLE</span><span class="p">,</span> <span class="n">interfaces_to_dicts</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.interfaces</span> <span class="kn">import</span> <span class="n">down_interfaces</span><span class="p">,</span> <span class="n">count_by_status</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">interfaces</span> <span class="o">=</span> <span class="n">interfaces_to_dicts</span><span class="p">(</span><span class="n">SAMPLE</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">down_interfaces</span><span class="p">(</span><span class="n">interfaces</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;GigabitEthernet4&#39;</span><span class="p">]</span>
</span></span></code></pre></div></li>
<li>
<p>Now the cases no lab device is in right now. You don&rsquo;t need a device in that state: hand the function the
data.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">down_interfaces</span><span class="p">([{</span><span class="s2">&#34;interface&#34;</span><span class="p">:</span> <span class="s2">&#34;Gi1&#34;</span><span class="p">,</span> <span class="s2">&#34;status&#34;</span><span class="p">:</span> <span class="s2">&#34;up&#34;</span><span class="p">,</span> <span class="s2">&#34;protocol&#34;</span><span class="p">:</span> <span class="s2">&#34;down&#34;</span><span class="p">}])</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;Gi1&#39;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">down_interfaces</span><span class="p">([])</span>
</span></span><span class="line"><span class="cl"><span class="p">[]</span>
</span></span></code></pre></div><p>An empty list never enters the loop, so the function returns the empty <code>down</code> it started with.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> A function that takes data can be tried on any data, including states the lab isn&rsquo;t in.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>count_by_status()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>count_by_status(interfaces)</code> under <code>TODO 3.1b</code>. It returns a dict with one key per status that occurs,
and how many interfaces have it:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">count_by_status</span><span class="p">(</span><span class="n">interfaces</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;up&#39;</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="s1">&#39;administratively down&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">count_by_status</span><span class="p">([])</span>
</span></span><span class="line"><span class="cl"><span class="p">{}</span>
</span></span></code></pre></div><p>Only statuses that occur are keys: no <code>'down': 0</code>.</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>The same shape as <code>down_interfaces()</code>, with a dict instead of a list: <code>counts = {}</code> before the loop,
<code>return counts</code> after it.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>counts[status] += 1</code> fails with <code>KeyError</code> the first time a status turns up, because the key isn&rsquo;t there
yet. <code>counts.get(status, 0)</code> is the count so far, or 0.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/interfaces.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=3.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">count_by_status</span><span class="p">(</span><span class="n">interfaces</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">counts</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">interfaces</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">counts</span><span class="p">[</span><span class="n">i</span><span class="p">[</span><span class="s2">&#34;status&#34;</span><span class="p">]]</span> <span class="o">=</span> <span class="n">counts</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">i</span><span class="p">[</span><span class="s2">&#34;status&#34;</span><span class="p">],</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">counts</span>
</span></span></code></pre></div><p>For each interface, look up how many of its status you&rsquo;ve counted so far (0 if none), add one, and store it
back under the same key. A new status gets a key the first time it&rsquo;s seen, so only statuses that occur appear,
in the order they first turned up. There&rsquo;s no <code>if</code> here: the dict does the deciding. Python&rsquo;s standard library
has a ready-made counter,
<a href="https://docs.python.org/3/library/collections.html#collections.Counter"><code>collections.Counter</code></a>, which does the same; writing it once yourself is how you find
out what it&rsquo;s doing.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>A whole show ip interface brief</title><link>https://networkdoodles.com/labs/python-101/task-2-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-2-2/</guid><description> new to this? step by stepbeginner python, then from netlab.parse import SAMPLE and print(SAMPLE). Split each line with split() and count the words. Which line has seven? Challenge: write interfaces_to_dicts() under TODO 2.2: one dict per interface line. make check T=2.2. If it fails, read the E lines: we expected against and got. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>python</code>, then <code>from netlab.parse import SAMPLE</code> and <code>print(SAMPLE)</code>.</li>
<li>Split each line with <code>split()</code> and count the words. Which line has seven?</li>
<li>Challenge: write <code>interfaces_to_dicts()</code> under <code>TODO 2.2</code>: one dict per interface line.</li>
<li><code>make check T=2.2</code>. If it fails, read the <code>E</code> lines: <em>we expected</em> against <em>and got</em>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Columns are a picture, not data</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="what-split-sees">What split() sees</h3>
<p><code>show ip interface brief</code> lines its columns up with spaces so a person can read it. <code>split()</code>, with nothing in
the parentheses, cuts a line wherever there are spaces, however many. That works for every column but one:
<strong>Status</strong>. An interface that someone has <code>shutdown</code> shows <em>administratively down</em>, which is two words, so that
line splits into seven pieces instead of six.</p>
<p>The way out is to count from both ends. The first four columns (interface, IP address, OK?, method) and the last
one (protocol) are always one word each. Whatever is in between is the status.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Take the first four words and the last word by position; the status is everything left in the middle.</p>
<h3 id="a-loop-a-first-look">A loop, a first look</h3>
<p>This task needs one thing from lesson 3, a <strong>loop</strong>: the same lines run once for every item of a list.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">    <span class="n">words</span> <span class="o">=</span> <span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="o">...</span>
</span></span></code></pre></div><p><code>text.splitlines()</code> is a list of the lines; <code>for line in ...</code> takes each in turn and runs the indented lines
under it. Inside a loop, <code>continue</code> skips to the next line, and <code>list.append(x)</code> adds <code>x</code> to the end of a list.
<a href="/lessons/python-101/loops-and-functions/">Lesson 3</a> covers loops properly.</p>
<h3 id="two-lines-that-arent-interfaces">Two lines that aren&rsquo;t interfaces</h3>
<p>The header (<code>Interface  IP-Address ...</code>) isn&rsquo;t an interface. A blank line isn&rsquo;t either, and <code>&quot;&quot;.split()</code> is an
empty list, <code>[]</code>, so asking for its first word fails. Skip both.</p>
<h3 id="no-address-is-none">No address is None</h3>
<p>An interface without an address says <code>unassigned</code>. That&rsquo;s a word the CLI prints, not an address. In the
dicts, write it as <code>None</code>, Python&rsquo;s value for <em>nothing</em>, so that later code can ask <code>ip_address is None</code> and
never has to know which word one OS uses.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Translate CLI words into Python values once, where you parse. Everything after that works with clean data.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>Text in, a list of dicts out</h2>
  </header>
  <div class="lab-stage-body">
    <p>r1&rsquo;s output, the lab&rsquo;s <code>SAMPLE</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">Interface              IP-Address      OK? Method Status                Protocol
</span></span><span class="line"><span class="cl">GigabitEthernet0       172.80.111.11   YES DHCP   up                    up
</span></span><span class="line"><span class="cl">GigabitEthernet1       192.168.10.1    YES manual up                    up
</span></span><span class="line"><span class="cl">GigabitEthernet2       10.0.12.1       YES manual up                    up
</span></span><span class="line"><span class="cl">GigabitEthernet3       10.0.13.1       YES manual up                    up
</span></span><span class="line"><span class="cl">GigabitEthernet4       unassigned      YES unset  administratively down down
</span></span><span class="line"><span class="cl">Loopback0              10.255.0.1      YES manual up                    up
</span></span></code></pre></div><p>What <code>interfaces_to_dicts(SAMPLE)</code> returns when it&rsquo;s done: six dicts, one per interface. The first and the fifth:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">rows</span> <span class="o">=</span> <span class="n">interfaces_to_dicts</span><span class="p">(</span><span class="n">SAMPLE</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">rows</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="mi">6</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">rows</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet0&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="s1">&#39;172.80.111.11&#39;</span><span class="p">,</span> <span class="s1">&#39;ok&#39;</span><span class="p">:</span> <span class="s1">&#39;YES&#39;</span><span class="p">,</span> <span class="s1">&#39;method&#39;</span><span class="p">:</span> <span class="s1">&#39;DHCP&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;up&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">rows</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;interface&#39;</span><span class="p">:</span> <span class="s1">&#39;GigabitEthernet4&#39;</span><span class="p">,</span> <span class="s1">&#39;ip_address&#39;</span><span class="p">:</span> <span class="kc">None</span><span class="p">,</span> <span class="s1">&#39;ok&#39;</span><span class="p">:</span> <span class="s1">&#39;YES&#39;</span><span class="p">,</span> <span class="s1">&#39;method&#39;</span><span class="p">:</span> <span class="s1">&#39;unset&#39;</span><span class="p">,</span> <span class="s1">&#39;status&#39;</span><span class="p">:</span> <span class="s1">&#39;administratively down&#39;</span><span class="p">,</span> <span class="s1">&#39;protocol&#39;</span><span class="p">:</span> <span class="s1">&#39;down&#39;</span><span class="p">}</span>
</span></span></code></pre></div><p>And with no output at all, no interfaces:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">interfaces_to_dicts</span><span class="p">(</span><span class="s2">&#34;&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">[]</span>
</span></span></code></pre></div><p>The check also makes up outputs of its own, 30 of them, with sub-interfaces, VLAN interfaces, interfaces up
with the protocol down, and blank lines in odd places.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Count the words</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Start the REPL in the repo&rsquo;s folder and look at the output as Python sees it:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.parse</span> <span class="kn">import</span> <span class="n">SAMPLE</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">lines</span> <span class="o">=</span> <span class="n">SAMPLE</span><span class="o">.</span><span class="n">splitlines</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">lines</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="mi">7</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">lines</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;Interface&#39;</span><span class="p">,</span> <span class="s1">&#39;IP-Address&#39;</span><span class="p">,</span> <span class="s1">&#39;OK?&#39;</span><span class="p">,</span> <span class="s1">&#39;Method&#39;</span><span class="p">,</span> <span class="s1">&#39;Status&#39;</span><span class="p">,</span> <span class="s1">&#39;Protocol&#39;</span><span class="p">]</span>
</span></span></code></pre></div><p>Seven lines: the header and six interfaces. The header splits like any other line, so you&rsquo;ll need to tell
it apart. Its first word is a good clue.</p>
</li>
<li>
<p>Count the words on every line, with a loop:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">lines</span><span class="p">:</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>     <span class="nb">print</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">()),</span> <span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">()[</span><span class="mi">0</span><span class="p">])</span>
</span></span><span class="line"><span class="cl"><span class="o">...</span>
</span></span><span class="line"><span class="cl"><span class="mi">6</span> <span class="n">Interface</span>
</span></span><span class="line"><span class="cl"><span class="mi">6</span> <span class="n">GigabitEthernet0</span>
</span></span><span class="line"><span class="cl"><span class="mi">6</span> <span class="n">GigabitEthernet1</span>
</span></span><span class="line"><span class="cl"><span class="mi">6</span> <span class="n">GigabitEthernet2</span>
</span></span><span class="line"><span class="cl"><span class="mi">6</span> <span class="n">GigabitEthernet3</span>
</span></span><span class="line"><span class="cl"><span class="mi">7</span> <span class="n">GigabitEthernet4</span>
</span></span><span class="line"><span class="cl"><span class="mi">6</span> <span class="n">Loopback0</span>
</span></span></code></pre></div><p>Type the first line, then the indented one (four spaces), then press Enter on an empty line to run it.
GigabitEthernet4 is the one with seven.</p>
</li>
<li>
<p>Look at GigabitEthernet4&rsquo;s words, and at what a blank line gives:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">gi4</span> <span class="o">=</span> <span class="n">lines</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">gi4</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;down&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="s2">&#34;&#34;</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">[]</span>
</span></span></code></pre></div><p><code>[-1]</code> is the last word, the protocol, whatever the line&rsquo;s length. An empty list has no first word, so
<code>&quot;&quot;.split()[0]</code> would be an <code>IndexError</code>: a blank line has to be skipped before you look inside it.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> Positions from the front and from the back are both fixed; only the middle changes length.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>interfaces_to_dicts()</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>interfaces_to_dicts(text)</code> under <code>TODO 2.2</code>, in place of the <code>raise NotImplementedError(...)</code> line. It
returns a list with one dict per interface line, each with the keys <code>interface</code>, <code>ip_address</code>, <code>ok</code>,
<code>method</code>, <code>status</code> and <code>protocol</code>:</p>
<ul>
<li>every value is a string, except that an <code>unassigned</code> address is <code>None</code>;</li>
<li><em>administratively down</em> is one status, not two;</li>
<li>the header and blank lines aren&rsquo;t interfaces;</li>
<li>an output with no interface lines gives <code>[]</code>.</li>
</ul>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Start with an empty list, <code>rows = []</code>. Loop over <code>text.splitlines()</code>, split each line, and if the line has no
words, or its first word is <code>&quot;Interface&quot;</code>, <code>continue</code>. At the end, <code>return rows</code>.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>words[:4]</code> is the first four words, <code>words[-1]</code> the last, and <code>words[4:-1]</code> everything between them. On
most lines that middle is <code>['up']</code> or <code>['down']</code>; on one it&rsquo;s <code>['administratively', 'down']</code>.
<code>&quot; &quot;.join(...)</code> turns either back into one string.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>If the check says <code>assert 'unassigned' is None</code>, the word went straight into the dict.
<code>None if address == &quot;unassigned&quot; else address</code> gives <code>None</code> for that word and the address for anything else.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>ValueError: too many values to unpack (expected 6)</code> means a line like <code>a, b, c, d, e, f = line.split()</code> met
a line with seven words. <code>not enough values to unpack (expected 6, got 0)</code> is the same line meeting a blank
one.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/parse.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=2.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">interfaces_to_dicts</span><span class="p">(</span><span class="n">text</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="n">rows</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">text</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
</span></span><span class="line"><span class="cl">        <span class="n">words</span> <span class="o">=</span> <span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="ow">not</span> <span class="n">words</span> <span class="ow">or</span> <span class="n">words</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;Interface&#34;</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">            <span class="k">continue</span>
</span></span><span class="line"><span class="cl">        <span class="n">name</span><span class="p">,</span> <span class="n">address</span><span class="p">,</span> <span class="n">ok</span><span class="p">,</span> <span class="n">method</span> <span class="o">=</span> <span class="n">words</span><span class="p">[:</span><span class="mi">4</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="n">status</span> <span class="o">=</span> <span class="s2">&#34; &#34;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">words</span><span class="p">[</span><span class="mi">4</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>          <span class="c1"># &#34;up&#34;, &#34;down&#34; or &#34;administratively down&#34;</span>
</span></span><span class="line"><span class="cl">        <span class="n">rows</span><span class="o">.</span><span class="n">append</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;interface&#34;</span><span class="p">:</span> <span class="n">name</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;ip_address&#34;</span><span class="p">:</span> <span class="kc">None</span> <span class="k">if</span> <span class="n">address</span> <span class="o">==</span> <span class="s2">&#34;unassigned&#34;</span> <span class="k">else</span> <span class="n">address</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;ok&#34;</span><span class="p">:</span> <span class="n">ok</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;method&#34;</span><span class="p">:</span> <span class="n">method</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;status&#34;</span><span class="p">:</span> <span class="n">status</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;protocol&#34;</span><span class="p">:</span> <span class="n">words</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">rows</span>
</span></span></code></pre></div><p><code>not words</code> is true for an empty list, so blank lines and lines of only spaces are skipped before anything
looks inside them. The first four words are fixed, so they can be unpacked into four names at once. The
status is everything between them and the protocol, joined back up with a space, so one line of code covers
<code>up</code>, <code>down</code> and <em>administratively down</em>. This is screen-scraping by hand, and it&rsquo;s fragile on purpose: in
chapter 5 you&rsquo;ll get the same table from a regular expression and from TextFSM, and compare.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>A line of show version</title><link>https://networkdoodles.com/labs/python-101/task-2-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-2-1/</guid><description> new to this? step by stepbeginner python, then line = "CapeOS Software (CO-BOLT), Version 0.11.2, LAB USE ONLY" and line.split(","). exit(). In netlab/parse.py, replace the raise NotImplementedError under TODO 2.1a with the code in step 4 of the follow-along. make check T=2.1: three checks pass and one fails. Read the failure: it names the function still to write. Challenge: write version_line() under TODO 2.1b, then make check T=2.1 again. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>python</code>, then <code>line = &quot;CapeOS Software (CO-BOLT), Version 0.11.2, LAB USE ONLY&quot;</code> and <code>line.split(&quot;,&quot;)</code>. <code>exit()</code>.</li>
<li>In netlab/parse.py, replace the <code>raise NotImplementedError</code> under <code>TODO 2.1a</code> with the code in step 4 of the follow-along.</li>
<li><code>make check T=2.1</code>: three checks pass and one fails. Read the failure: it names the function still to write.</li>
<li>Challenge: write <code>version_line()</code> under <code>TODO 2.1b</code>, then <code>make check T=2.1</code> again.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>Text in, a dict out</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="everything-from-a-device-is-a-string">Everything from a device is a string</h3>
<p>When code reads a device&rsquo;s output, it gets text: a <strong>string</strong>. Before you can ask <em>which version is r1
running?</em>, you have to cut that text into pieces and name them. The first line of <code>show version</code> has three
parts, split by commas:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">CapeOS Software (CO-BOLT), Version 0.11.2, LAB USE ONLY
</span></span><span class="line"><span class="cl">└──── software ──┘└image┘  └─ version ──┘  └─ ignored ─┘
</span></span></code></pre></div><p>The function you write returns the three you need as a <strong>dict</strong>, a set of named values:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;software&#39;</span><span class="p">:</span> <span class="s1">&#39;CapeOS Software&#39;</span><span class="p">,</span> <span class="s1">&#39;image&#39;</span><span class="p">:</span> <span class="s1">&#39;CO-BOLT&#39;</span><span class="p">,</span> <span class="s1">&#39;version&#39;</span><span class="p">:</span> <span class="s1">&#39;0.11.2&#39;</span><span class="p">}</span>
</span></span></code></pre></div><p class="lab-recap"><span class="mono">in one sentence</span> Parse once, into a dict, and the rest of your code asks for <code>info[&quot;version&quot;]</code> instead of counting commas.</p>
<h3 id="four-string-methods">Four string methods</h3>
<table>
  <thead>
      <tr>
          <th>Method</th>
          <th>What it does</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>split(&quot;,&quot;)</code></td>
          <td>cuts the string at every comma and gives a list of the pieces</td>
      </tr>
      <tr>
          <td><code>strip()</code></td>
          <td>removes spaces from both ends</td>
      </tr>
      <tr>
          <td><code>partition(&quot;(&quot;)</code></td>
          <td>cuts once, at the first <code>(</code>, and gives three parts: before, the <code>(</code>, after</td>
      </tr>
      <tr>
          <td><code>removeprefix(&quot;Version&quot;)</code></td>
          <td>removes <code>Version</code> from the front</td>
      </tr>
  </tbody>
</table>
<p>Each one returns a <strong>new</strong> string and leaves the old one as it was, so you can chain them:
<code>piece.strip().removeprefix(&quot;Version&quot;).strip()</code>.</p>
<h3 id="what-a-check-is">What a check is</h3>
<p><code>make check T=2.1</code> runs <strong>pytest</strong>, the test runner most Python projects use, on the file
<code>checks/test_2_1.py</code>. Each function in that file whose name starts with <code>test_</code> is one check. It imports your
function, calls it, and uses <code>assert</code> to say what must be true of the answer. Some checks use the lab&rsquo;s own
line; others make up a fresh <code>show version</code> line on every run (other software names, other versions, nothing
after the second comma), so code that only works for <code>0.11.2</code> doesn&rsquo;t pass.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> The checks are code you can read: <code>checks/test_2_1.py</code> is the spec for this task.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>How to read make check</h2>
  </header>
  <div class="lab-stage-body">
    <p>Every task in this lab ends with <code>make check</code>, so it&rsquo;s worth knowing how to read it now. There are three kinds
of failure. Here&rsquo;s the first, on the starter code, before you&rsquo;ve written anything:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">task 2.1  checks/test_2_1.py
</span></span><span class="line"><span class="cl">============================= test session starts ==============================
</span></span><span class="line"><span class="cl">collecting ... collected 4 items
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">checks/test_2_1.py::test_the_lab_line FAILED                             [ 25%]
</span></span><span class="line"><span class="cl">checks/test_2_1.py::test_lines_from_the_lab_devices FAILED               [ 50%]
</span></span><span class="line"><span class="cl">checks/test_2_1.py::test_unseen_lines FAILED                             [ 75%]
</span></span><span class="line"><span class="cl">checks/test_2_1.py::test_back_into_a_line FAILED                         [100%]
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">=================================== FAILURES ===================================
</span></span><span class="line"><span class="cl">______________________________ test_the_lab_line _______________________________
</span></span><span class="line"><span class="cl">TODO 2.1a is still open: write parse_version_line() in netlab/parse.py, then check again
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">____________________________ test_back_into_a_line _____________________________
</span></span><span class="line"><span class="cl">TODO 2.1b is still open: write version_line() in netlab/parse.py, then check again
</span></span><span class="line"><span class="cl">============================== 4 failed in 0.02s ===============================
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">✗ not yet: 2.1. Each failure above says what&#39;s missing (pytest marks the line with E); the checks themselves are in checks/.
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">make: *** [Makefile:63: check] Error 1
</span></span></code></pre></div><p>Read it from the top:</p>
<table>
  <thead>
      <tr>
          <th>Part</th>
          <th>What it tells you</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>task 2.1  checks/test_2_1.py</code></td>
          <td>which task, and the file its checks are in</td>
      </tr>
      <tr>
          <td><code>collected 4 items</code></td>
          <td>pytest found four checks</td>
      </tr>
      <tr>
          <td><code>checks/test_2_1.py::test_the_lab_line FAILED</code></td>
          <td>one line per check: its file, its name, and <code>PASSED</code> or <code>FAILED</code></td>
      </tr>
      <tr>
          <td><code>[ 25%]</code></td>
          <td>how far through the file it is, nothing more</td>
      </tr>
      <tr>
          <td><code>FAILURES</code></td>
          <td>one block per failed check, each headed by its name between <code>____</code> lines</td>
      </tr>
      <tr>
          <td><code>4 failed in 0.02s</code></td>
          <td>the count</td>
      </tr>
      <tr>
          <td><code>make: *** ... Error 1</code></td>
          <td>make passing on that the check failed. Nothing is wrong with make</td>
      </tr>
  </tbody>
</table>
<p><strong>1. A TODO that&rsquo;s still open</strong> is one plain line, naming the function and the file. Nothing to decode.</p>
<p><strong>2. A wrong answer</strong> is longer. This is a <code>parse_version_line()</code> that forgot to remove the word <code>Version</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">______________________________ test_unseen_lines _______________________________
</span></span><span class="line"><span class="cl">checks/test_2_1.py:27: in test_unseen_lines
</span></span><span class="line"><span class="cl">    assert got == want, f&#34;for the line\n    {line}\nwe expected {want}\nand got      {got}&#34;
</span></span><span class="line"><span class="cl">E   AssertionError: for the line
</span></span><span class="line"><span class="cl">E         Example Router Software (EX-K9), Version 18.3.0a
</span></span><span class="line"><span class="cl">E     we expected {&#39;software&#39;: &#39;Example Router Software&#39;, &#39;image&#39;: &#39;EX-K9&#39;, &#39;version&#39;: &#39;18.3.0a&#39;}
</span></span><span class="line"><span class="cl">E     and got      {&#39;software&#39;: &#39;Example Router Software&#39;, &#39;image&#39;: &#39;EX-K9&#39;, &#39;version&#39;: &#39;Version 18.3.0a&#39;}
</span></span><span class="line"><span class="cl">E   assert {&#39;software&#39;: ...sion 18.3.0a&#39;} == {&#39;software&#39;: ...n&#39;: &#39;18.3.0a&#39;}
</span></span><span class="line"><span class="cl">E     
</span></span><span class="line"><span class="cl">E     Omitting 2 identical items, use -vv to show
</span></span><span class="line"><span class="cl">E     Differing items:
</span></span><span class="line"><span class="cl">E     {&#39;version&#39;: &#39;Version 18.3.0a&#39;} != {&#39;version&#39;: &#39;18.3.0a&#39;}
</span></span><span class="line"><span class="cl">E     ...
</span></span></code></pre></div><ul>
<li><code>checks/test_2_1.py:27: in test_unseen_lines</code> is where in the check it failed: file, line 27, which check.</li>
<li>The next line is that line of the check: the <code>assert</code> that wasn&rsquo;t true.</li>
<li>The lines starting with <strong><code>E</code></strong> are the error. The first few are the check&rsquo;s own message, written for you:
the input, <code>we expected</code>, and <code>and got</code>. Compare those two lines: the only difference is <code>Version </code>.</li>
<li>After that, pytest adds its own comparison. In <code>Differing items</code>, <strong>your</strong> value is on the left and the
expected one on the right. <code>Omitting 2 identical items</code> means the other two keys were right.</li>
<li><code>use -vv</code> and <code>Full output truncated</code> are pytest offering more detail. The check&rsquo;s message above it is
usually enough.</li>
</ul>
<p>Because this check makes up its input, the line in the message is different on every run. That&rsquo;s on purpose.</p>
<p><strong>3. Your code crashed</strong> before it could answer. Then the block is a short traceback that walks from the check
into your code, and the last line before the <code>E</code> is the line of yours that failed. From task 2.2, a version
that unpacks every line into six names:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">___________________________________ test_r1 ____________________________________
</span></span><span class="line"><span class="cl">checks/test_2_2.py:14: in test_r1
</span></span><span class="line"><span class="cl">    got = call(interfaces_to_dicts, text)
</span></span><span class="line"><span class="cl">          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">checks/conftest.py:20: in call
</span></span><span class="line"><span class="cl">    return func(*args, **kwargs)
</span></span><span class="line"><span class="cl">           ^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">netlab/parse.py:41: in interfaces_to_dicts
</span></span><span class="line"><span class="cl">    name, address, ok, method, status, protocol = line.split()
</span></span><span class="line"><span class="cl">    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
</span></span><span class="line"><span class="cl">E   ValueError: too many values to unpack (expected 6)
</span></span></code></pre></div><p><code>netlab/parse.py:41</code> is your file and line, and the <code>E</code> line is Python&rsquo;s error. (<code>conftest.py</code> is the lab&rsquo;s
code that calls your function; you can skip past it.)</p>
<p class="lab-recap"><span class="mono">in one sentence</span> Find the <code>FAILED</code> lines, then for each block read the <code>E</code> lines: the check&rsquo;s message first, <em>expected</em> against <em>got</em>.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Take the line apart</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Open a terminal. It starts in the repo&rsquo;s folder, which matters: that&rsquo;s where Python finds <code>netlab</code>. Start
the REPL and try the line:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">line</span> <span class="o">=</span> <span class="s2">&#34;CapeOS Software (CO-BOLT), Version 0.11.2, LAB USE ONLY&#34;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parts</span> <span class="o">=</span> <span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s2">&#34;,&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parts</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s1">&#39;CapeOS Software (CO-BOLT)&#39;</span><span class="p">,</span> <span class="s1">&#39; Version 0.11.2&#39;</span><span class="p">,</span> <span class="s1">&#39; LAB USE ONLY&#39;</span><span class="p">]</span>
</span></span></code></pre></div><p>Three pieces. The second and third start with a space, the one that followed each comma.</p>
</li>
<li>
<p>Clean up the version, one method at a time, and watch what each one does:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parts</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;Version 0.11.2&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parts</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span><span class="o">.</span><span class="n">removeprefix</span><span class="p">(</span><span class="s2">&#34;Version&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39; 0.11.2&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parts</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span><span class="o">.</span><span class="n">removeprefix</span><span class="p">(</span><span class="s2">&#34;Version&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;0.11.2&#39;</span>
</span></span></code></pre></div></li>
<li>
<p>And the first piece, which holds the software and the image:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">first</span> <span class="o">=</span> <span class="n">parts</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">first</span><span class="o">.</span><span class="n">partition</span><span class="p">(</span><span class="s2">&#34;(&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="s1">&#39;CapeOS Software &#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;CO-BOLT)&#39;</span><span class="p">)</span>
</span></span></code></pre></div><p>The software has a space on the end, and the image a <code>)</code>. <code>strip()</code> and <code>rstrip(&quot;)&quot;)</code> (strip from the right
only) take care of those. Leave with <code>exit()</code>.</p>
</li>
<li>
<p>Open <code>netlab/parse.py</code> and find <code>TODO 2.1a</code>. Replace the <code>raise NotImplementedError(...)</code> line, and only
that line, with:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>netlab/parse.py</code><span class="lab-file-how">Ctrl+P → parse.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl">    <span class="n">first</span><span class="p">,</span> <span class="n">second</span> <span class="o">=</span> <span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s2">&#34;,&#34;</span><span class="p">)[:</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="n">software</span><span class="p">,</span> <span class="n">_</span><span class="p">,</span> <span class="n">image</span> <span class="o">=</span> <span class="n">first</span><span class="o">.</span><span class="n">partition</span><span class="p">(</span><span class="s2">&#34;(&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;software&#34;</span><span class="p">:</span> <span class="n">software</span><span class="o">.</span><span class="n">strip</span><span class="p">(),</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;image&#34;</span><span class="p">:</span> <span class="n">image</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="s2">&#34;)&#34;</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;version&#34;</span><span class="p">:</span> <span class="n">second</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span><span class="o">.</span><span class="n">removeprefix</span><span class="p">(</span><span class="s2">&#34;Version&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">strip</span><span class="p">(),</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span></code></pre></div><p><code>[:2]</code> keeps the first two pieces, so a line with nothing after the second comma, or with more commas,
works too. <code>first, second = ...</code> gives the two a name each. <code>partition</code> gives three parts; the middle one
is the <code>(</code>, and <code>_</code> is the usual name for a value you don&rsquo;t need. Keep the indentation: four spaces, inside
the function.</p>
</li>
<li>
<p>Save, start a new REPL (it reads <code>netlab</code> once, when you import it, so changes need a fresh start), and
try your function on two lines:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netlab.parse</span> <span class="kn">import</span> <span class="n">parse_version_line</span><span class="p">,</span> <span class="n">version_line</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parse_version_line</span><span class="p">(</span><span class="s2">&#34;CapeOS Software (CO-BOLT), Version 0.11.2, LAB USE ONLY&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;software&#39;</span><span class="p">:</span> <span class="s1">&#39;CapeOS Software&#39;</span><span class="p">,</span> <span class="s1">&#39;image&#39;</span><span class="p">:</span> <span class="s1">&#39;CO-BOLT&#39;</span><span class="p">,</span> <span class="s1">&#39;version&#39;</span><span class="p">:</span> <span class="s1">&#39;0.11.2&#39;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">parse_version_line</span><span class="p">(</span><span class="s2">&#34;Example Router Software (EX-K9), Version 18.3.0a&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="s1">&#39;software&#39;</span><span class="p">:</span> <span class="s1">&#39;Example Router Software&#39;</span><span class="p">,</span> <span class="s1">&#39;image&#39;</span><span class="p">:</span> <span class="s1">&#39;EX-K9&#39;</span><span class="p">,</span> <span class="s1">&#39;version&#39;</span><span class="p">:</span> <span class="s1">&#39;18.3.0a&#39;</span><span class="p">}</span>
</span></span></code></pre></div></li>
<li>
<p>Run the check:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">make check <span class="nv">T</span><span class="o">=</span>2.1
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">checks/test_2_1.py::test_the_lab_line PASSED                             [ 25%]
</span></span><span class="line"><span class="cl">checks/test_2_1.py::test_lines_from_the_lab_devices PASSED               [ 50%]
</span></span><span class="line"><span class="cl">checks/test_2_1.py::test_unseen_lines PASSED                             [ 75%]
</span></span><span class="line"><span class="cl">checks/test_2_1.py::test_back_into_a_line FAILED                         [100%]
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">=================================== FAILURES ===================================
</span></span><span class="line"><span class="cl">____________________________ test_back_into_a_line _____________________________
</span></span><span class="line"><span class="cl">TODO 2.1b is still open: write version_line() in netlab/parse.py, then check again
</span></span><span class="line"><span class="cl">========================= 1 failed, 3 passed in 0.10s ==========================
</span></span></code></pre></div><p>Three passed, including 40 lines your function had never seen. The fourth is the challenge.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> Try each method in the REPL first, then put the ones that worked into the function.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>And back into a line</h2>
  </header>
  <div class="lab-stage-body">
    <p>Write <code>version_line(info)</code>, under <code>TODO 2.1b</code>. It takes the dict that <code>parse_version_line()</code> returns and gives
back one line: the software, the image and the version, with one space between each.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">info</span> <span class="o">=</span> <span class="n">parse_version_line</span><span class="p">(</span><span class="s2">&#34;CapeOS Software (CO-BOLT), Version 0.11.2, LAB USE ONLY&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">info</span><span class="p">[</span><span class="s2">&#34;version&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;0.11.2&#39;</span>
</span></span><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="n">version_line</span><span class="p">(</span><span class="n">info</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="s1">&#39;CapeOS Software CO-BOLT 0.11.2&#39;</span>
</span></span></code></pre></div><details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>An f-string builds a line from values: <code>f&quot;{a} {b}&quot;</code> puts <code>a</code>, a space, then <code>b</code>. Anything inside the curly
braces is worked out first, and that includes looking up a key in a dict.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Inside an f-string written with double quotes, write the dict&rsquo;s keys with single quotes:
<code>f&quot;{info['software']} ...&quot;</code>. Two sets of double quotes would end the string early.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>test_back_into_a_line</code> makes up 20 dicts and calls your function on each. If it fails, the message says what
the line should be made of.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>netlab/parse.py</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=2.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">version_line</span><span class="p">(</span><span class="n">info</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">info</span><span class="p">[</span><span class="s1">&#39;software&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">info</span><span class="p">[</span><span class="s1">&#39;image&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">info</span><span class="p">[</span><span class="s1">&#39;version&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">&#34;</span>
</span></span></code></pre></div><p>The f-string looks up each key and puts a space between them. A function this short is still worth having:
any code that needs to print a version calls it, and the format is decided in one place. An equally
good answer is <code>&quot; &quot;.join([info[&quot;software&quot;], info[&quot;image&quot;], info[&quot;version&quot;]])</code>, which glues a list of strings
together with a space.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>A venv of your own</title><link>https://networkdoodles.com/labs/python-101/task-1-2/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-1-2/</guid><description> new to this? step by stepbeginner deactivate, then python3 -m venv scratch/.venv. source scratch/.venv/bin/activate: the prompt now starts with (.venv). pip install netaddr==1.3.0, then pip freeze &gt; scratch/requirements.txt. deactivate, and python3 -c "import netaddr": it should fail. make check T=1.2, then open a new terminal to get back into the lab’s venv. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li><code>deactivate</code>, then <code>python3 -m venv scratch/.venv</code>.</li>
<li><code>source scratch/.venv/bin/activate</code>: the prompt now starts with <code>(.venv)</code>.</li>
<li><code>pip install netaddr==1.3.0</code>, then <code>pip freeze &gt; scratch/requirements.txt</code>.</li>
<li><code>deactivate</code>, and <code>python3 -c &quot;import netaddr&quot;</code>: it should fail.</li>
<li><code>make check T=1.2</code>, then open a new terminal to get back into the lab&rsquo;s venv.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>A folder that acts as a Python</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="what-a-venv-is">What a venv is</h3>
<p>A <strong>venv</strong> (virtual environment) is a folder with a Python of its own in it: <code>bin/python</code>, <code>bin/pip</code>, and its
own <code>site-packages</code> folder where installed packages go. It borrows the interpreter from the Python that made it,
and nothing else. Whatever you install into a venv stays in that venv.</p>
<p>One project, one venv. That way two projects can need different versions of the same package and never meet.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>python3 -m venv FOLDER</code> makes a venv; what you <code>pip install</code> inside it stays inside it.</p>
<h3 id="activating">Activating</h3>
<p><code>source FOLDER/bin/activate</code> puts the venv&rsquo;s <code>bin</code> first on <code>PATH</code>, so <code>python</code> and <code>pip</code> mean the venv&rsquo;s. The
prompt shows its name in parentheses. <code>deactivate</code> undoes it. You can skip activating altogether and call
<code>FOLDER/bin/python</code> by its path: it&rsquo;s the same thing.</p>
<h3 id="pinning">Pinning</h3>
<p><code>requirements.txt</code> lists a project&rsquo;s packages, one per line. <code>name==version</code> <strong>pins</strong> one exact version, so
the venv can be rebuilt identically later, by anyone, with <code>pip install -r requirements.txt</code>. <code>pip freeze</code>
prints everything installed in exactly that format.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> A pinned requirements.txt is how a venv becomes repeatable.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>Build, install, freeze</h2>
  </header>
  <div class="lab-stage-body">
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python3 -m venv scratch/.venv
</span></span><span class="line"><span class="cl">$ source scratch/.venv/bin/activate
</span></span><span class="line"><span class="cl">$ which python
</span></span><span class="line"><span class="cl">/workspaces/python-101/scratch/.venv/bin/python
</span></span><span class="line"><span class="cl">$ pip install netaddr==1.3.0
</span></span><span class="line"><span class="cl">Collecting netaddr==1.3.0
</span></span><span class="line"><span class="cl">...
</span></span><span class="line"><span class="cl">Successfully installed netaddr-1.3.0
</span></span><span class="line"><span class="cl">$ pip freeze &gt; scratch/requirements.txt
</span></span><span class="line"><span class="cl">$ cat scratch/requirements.txt
</span></span><span class="line"><span class="cl">netaddr==1.3.0
</span></span></code></pre></div><p>And outside it:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ deactivate
</span></span><span class="line"><span class="cl">$ python3 -c &#34;import netaddr&#34;
</span></span><span class="line"><span class="cl">Traceback (most recent call last):
</span></span><span class="line"><span class="cl">  File &#34;&lt;string&gt;&#34;, line 1, in &lt;module&gt;
</span></span><span class="line"><span class="cl">ModuleNotFoundError: No module named &#39;netaddr&#39;
</span></span></code></pre></div><p>That error is the result you want here.</p>

  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Make the venv</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Leave the lab&rsquo;s venv, so the new one is made from the codespace&rsquo;s Python, not from another venv:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">deactivate
</span></span><span class="line"><span class="cl">python3 -m venv scratch/.venv
</span></span></code></pre></div><p>It takes a few seconds and prints nothing. Look in the Explorer: <code>scratch/.venv/</code> now has <code>bin/</code>, <code>lib/</code>
and <code>pyvenv.cfg</code>. It&rsquo;s greyed out because <code>.gitignore</code> lists it.</p>
</li>
<li>
<p>Activate it, and check:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="nb">source</span> scratch/.venv/bin/activate
</span></span><span class="line"><span class="cl">which python
</span></span></code></pre></div><p>The prompt starts with <code>(.venv)</code>, and <code>which python</code> points into <code>scratch/.venv/bin/</code>.</p>
</li>
<li>
<p>See what&rsquo;s in it so far:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">pip list
</span></span></code></pre></div><p>Only <code>pip</code> and <code>setuptools</code>. None of the lab&rsquo;s packages: this venv is new and empty.</p>
</li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> A venv starts empty, whatever the Python that made it has.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>A package only it has</h2>
  </header>
  <div class="lab-stage-body">
    <p>With <code>scratch/.venv</code> active:</p>
<ul>
<li>install <code>netaddr</code>, pinned to version 1.3.0;</li>
<li>write <code>scratch/requirements.txt</code>, with every package in this venv pinned;</li>
<li>then leave the venv and show that <code>python3</code> outside it can&rsquo;t import <code>netaddr</code>.</li>
</ul>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>A pin goes in the install command too: <code>pip install name==version</code>.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>pip freeze</code> prints the pinned list; <code>&gt;</code> (from Linux CLI 101&rsquo;s lesson on redirection) sends it into a file
instead of the screen.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>If the last step <em>doesn&rsquo;t</em> fail, <code>netaddr</code> was installed outside the venv: you ran pip after <code>deactivate</code>.
<code>python3 -m pip uninstall netaddr</code> removes it from there.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>scratch/requirements.txt</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=1.2</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">pip install <span class="nv">netaddr</span><span class="o">==</span>1.3.0
</span></span><span class="line"><span class="cl">pip freeze &gt; scratch/requirements.txt
</span></span><span class="line"><span class="cl">deactivate
</span></span><span class="line"><span class="cl">python3 -c <span class="s2">&#34;import netaddr&#34;</span>         <span class="c1"># ModuleNotFoundError: the point</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">netaddr==1.3.0
</span></span></code></pre></div><p>The check does what you did by hand: it asks pip inside <code>scratch/.venv</code> for each pinned package and its
version, then asks the Python outside the venv for the same package, and expects it not to be there. Open a new
terminal when you&rsquo;re done, to get back into the lab&rsquo;s venv.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item><item><title>Hello, Python</title><link>https://networkdoodles.com/labs/python-101/task-1-1/</link><pubDate>Mon, 16 Nov 2026 09:00:00 -0500</pubDate><dc:creator>David Henderson</dc:creator><guid>https://networkdoodles.com/labs/python-101/task-1-1/</guid><description> new to this? step by stepbeginner New to the lab app, the editor or make? Meet the lab covers them; this task starts where its section 4 ends. In the terminal: python --version. Then python, type len("GigabitEthernet1"), and exit(). Make scripts/hello.py with one line, print("Hello, network!"), and run python scripts/hello.py. which python. Challenge: deactivate, then which python again. Fill in answers/1.1.yml, then make check T=1.1. more in meet the lab</description><content:encoded xmlns:content="http://purl.org/rss/1.0/modules/content/"><![CDATA[
<details class="lab-basics">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M4 21c0-4 4-6 8-6s8 2 8 6"/></svg>
 <span>new to this? step by step</span><em>beginner</em></summary>
  <div class="lab-basics-body">
    <ol>
<li>New to the lab app, the editor or <code>make</code>? <a href="/labs/basics/">Meet the lab</a> covers them; this task starts where its section 4 ends.</li>
<li>In the terminal: <code>python --version</code>. Then <code>python</code>, type <code>len(&quot;GigabitEthernet1&quot;)</code>, and <code>exit()</code>.</li>
<li>Make <code>scripts/hello.py</code> with one line, <code>print(&quot;Hello, network!&quot;)</code>, and run <code>python scripts/hello.py</code>.</li>
<li><code>which python</code>. Challenge: <code>deactivate</code>, then <code>which python</code> again.</li>
<li>Fill in answers/1.1.yml, then <code>make check T=1.1</code>.</li>
</ol>

    <p class="lab-basics-more mono">more in <a href="/labs/basics/">meet the lab</a></p>
  </div>
</details>


<section class="lab-stage lab-stage-explain" id="explain">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">1</span>
    <span class="lab-stage-kind mono">explain</span><h2>One interpreter, two ways in</h2>
  </header>
  <div class="lab-stage-body">
    <h3 id="the-interpreter">The interpreter</h3>
<p>Python is a program, the <strong>interpreter</strong>, that reads Python code and runs it a statement at a time. You&rsquo;ll use
it two ways in this lab:</p>
<ul>
<li>the <strong>REPL</strong>, its interactive prompt <code>&gt;&gt;&gt;</code>: type a line, get the answer back straight away;</li>
<li>a <strong>script</strong>: the same lines saved in a <code>.py</code> file, run with <code>python file.py</code>.</li>
</ul>
<p>The REPL is for trying things. A script is for keeping them. Every function you write in this lab, you&rsquo;ll try
in the REPL first.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> <code>python</code> alone opens the REPL; <code>python file.py</code> runs a script.</p>
<h3 id="a-script-prints-only-what-you-tell-it-to">A script prints only what you tell it to</h3>
<p>In the REPL, <code>2 + 2</code> shows <code>4</code>, because the REPL prints every result. In a script, nothing appears unless the
code calls <code>print()</code>.</p>
<h3 id="which-python">Which Python?</h3>
<p>A computer can have several Pythons, each with its own installed packages. The terminal runs the first one it
finds on <code>PATH</code>, and <code>which python</code> says which that is. In this lab, every new terminal starts inside the
lab&rsquo;s <strong>venv</strong>, a Python environment with the lab&rsquo;s packages in it, and the prompt shows <code>(lab)</code> to say so.
<code>deactivate</code> leaves it.</p>
<p class="lab-recap"><span class="mono">in one sentence</span> When code works in one terminal and not another, compare <code>which python</code> in both.</p>

  </div>
</section>


<section class="lab-stage lab-stage-show" id="show">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">2</span>
    <span class="lab-stage-kind mono">show</span><h2>The prompt, a script, two Pythons</h2>
  </header>
  <div class="lab-stage-body">
    <p>Starting the REPL prints the version and where it was built:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python
</span></span><span class="line"><span class="cl">Python 3.11.18 (main, Oct 28 2026, 04:42:12) [GCC 12.2.0] on linux
</span></span><span class="line"><span class="cl">Type &#34;help&#34;, &#34;copyright&#34;, &#34;credits&#34; or &#34;license&#34; for more information.
</span></span><span class="line"><span class="cl">&gt;&gt;&gt; 2 ** 10
</span></span><span class="line"><span class="cl">1024
</span></span><span class="line"><span class="cl">&gt;&gt;&gt; len(&#34;GigabitEthernet1&#34;)
</span></span><span class="line"><span class="cl">16
</span></span><span class="line"><span class="cl">&gt;&gt;&gt; exit()
</span></span></code></pre></div><p>A one-line script, and running it:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ cat scripts/hello.py
</span></span><span class="line"><span class="cl">print(&#34;Hello, network!&#34;)
</span></span><span class="line"><span class="cl">$ python scripts/hello.py
</span></span><span class="line"><span class="cl">Hello, network!
</span></span></code></pre></div><p>And the two Pythons:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ which python
</span></span><span class="line"><span class="cl">/home/vscode/.venvs/lab/bin/python
</span></span><span class="line"><span class="cl">$ deactivate
</span></span><span class="line"><span class="cl">$ which python
</span></span><span class="line"><span class="cl">/usr/local/bin/python
</span></span></code></pre></div>
  </div>
</section>


<section class="lab-stage lab-stage-follow" id="follow">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">3</span>
    <span class="lab-stage-kind mono">follow along</span><h2>Your first line of Python</h2>
  </header>
  <div class="lab-stage-body">
    <ol>
<li>
<p>Open a terminal (<strong>Terminal › New Terminal</strong>). Its prompt starts with <code>(lab)</code>. Ask Python what it is:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python --version
</span></span></code></pre></div></li>
<li>
<p>Start the REPL with <code>python</code>, and use it as a calculator for a minute: <code>2 + 2</code>, <code>10 / 4</code>, <code>10 // 4</code>,
<code>2 ** 10</code>. Then count the letters in an interface name:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="o">&gt;&gt;&gt;</span> <span class="nb">len</span><span class="p">(</span><span class="s2">&#34;GigabitEthernet1&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>Leave with <code>exit()</code>.</p>
</li>
<li>
<p>Make the script. In the Explorer, right-click the <code>scripts</code> folder › <strong>New File…</strong>, call it <code>hello.py</code>, and
give it one line:</p>
<div class="lab-file lab-file-new mono">
  <span class="lab-file-kind">new file</span><code>scripts/hello.py</code><span class="lab-file-how">Ctrl+P → hello.py</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="nb">print</span><span class="p">(</span><span class="s2">&#34;Hello, network!&#34;</span><span class="p">)</span>
</span></span></code></pre></div><p>Save it, and run it:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">python scripts/hello.py
</span></span></code></pre></div><p>The quotes and the exclamation mark matter: the check compares the line exactly.</p>
</li>
<li>
<p>Find out which Python the terminal runs:</p>
<div class="lab-file lab-file-run mono">
  <span class="lab-file-kind">run in the terminal</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">which python
</span></span></code></pre></div></li>
<li>
<p>Fill in the follow-along answers, with what <em>your</em> terminal printed:</p>
<div class="lab-file lab-file-edit mono">
  <span class="lab-file-kind">edit</span><code>answers/1.1.yml</code><span class="lab-file-how">Ctrl+P → 1.1.yml</span>
</div>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-yaml" data-lang="yaml"><span class="line"><span class="cl"><span class="nt">version</span><span class="p">:</span><span class="w">          </span><span class="m">3.11.18</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nt">venv_python</span><span class="p">:</span><span class="w">      </span><span class="l">/home/vscode/.venvs/lab/bin/python</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nt">repl_answer</span><span class="p">:</span><span class="w">      </span><span class="m">16</span><span class="w">
</span></span></span></code></pre></div></li>
</ol>
<p class="lab-recap"><span class="mono">in one sentence</span> The lab&rsquo;s Python is the venv&rsquo;s, at <code>~/.venvs/lab/bin/python</code>, and every new terminal starts in it.</p>

  </div>
</section>


<section class="lab-stage lab-stage-challenge" id="challenge">
  <header class="lab-stage-head">
    <span class="lab-stage-n mono">4</span>
    <span class="lab-stage-kind mono">challenge</span><h2>The Python outside the venv</h2>
  </header>
  <div class="lab-stage-body">
    <p>Leave the venv in this terminal and find out which Python it runs then. That&rsquo;s <code>system_python</code>.</p>
<p>Afterwards, open a new terminal: it&rsquo;s back in the venv. (<code>make</code> commands always use the venv, whichever
terminal you run them in.)</p>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p><code>deactivate</code> is a command the venv added to your shell when it was activated. Run it, and the <code>(lab)</code> in the
prompt goes away.</p>
</div>
</details>
<details class="lab-hint">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></svg>
 <span>hint</span></summary>
  <div class="lab-hint-body"><p>Then the same <code>which python</code> as before. It&rsquo;s no longer under <code>.venvs</code>.</p>
</div>
</details>
<details class="lab-solution">
  <summary class="mono"><svg class="ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M14 4h6v6M20 4l-9 9M18 14v5a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/></svg>
 <span>show the solution</span><em>answers/1.1.yml</em></summary>
  <div class="lab-solution-body">
    <p class="mono lab-solution-tip">or pull it into your lab: <code>make solve T=1.1</code>, then <code>git diff --staged</code> shows what changed</p>
    <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-yaml" data-lang="yaml"><span class="line"><span class="cl"><span class="nt">system_python</span><span class="p">:</span><span class="w">    </span><span class="l">/usr/local/bin/python</span><span class="w">
</span></span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ deactivate
</span></span><span class="line"><span class="cl">$ which python
</span></span><span class="line"><span class="cl">/usr/local/bin/python
</span></span></code></pre></div><p>That&rsquo;s the codespace&rsquo;s own Python 3.11, the one the venv was made from. It doesn&rsquo;t have Netmiko or any of the
lab&rsquo;s other packages: a venv&rsquo;s packages stay inside the venv. Run <code>python -c &quot;import netmiko&quot;</code> here and you get
<code>ModuleNotFoundError</code>; in a new terminal, inside the venv, the same line prints nothing, because it worked.</p>
  </div>
</details>

  </div>
</section>

]]></content:encoded></item></channel></rss>