David Landup

Lazar Ristic

In this detailed guide, we'll take a look at how to create a Discord bot in JavaScript with Discord.js v13. It'll react and respond to messages, handle commands and welcome users with a custom presence.

Guide to Creating a Discord Bot in JavaScript with Discord.js v13

<h2 id="introduction">Introduction</h2>
Parsing URLs is a common task to perform during web development, and also one that seems to be simple but can get complex. It's not often that you come across a module that makes parsing so easy that you don't have to think a lot yourself.
Despite being relatively young (published in June 2021), with almost 3 million weekly downloads, <a target="_blank" href="https://www.npmjs.com/package/parse-url">parse-url</a> is one of the top modules for parsing URLs in JavaScript.
<blockquote>
In this article, we'll be taking a look at all of its possibilities and how it makes our lives easier.
</blockquote>
<h2 id="partsofanurl">Parts of an URL</h2>
A URL has many parts, so breaking it up in bits and pieces without pure string parsing is a powerful tool to have. Every URL has the same main parts, with other parts being optional depending on the query or action.
The constituent elements of an URL are:
<ul>
<li>Scheme - used to identify the protocol being used to fetch the resource on the Internet
<ul>
<li>Some of the more popular protocols are: HTTP, HTTPS, IP, ICMP, TCP, UDP, etc.</li>
</ul>
</li>
<li>Host - the name of the host that has the resource we're getting (<code>www.somehost.com</code>)</li>
<li>Path - the path to the resource located on the host (<code>www.somehost.com/path/to/index.html</code>)</li>
<li>Query string - string containing key-value pairs (<code>www.somehost.com/index?key=value&amp;key2=value2</code>)</li>
</ul>
These are the main chunks of the URL, but we'll see that we can retrieve even more with parse-url, in a very readable and again, parsable format.
<h2 id="installingandsettinguptheparseurlmodule">Installing and Setting up the parse-url Module</h2>
We start by creating a folder for our mini project called <code>parse_url</code>. In the folder, we can install the module using <code>npm</code>:
<pre><code class="hljs">$ npm i parse-url
</code></pre>
To use the module in our code (in the index.js file), we must <code>require</code> it:
<pre><code class="hljs">const parseUrl = require(&#x27;parse-url&#x27;);
</code></pre>
That's it, we're good to go! Let's see what this module offers.
<h2 id="parsingtheurl">Parsing the URL</h2>
To start, let's take a simple URL: <code>https://www.stackabuse.com</code>. The constructor for <code>parseUrl</code> takes in two parameters, <code>string_url</code> and <code>normalize</code>, with <code>normalize</code> being optional.
By default, it is set to <code>false</code> and it's assumed that the URLs being supplied are already normalized. When <code>true</code>, it transforms a non-normalized URL to a normalized one. For example:
<pre><code class="hljs">someRandomUrl.com:80 --&gt; http://someRandomUrl.com
</code></pre>
This is called URL normalization. The <code>parse-url</code> module bases its normalization on the <code>normalize-url</code> module and the <code>normalize-url</code> module works exactly as shown above.
Let's parse a URL:
<pre><code class="hljs">const url = &#x27;https://www.stackabuse.com/&#x27;;
const parsedUrl = parseUrl(url);

console.log(parsedUrl)
</code></pre>
The output of the code will be in JSON format, which consists of the elements of that URL:
<pre><code class="hljs">{
 protocols: [ &#x27;https&#x27; ],
 protocol: &#x27;https&#x27;,
 port: null,
 resource: &#x27;www.stackabuse.com&#x27;,
 user: &#x27;&#x27;,
 pathname: &#x27;&#x27;,
 hash: &#x27;&#x27;,
 search: &#x27;&#x27;,
 href: &#x27;https://www.stackabuse.com&#x27;,
 query: [Object: null prototype] {}
}
</code></pre>
As you can see there is a lot of things that were extracted, although, some are empty since the URL we've provided is pretty bare. Let's take a look at the elements in this JSON:
<ul>
<li><code>protocols</code> - list of protocols used in the URL (can be more the one)</li>
<li><code>protocol</code> - first of <code>protocols</code></li>
<li><code>port</code> - a port (if supplied)</li>
<li><code>resource</code> - the host</li>
<li><code>user</code> - user at the host's server (user@host)</li>
<li><code>pathname</code> - path to resource</li>
<li><code>hash</code> - if supplied, info after the <code>#</code> (hash) - usually anchors on a web page</li>
<li><code>search</code> - a query string</li>
<li><code>href</code> - the full URL</li>
</ul>
An interesting example is found using GitHub links, which were one of the reasons this module was created in the first place. GitHub links can get pretty complex and convoluted compared to other URLs you see on a daily basis, and can include multiple protocols and users:
<pre><code class="hljs">const url = &#x27;git+ssh://git@somehost.com/path/to/resource.git&#x27;;
const parsedUrl = parseUrl(url);

console.log(parsedUrl)
</code></pre>
This results in:
<pre><code class="hljs">{
 protocols: [ &#x27;git&#x27;, &#x27;ssh&#x27; ],
 protocol: &#x27;git&#x27;,
 port: null,
 resource: &#x27;somehost.com&#x27;,
 user: &#x27;git&#x27;,
 pathname: &#x27;/path/to/resource.git&#x27;,
 hash: &#x27;&#x27;,
 search: &#x27;&#x27;,
 href: &#x27;git+ssh://git@somehost.com/path/to/resource.git&#x27;,
 query: [Object: null prototype] {}
}
</code></pre>
The list protocol here has changed, since there are multiple protocols in use. However, the first one is referred to when printing out the URL info. We can also see <code>pathname</code> is now filled with the path to the resource.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 One of the selling points of <code>parse-url</code> is the fact that it works so well with Git URLs.

 </div>
 </div>
 </div>
 Let's really up the URL and include a hash and a couple of key-value queries:
<pre><code class="hljs">const url = &#x27;git+ssh://git@somehost.com:30/path/to/resource.git?key1=value1&amp;key2=value2#anchor&#x27;;
const parsedUrl = parseUrl(url);

console.log(parsedUrl)
</code></pre>
This example differs from the previous one just a little bit, just enough to fill out the empty values in the previous example. The output will be:
<pre><code class="hljs">{
 protocols: [ &#x27;git&#x27;, &#x27;ssh&#x27; ],
 protocol: &#x27;git&#x27;,
 port: 30,
 resource: &#x27;somehost.com&#x27;,
 user: &#x27;git&#x27;,
 pathname: &#x27;/path/to/resource.git&#x27;,
 hash: &#x27;anchor&#x27;,
 search: &#x27;key1=value1&amp;key2=value2&#x27;,
 href: &#x27;git+ssh://git@somehost.com:30/path/to/resource.git?key1=value1&amp;key2=value2#anchor&#x27;,
 query: [Object: null prototype] { key1: &#x27;value1&#x27;, key2: &#x27;value2&#x27; }
}
</code></pre>
The port, hash and query are present now - and we've even got the keys and values for the query! Having the parsed data be structured in a human-readable format, that's also universally accepted and easily parsable is a really helping hand when parsing URLs.
Though, this is only the pretty-printed output of the returned object. What allows us to really work with these parsed elements is the fact that they're all fields of the returned object, which we can easily access:
<pre><code class="hljs">console.log(&quot;The protocols used in the URL are &quot; + parsedUrl.protocols);
console.log(&quot;The port used in the URL is &quot; + parsedUrl.port);
console.log(&quot;The resource in the URL is &quot; + parsedUrl.resource);
console.log(&quot;The user in the URL is &quot; + parsedUrl.user);
console.log(&quot;The pathname in the URL is &quot; + parsedUrl.pathname);
console.log(&quot;The hash in the URL is &quot; + parsedUrl.hash);
console.log(&quot;The search part in the URL is &quot; + parsedUrl.search);
console.log(&quot;Full URL is &quot; + parsedUrl.href);
</code></pre>
Running this code results in:
<pre><code class="hljs">The protocols used in the URL are git,ssh
The port used in the URL is 30
The resource in the URL is somehost.com
The user in the URL is git
The pathname in the URL is /path/to/resource.git
The hash in the URL is anchor
The search part in the URL is key1=value1&amp;key2=value2
Full URL is git+ssh://git@somehost.com:30/path/to/resource.git?key1=value1&amp;key2=value2#anchor
</code></pre>
Finally, let's see the results of URL normalization. If we pass an unnormalized URL, such as <code>stackabuse.com:3000/path/to/index.html#anchor</code>, as a URL string:
<pre><code class="hljs">const url = &#x27;stackabuse.com:3000/path/to/index.html#anchor&#x27;;
const parsedUrl = parseUrl(url, true);
console.log(parsedUrl);
</code></pre>
This results in:
<pre><code class="hljs">{
 protocols: [ &#x27;http&#x27; ],
 protocol: &#x27;http&#x27;,
 port: 3000,
 resource: &#x27;stackabuse.com&#x27;,
 user: &#x27;&#x27;,
 pathname: &#x27;/path/to/index.html&#x27;,
 hash: &#x27;anchor&#x27;,
 search: &#x27;&#x27;,
 href: &#x27;http://stackabuse.com:3000/path/to/index.html#anchor&#x27;,
 query: [Object: null prototype] {}
}
</code></pre>
We can see that the parser automatically assigned <code>http</code> as the protocol and filled out the <code>href</code> property correctly. The missing parts are not filled in, since they weren't supplied to begin with.
If we were to disable the normalization feature, while providing a non-normalized URL, the results would be off:
<pre><code class="hljs">{
 protocols: [],
 protocol: &#x27;file&#x27;,
 port: null,
 resource: &#x27;&#x27;,
 user: &#x27;&#x27;,
 pathname: &#x27;stackabuse.com:3000/path/to/index.html&#x27;,
 hash: &#x27;anchor&#x27;,
 search: &#x27;&#x27;,
 href: &#x27;stackabuse.com:3000/path/to/index.html#anchor&#x27;,
 query: [Object: null prototype] {}
}
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: If you set <code>normalize</code> to <code>true</code> and supply an already-normalized URL, nothing really happens, and it's parsed correctly. Given this - you'll typically want to set the parameter to true.

 </div>
 </div>
 </div>
 Since <code>parsedUrl</code> is an object, its properties can be changed. We can simply access any property and change it:
<pre><code class="hljs">console.log(parsedUrl.port) // 3000
parsedUrl.port = 4000
console.log(parsedUrl.port) // 4000
</code></pre>
However, this is not the desired behavior and shouldn't be done, since this module is used solely to parse the URLs. The only time you should alter the <code>parsedUrl</code> object like this is when you are confident in the value of some property, otherwise, you might be shooting yourself in the leg.
<h2 id="conclusion">Conclusion</h2>
We've seen <code>parse-url</code> lets us pretty easily parse URLs without any additional processing, and makes the process of parsing URLs extremely simple and readable.
It splits everything up as desired and creates an <code>parsedUrl</code> object that can be accessed just like any other object, as well as changed. The module is as simple as they come, with a neat output and syntax and as straightforward as possible, resulting in quick and precise results.

In this practical easy guide, learn how to easily parse URLs in JavaScript using parse-url. Get the domain, host name, query parameters and more in a single line of code!

Easily Parse URLs in JavaScript with parse-url

<h2 id="introduction">Introduction</h2>
Java is a type-safe, verbose language. There are advantages to this, but also some drawbacks. Namely - there's oftentimes a lot of boilerplate code and simple operations such as printing an array aren't as simple as supplying it to the <code>println()</code> method:
<pre><code class="hljs">int[] array = new int[]{1, 2, 3, 4, 5, 6};
System.out.println(array);
</code></pre>
This results in the hashes of object reference in memory, not its contents:
<pre><code class="hljs">[I@7c3df479
</code></pre>
This is because Java's arrays don't override the <code>toString()</code> method of the <code>Object</code> class, and just return the hash of the object itself. This is an obviously missing feature in the language, and it's not exactly clear why such a feature would be missing, especially with other languages having support for printing such fundamental data structures.
<blockquote>
In this guide, we'll take a look at several ways of printing arrays in one line - utilizing the built-in helper methods and the Stream API, weighing the differences between the approaches and when to use which one.
</blockquote>
<h2 id="arraystostring">Arrays.toString()</h2>
The simplest and most straightforward way to print an array in a single line is to use the helper <code>Arrays</code> class, residing in the <code>java.util</code> package:
<pre><code class="hljs">int[] array = new int[]{1, 2, 3, 4, 5, 6};
System.out.println(Arrays.toString(array));
</code></pre>
Under the hood, it uses a <code>StringBuilder</code> to append each element through a simple <code>for</code> loop, and you get a result you might expect when printing an array as-is:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6]
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: This approach fails on nested arrays, in which case, an element is an array, so its reference to the object in memory is added instead of its contents.

 </div>
 </div>
 </div>
 So, this 2D array can't be printed with <code>Arrays.toString()</code>:
<pre><code class="hljs">int[][] array = new int[][]{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}};
System.out.println(Arrays.toString(array));
</code></pre>
And results in:
<pre><code class="hljs">[[I@7c3df479, [I@7106e68e]
</code></pre>
<h2 id="arraysdeeptostring">Arrays.deepToString()</h2>
If you'd like to work with nested arrays, you can use the <code>deepToString()</code> method instead:
<pre><code class="hljs">int[][] array = new int[][]{{1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}};
System.out.println(Arrays.deepToString(array));
</code></pre>
This results in the expected output:
<pre><code class="hljs">[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]
</code></pre>
<h2 id="printarrayinonelinewithjavastreams">Print Array in One Line with Java Streams</h2>
<code>Arrays.toString()</code> and <code>Arrays.toDeepString()</code> just print the contents in a fixed manner and were added as convenience methods that remove the need for you to create a manual <code>for</code> loop. When printing though, you might want to format the output a bit, or perform additional operations on the elements while going through them.
The Stream API was added in Java 8, as one of the first steps in introducing the Functional Programming paradigm into Java. Generally, when printing an array with a <code>Stream</code>, you'll call the <code>forEach()</code> method, though there are multiple ways of <a target="_blank" href="https://stackabuse.com/java-convert-array-to-stream/">obtaining a Stream from an Array</a>.
<blockquote>
If you'd like to read more about the <code>forEach()</code> method, read our <a target="_blank" href="https://stackabuse.com/guide-to-java-streams-foreach-with-examples/">Guided to Stream.forEach() in Java</a>!
</blockquote>
The easiest way to obtain a Stream from an Array is the <code>Stream.of()</code> method, which can be used with other collections as well (but depends on the data type), though you could also use <code>Arrays.stream()</code> (more robust) or convert the array to a list and stream that (a bit redundant though) via <code>Arrays.asList().stream()</code>.
From all of these - you'll most likely be using the <code>Arrays.stream()</code> method as it doesn't concern itself with whether the elements are a primitive type or an object, which is a concern when using the <code>Stream.of()</code> method.
With <code>Stream.of()</code>, depending on the data type you're using, you'll either use a <code>Stream</code> or a derived variant, such as <code>IntStream</code>. This is important, lest the code return a hash instead of the contents.
<pre><code class="hljs">int[] intArray = new int[]{1, 2, 3, 4, 5, 6};
String[] objArray = new String[]{&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};

// If using Stream.of(), primitive types need to be flatmapped
Stream.of(intArray).flatMapToInt(Arrays::stream).forEach(System.out::print);
IntStream.of(intArray).forEach(System.out::print);
// Stream.of() with objects
Stream.of(objArray).forEach(System.out::print);

// Arrays.stream() works with both primitive types and objects
Arrays.stream(intArray).forEach(System.out::print);
Arrays.stream(objArray).forEach(System.out::print);

// If using asList(), primitive types need to be flatMapped
Arrays.asList(intArray).stream().flatMapToInt(Arrays::stream).forEach(System.out::print);
Arrays.asList(objArray).stream().forEach(System.out::print);
</code></pre>
These all result in:
<pre><code class="hljs">123456
JavaPythonJavaScript
</code></pre>
Generally speaking, the <code>Arrays.stream()</code> method is the safest one to use and is also the shortest/most readable one.
Although not very stylized right now - using Streams allows you to add any intermediary operation in the pipeline, so if you'd like to collect these with a delimiter, for instance, you could use a <code>Collector</code>:
<pre><code class="hljs">System.out.println(Arrays.stream(objArray).collect(Collectors.joining(&quot;,&quot;)));
</code></pre>
This results in:
<pre><code class="hljs">Java,Python,JavaScript
</code></pre>
You can get creative here, with multiple operations, such as transforming the values, filtering them and then joining:
<pre><code class="hljs">String[] objArray = new String[]{&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};

System.out.println(Arrays.stream(objArray)
 map(String::toUpperCase)
 filter(e -&gt; e.startsWith(&quot;J&quot;))
 collect(Collectors.joining(&quot;,&quot;)));
</code></pre>
Which maps all of the elements to their counterparts in upper case, filters given a predicate (that an element starts with &quot;J&quot;) and then joins them with a delimiter:
<pre><code class="hljs">JAVA,JAVASCRIPT
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to print an array in Java in a single line - a feature that's missing by default.
We've taken a look at how to print arrays via the built-in helper methods of the <code>Arrays</code> class, as well as how to utilize the Stream API to customize this process.

In this short tutorial, we'll take a look at how to print an array in a single line in Java, using Arrays.toString(), Arrays.deepToString(), the Stream API and other methods.

Java - How to Print an Array in One Line

<h2 id="introduction">Introduction</h2>
The Portable Document Format (PDF) is not a WYSIWYG (What You See is What You Get) format. It was developed to be platform-agnostic, independent of the underlying operating system and rendering engines.
To achieve this, PDF was constructed to be interacted with via something more like a programming language, and relies on a series of instructions and operations to achieve a result. In fact, PDF is based on a scripting language - <a rel="nofollow noopener noreferrer" target="_blank" href="https://www.adobe.com/products/postscript.html">PostScript</a>, which was the first device-independent Page Description Language.
In this guide, we'll be using <a rel="nofollow noopener noreferrer" target="_blank" href="https://borbpdf.com/">borb</a> - a Python library dedicated to reading, manipulating and generating PDF documents. It offers both a low-level model (allowing you access to the exact coordinates and layout if you choose to use those) and a high-level model (where you can delegate the precise calculations of margins, positions, etc to a layout manager).
Matplotlib is a data visualization library that fueled an entire generation of engineers to start visualizing data, and the engine behind many other popular libraries such as Seaborn.
Given how common PDF documents are for creating reports (which oftentimes include graphs), we'll take a look at how to integrate Matplotlib charts in a PDF document using borb.
<h2 id="installingborbandmatplotlib">Installing borb (and Matplotlib)</h2>
borb can be downloaded from source on <a rel="nofollow noopener" target="_blank" href="https://github.com/jorisschellekens/borb">GitHub</a>, or installed via <code>pip</code>:
<pre><code class="hljs">$ pip install borb
</code></pre>
Matplotlib can be installed via <code>pip</code>:
<pre><code class="hljs">$ pip install matplotlib
</code></pre>
<h2 id="integratingmatplotlibchartsinpdfdocumentswithborb">Integrating Matplotlib Charts in PDF Documents with borb</h2>
Before we can create a chart, such as a Pie Chart, we're going to write a small utility function that generates <code>N</code> colors, evenly distributed among the color-spectrum.
This will help us whenever we need to create a plot and color each section:
<pre><code class="hljs">from borb.pdf.canvas.color.color import HSVColor, HexColor
from decimal import Decimal
import typing

def create_n_colors(n: int) -&gt; typing.List[str]:
 # The base color is borb-blue
 base_hsv_color: HSVColor = HSVColor.from_rgb(HexColor(&quot;56cbf9&quot;))
 # This array comprehension creates n HSVColor objects, transforms then to RGB, and then returns their hex string
 return [HSVColor(base_hsv_color.hue + Decimal(x / 360), Decimal(1), Decimal(1)).to_rgb().to_hex_string() for x in range(0, 360, int(360/n))]
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: HSL (hue, saturation, lightness) and HSV/HSB (hue, saturation, value/hue, saturation, brightness) are alternative representations of the RGB color model.

 </div>
 </div>
 </div>
 HSL and HSV/HSB were designed in the 1970s by computer graphics researchers to more closely align with the way human vision perceives color-making attributes. In these models, colors of each hue are arranged in a radial slice, around a central axis of neutral colors which ranges from black at the bottom to white at the top:
<img src="https://s3.stackabuse.com/media/articles/integrating-matplotlib-charts-in-a-pdf-in-python-with-borb-2.png" alt="hsv cone spectrum"> 
Credits: Wikimedia (CC BY-SA 3.0) license
The advantage of using this representation for <code>Color</code> is that we can easily divide the color-spectrum in equal parts.
Now we can define a <code>create_pie_chart()</code> function (or a function for other types of plots):
<pre><code class="hljs"># New import(s)
import matplotlib.pyplot as plt
from borb.pdf.canvas.layout.image.chart import Chart
from borb.pdf.canvas.layout.layout_element import Alignment

def create_piechart(labels: typing.List[str], data: typing.List[float]):

 # Symetric figure to ensure equal aspect ratio
 fig1, ax1 = plt.subplots(figsize=(4, 4))
 ax1.pie(
 data,
 explode=[0 for _ in range(0, len(labels))],
 labels=labels,
 autopct=&quot;%1.1f%%&quot;,
 shadow=True,
 startangle=90,
 colors=create_n_colors(len(labels)),
 )

 ax1.axis(&quot;equal&quot;) # Equal aspect ratio ensures that pie is drawn as a circle.

 return Chart(
 plt.gcf(),
 width=Decimal(200),
 height=Decimal(200),
 horizontal_alignment=Alignment.CENTERED,
 )
</code></pre>
Here, we've used Matplotlib to create a pie chart, via the <code>pie()</code> function.
<blockquote>
If you'd like to learn more about creating Pie Charts, read our <a target="_blank" href="https://stackabuse.com/matplotlib-pie-chart-tutorial-and-examples/">Guide to Matplotlib Pie Charts</a>!
</blockquote>
The <code>gcf()</code> function of the <code>PyPlot</code> instance returns the current figure (get current figure). This figure can be embedded into a PDF document, by injecting it in a <code>Chart</code> constructor, alongside your customization arguments such as the <code>width</code>, <code>height</code> and <code>horizontal_alignment</code>.
That's it! You just supply a Matplotlib figure to the <code>Chart</code> constructor.
<h2 id="addingamatplotlibcharttoapdfdocument">Adding a Matplotlib Chart to a PDF Document</h2>
Now it's time to create our basic PDF <code>Document</code> and add content to it.
<pre><code class="hljs"># New import(s)
from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF
from borb.pdf.canvas.layout.page_layout.multi_column_layout import MultiColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout
from borb.pdf.canvas.layout.text.paragraph import Paragraph

# Create empty Document
pdf = Document()

# Create empty Page
page = Page()

# Add Page to Document
pdf.append_page(page)

# Create PageLayout
layout: PageLayout = MultiColumnLayout(page)

# Write title
layout.add(Paragraph(&quot;About Lorem Ipsum&quot;, 
 font_size=Decimal(20), 
 font=&quot;Helvetica-Bold&quot;))

</code></pre>
We'll be using hyphenation in this PDF to ensure the text can be laid out even more smoothly. Hyphenation in borb is pretty straightforward:
<pre><code class="hljs"># New import(s)
from borb.pdf.canvas.layout.hyphenation.hyphenation import Hyphenation

# Create hyphenation algorithm
hyphenation_algorithm: Hyphenation = Hyphenation(&quot;en-gb&quot;)

# Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
 Lorem Ipsum has been the industry&#x27;s standard dummy text ever since the 1500s, 
 when an unknown printer took a galley of type and scrambled it to make a type specimen book. 
 It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. 
 It was popularized in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, 
 and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))
</code></pre>
Now we can add a pie chart using the function we declared earlier;
<pre><code class="hljs"># Write graph
layout.add(create_piechart([&quot;Loren&quot;, &quot;Ipsum&quot;, &quot;Dolor&quot;], 
 [0.6, 0.3, 0.1]))
</code></pre>
Next we're going to write three more <code>Paragraph</code> objects. 
One of them is going to be more of a quote (border on the side, different font, etc).
<pre><code class="hljs"># Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Contrary to popular belief, Lorem Ipsum is not simply random text. 
 It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. 
 Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, 
 consectetur, from a Lorem Ipsum passage, and going through the cities of the word in classical literature, 
 discovered the undoubtable source.
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))

# Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
 &quot;&quot;&quot;, 
 font=&quot;Courier-Bold&quot;,
 text_alignment=Alignment.JUSTIFIED, 
 hyphenation=hyphenation_algorithm,
 border_color=HexColor(&quot;56cbf9&quot;),
 border_width=Decimal(3),
 border_left=True,
 padding_left=Decimal(5),
 padding_bottom=Decimal(5),
))

# Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of &quot;de Finibus Bonorum et Malorum&quot; 
 (The Extremes of Good and Evil) by Cicero, written in 45 BC. 
 This book is a treatise on the theory of ethics, very popular during the Renaissance.
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))
</code></pre>
Let's add another plot
<pre><code class="hljs"># Write graph
layout.add(create_piechart([&quot;Loren&quot;, &quot;Ipsum&quot;, &quot;Dolor&quot;, &quot;Sit&quot;, &quot;Amet&quot;], 
 [600, 30, 89, 100, 203]))
</code></pre>
And one more <code>Paragraph</code> of content
<pre><code class="hljs"># Write paragraph
layout.add(Paragraph(
 &quot;&quot;&quot;
 It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. 
 The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using &#x27;Content here, content here&#x27;, 
 making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, 
 and a search for &#x27;lorem ipsum&#x27; will uncover many websites still in their infancy. 
 Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humor and the like).
 &quot;&quot;&quot;, text_alignment=Alignment.JUSTIFIED, hyphenation=hyphenation_algorithm))
</code></pre>
Finally, we can store the <code>Document</code>:
<pre><code class="hljs"># Write to disk
with open(&quot;output.pdf&quot;, &quot;wb&quot;) as pdf_file_handle:
 PDF.dumps(pdf_file_handle, pdf)
</code></pre>
Running this code results in a PDF document that looks like this:
<img src="https://s3.stackabuse.com/media/articles/integrating-matplotlib-charts-in-a-pdf-using-borb-1.PNG" alt="integrating matplotlib charts in pdf with python and borb">
<h2 id="conclusion">Conclusion</h2>
In this guide you've learned how to integrate Matplotlib charts in a PDF using <code>borb</code>. From here, the sky's the limit! The more creative you get with data visualization, the nicer your PDFs will be.

Joris Schellekens

Integrating Matplotlib Charts in a PDF in Python With borb

Branko Ilic

Jovana Ninkovic

In this guide, we'll take a look at the theory and implementation of Heap Sort in Java - we'll be implementing it via a Heap and a PriorityQueue.

Heap Sort in Java

In this detailed guide, we'll take a look at Prim's Algorithm and how to find an MST (Minimum Spanning Tree) in a graph in Java in theory and practice.

Graphs in Java: Minimum Spanning Trees - Prim's Algorithm

<h2 id="introduction">Introduction</h2>
Axios is a JavaScript library for making HTTP requests, either in the browser or Node.js.
Unlike the popular <a target="_blank" href="/the-node-js-request-module/">Requests</a> library, Axios is natively promise-based, making it more suitable for modern applications taking advantage of newer JavaScript features, like Promises and the async/await syntax.
If you're experienced in web development and would just like to find an answer as to how to send a PUT request with Axios - the long story short is:
<pre><code class="hljs">const axios = require(&#x27;axios&#x27;);

// Wrapper, specific put() function
const res = await axios.put(&#x27;/api/article/123&#x27;, {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
});

// General HTTP function
const res = await axios({
 method: &#x27;put&#x27;,
 url: &#x27;/api/article/123&#x27;,
 data: {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
 }
});
</code></pre>
However, if you're new to working with Axios or would like to know more about how this works - read on!
<h2 id="httprequestsandverbs">HTTP Requests and Verbs</h2>
The modern web is built on the HTTP protocol and a request-response lifecycle, where a client requests a resource, and a server responds with it.
The HTTP protocol defines a number of methods with varying intentions, namely <code>GET</code>, <code>POST</code>, <code>DELETE</code>, etc. which allow a client to &quot;state&quot; their intention. One of the more common HTTP methods is the <code>PUT</code> method, which is most commonly used for sending data to a server, either for creating a new resource or for patching or editing data on an existing resource.
For instance, a REST API service for a blog may have a route that allows you to perform CRUD (Create, Read, Update, Delete) operations on the <code>article</code> resource using the path <code>/api/article/[id]</code>.
Sending a <code>GET</code> request to this route might return the article specified by the <code>id</code>. Sending a <code>PUT</code> request to this path would edit the specified attributes article. These attributes can be specified in the body of the request, which is serialized to JSON format by default.
<blockquote>
If you'd like to read more about creating REST APIs with Node.js - read our <a target="_blank" href="https://stackabuse.com/building-a-rest-api-with-node-and-express/">Guide to Building a REST API with Node and Express</a>!
</blockquote>
<h2 id="sendingaputrequestwithaxios">Sending a PUT Request with Axios</h2>
Let's see how we can use the Axios library to send an HTTP PUT request from your JavaScript application.
First, you can install <code>axios</code> using <code>yarn</code> or <code>npm</code>:
<pre><code class="hljs">$ npm install axios --save
</code></pre>
<pre><code class="hljs">$ yarn add axios
</code></pre>
It's also available for frontend applications via a number of CDNs, such as jsDelivr:
<pre><code class="hljs">&lt;script src=&quot;https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js&quot;&gt;&lt;/script&gt;
</code></pre>
Once the library is installed, you'll need to instantiate an instance:
<pre><code class="hljs">const axios = require(&#x27;axios&#x27;);
</code></pre>
The simplest way to make the <code>PUT</code> call is to simply use the <code>put()</code> function of the <code>axios</code> instance, and supply the body of that request in the form of a JavaScript object:
<pre><code class="hljs">const res = await axios.put(&#x27;/api/article/123&#x27;, {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
});
</code></pre>
The only arguments needed here are the URL and the data you wish to send, which in our case is the title in which we want to edit the article resource.
The JavaScript object we've created to hold the <code>title</code> and <code>status</code> is serialized into JSON, sent to a request handler, which performs an action and returns a result. The <code>body</code> of the request we're sending is the serialized JSON, which can easily be retrieved on the back-end.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Since JSON is being sent - which is a very universal format, most frameworks will have no issues reading the sent data and deserializing it into whatever representation the back-end uses, regardless of the tech stack.

 </div>
 </div>
 </div>
 The object returned by Axios, <code>res</code> in this case, has a standard schema for all calls:
<pre><code class="hljs">{
 data: {},
 status: 200,
 statusText: &#x27;OK&#x27;,
 headers: {},
 config: {},
 request: {}
}
</code></pre>
Where:
<ul>
<li><code>data</code>: The data returned by the service you called - typically, a JSON response from a REST API.</li>
<li><code>status</code>: The HTTP status returned by the service, denoting how the operation went - like 200 (OK), 301 (Moved Permanently), 404 (Not Found), etc.</li>
<li><code>statusText</code>: The HTTP status text describing the status code in a human-readable format - like 'OK', 'Moved Permanently', or 'Not Found'.</li>
<li><code>headers</code>: An object containing all headers returned by the service, like 'Cache-Control'.</li>
<li><code>config</code>: The config object provided to the call (optional).</li>
<li><code>request</code>: The request object for this call, which is a <code>ClientRequest</code> in Node.js or <code>XMLHttpRequest</code> in the browser.</li>
</ul>
Another way to make a PUT request with Axios is a more generic method in which you specify the HTTP method within the arguments.
This is done by using the <code>axios()</code> default method and config object:
<pre><code class="hljs">const res = await axios({
 method: &#x27;put&#x27;,
 url: &#x27;/api/article/123&#x27;,
 data: {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
 }
});
</code></pre>
The result of this call is exactly the same as the <code>axios.put()</code> call from earlier - the only difference being that the <code>axios.put()</code> method is a convenience method that wraps the general method, imbuing it with the <code>method: 'put'</code> field.
<h2 id="axiosvsput">axios() vs put()</h2>
So why would you use one method over the other? That may depend on a few factors, like readability or the context in which the method is used, but also to a large degree - your personal preference.
The more generic <code>axios()</code> call is more flexible since all options/configs are specified within the same object, making it easier to add more configs, like headers for example, or switching method verbs.
Since the <code>put()</code> method just wraps <code>axios()</code>, the underlying functionality is fundamentally the same.
<h2 id="handlingerrors">Handling Errors</h2>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: When sending requests - you might not always get an expected result back.

 </div>
 </div>
 </div>
 Generally speaking - you'll want to try sending a request, and catch exceptions if they arise in that process, which changes the call procedure a tiny bit:
<pre><code class="hljs">try {
 const { data } = await axios({
 method: &#x27;put&#x27;,
 url: &#x27;/api/article/123&#x27;,
 data: {
 title: &#x27;Making PUT Requests with Axios&#x27;,
 status: &#x27;published&#x27;
 }
 });

 console.log(data);
} catch (err) {
 if (err.response.status === 404) {
 console.log(&#x27;Resource could not be found!&#x27;);
 } else {
 console.log(err.message);
 }
}
</code></pre>
The main difference here is the error handling, which uses the <code>response</code> object within the error to determine the cause rather than the <code>data</code> object returned from the call itself.
Typically, error-handling is more robust than just checking whether the status is a single integer - however, this way you can alter the flow of the logic based on how the request was handled (or wasn't).
<h2 id="conclusion">Conclusion</h2>
In this article we gave a short introduction to the Axios library and the HTTP PUT method.
We also showed a few examples of how Axios can be used to make PUT calls, as well as how other configurations can be called and how simple errors can be handled.

Scott Robinson

In this practical guide, we'll take a look at how to send a PUT HTTP request with JavaScript's Axios library, in the Node.js environment - with examples and best practices.

Sending PUT HTTP Requests with Axios

<h2 id="introduction">Introduction</h2>
<blockquote>
Sorting is one of the fundamental techniques used in solving problems, especially in those related to writing and implementing efficient algorithms.
</blockquote>
Usually, sorting is paired with searching - meaning we first sort elements in the given collection, then search for something within it, as it is generally easier to search for something in a sorted, rather than an unsorted collection, as we can make educated guesses and impose assumptions on the data.
<blockquote>
There are many algorithms that can efficiently sort elements, but in this guide we'll be taking a look at the theory behind as well as how to implement Quicksort in Java.
</blockquote>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Fun fact: Since JDK7, the algorithm used for <a target="_blank" href="https://github.com/openjdk-mirror/jdk7u-jdk/blob/master/src/share/classes/java/util/Arrays.java" rel="nofollow noopener noreferrer">off-the-shelf sorting in the JVM for Arrays</a> is a dual-pivot Quicksort!

 </div>
 </div>
 </div>
 <h2 id="quicksortinjava">Quicksort in Java</h2>
Quicksort is a sorting algorithm belonging to the divide-and-conquer group of algorithms, and it's an in-place (no need for auxiliary data structures), non-stable (doesn't guarantee relative order of same-value elements after sorting) sorting algorithm.
The divide-and-conquer algorithms recursively break down a problem into two or more sub-problems of the same type, making them simpler to solve. The breakdown continues until a problem is simple enough to be solved on it's own (we call this the base case).
This algorithm has been shown to give the best results when working with large arrays, and on the other hand when working with smaller arrays an algorithm like <a target="_blank" href="https://stackabuse.com/selection-sort-in-java/">Selection Sort</a> might prove more efficient.
Quicksort modifies the base idea of Selection Sort, so that instead of a minimum (or a maximum), in every step of the way an element is placed on the spot it belongs on in the sorted array.
This element is called the pivot. However, if we wanted to use the divide-and-conquer approach and reduce the problem of sorting the array to a smaller group of two sub-arrays we need to abide by the following: while we're placing our pivot at it's spot in the array we need to group the rest of the elements in two smaller groups - the ones left of the pivot are lesser or equal to it, and the ones on the right are bigger than the pivot.
This is actually the key step of the algorithm - called partitioning, and implementing it efficiently is a must if we want our Quicksort to be efficient as well.
Before discussing how Quicksort works, we should address how we choose which element is the pivot. The perfect scenario is that we always choose the element that splits the array in exact halves. However, since this is almost impossible to achieve, we can approach this problem in a few different ways.
<blockquote>
For example, the pivot can be the first or the last element in the array (or a sub-array) we're currently processing. We can pick a median element as the pivot, or even choose a random element to play the role.
</blockquote>
We have a variety of ways of accomplishing this task, and the approach we'll be taking in this article is to always choose the first (that is, leftmost element of the array) as the pivot. Now let's jump into an example and explain how it all works.
<h2 id="visualizationofquicksort">Visualization of Quicksort</h2>
Suppose we have the following array:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-1.jpg" alt="array">
In this example, the pivot in the first iteration will be <code>4</code>, since the decision is to pick the first element of the array as the pivot. Now comes in the partitioning - we need to place <code>4</code> at the position it will be found in the sorted array.
The index of that position will be <code>2</code>, so after the first partitioning our array will look like this:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-2.jpg" alt="array">

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: It's noticeable that the elements located left and right from the pivot aren't sorted as they should be.

 </div>
 </div>
 </div>
 This is to be expected - whenever we partition an array that isn't the base case (that is of size <code>1</code>), the elements are grouped in a random order.
The important thing is what we discussed earlier: the elements left of the pivot are lesser or equal, and the elements on the right are bigger than the pivot. That isn't to say that they can't be sorted in the first grouping - while unlikely it can still happen.
We continue on, and see that here divide-and-conquer kicks in - we can break down our original problem into two smaller ones:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-3.jpg" alt="array">
For the problem on the left we have an array of size <code>2</code>, and the pivot element will be <code>2</code>. After positioning the pivot at its place (at the position <code>1</code>), we get an array <code>[1, 2]</code> after which we have no more cases for the left side of the problem, since the only two subcases of <code>[1, 2]</code> are <code>[1]</code> and <code>[2]</code> which are both base cases. With this we finish with the left side of subcases and consider that part of the array sorted.
Now for the right side - the pivot is <code>13</code>. Since it's the largest of all of the numbers in the array we're processing, we have the following setup:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-4.jpg" alt="array">
Unlike earlier when the pivot broke down our array into two subcases, there's only one case here - <code>[8, 10, 7, 5]</code>. The pivot now is <code>8</code> and we need to bring it to the position <code>5</code> in the array:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-5.jpg" alt="array">
The pivot now splits the array in two subcases: <code>[7, 5]</code> and <code>[10]</code>. Since <code>[10]</code> is of size <code>1</code>, that is our base case and we don't consider it at all.
The only subarray left is the array of <code>[7, 5]</code>. Here, <code>7</code> is the pivot, and after bringing it to its position (index <code>4</code>), to the left of it at the position <code>3</code> is only <code>5</code>. We have no more subcases and this is where the algorithm ends.
After running Quicksort, we have the following sorted array:
<img src="https://s3.stackabuse.com/media/articles/quicksort-in-java-6.jpg" alt="templateniz">
<blockquote>
This approach also accounts for duplicates in the array, since all of the elements left of the pivot are lesser or equal than the pivot itself.
</blockquote>
<h2 id="implementingquicksortinjava">Implementing Quicksort in Java</h2>
With a good intuition of how Quicksort works - we can follow through with an implementation. First of all, we'll go through the main part of the program that will be running Quicksort itself.
Since Quicksort is a divide-and-conquer algorithm, it's naturally implemented recursively, although you could do it iteratively as well (any recursive function can also be implemented iteratively) - though, the implementation is not as clean:
<pre><code class="hljs">static void quicksort(int[] arr, int low, int high){
 if(low &lt; high){
 int p = partition(arr, low, high);
 quicksort(arr, low, p-1);
 quicksort(arr, p+1, high);
 }
}
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: low and high represent the left and right margins of the array that's currently being processed.

 </div>
 </div>
 </div>
 The <code>partition(arr, low, high)</code> method partitions the array, and upon it's execution the variable <code>p</code> stores the position of the pivot after the partitioning.
This method is only invoked when we're processing arrays that have more than one element, hence the partitioning only takes place if <code>low &lt; high</code>.
Since Quicksort works in-place, the starting multiset of elements that can be found within the array stays unchanged, but we've accomplished exactly what we aimed to do - group up smaller or equal elements left to the pivot, and bigger than the pivot on the right.
Afterwards, we call the <code>quicksort</code> method recursively twice: for the part of the array from <code>low</code> to <code>p-1</code> and for the part from <code>p+1</code> to <code>high</code>.
Before we discuss the <code>partition()</code> method, for the sake of readability we'll implement a simple <code>swap()</code> function that swaps two elements in the same array:
<pre><code class="hljs">static void swap(int[] arr, int low, int pivot){
 int tmp = arr[low];
 arr[low] = arr[pivot];
 arr[pivot] = tmp;
}
</code></pre>
Now, let's dive into the code for the <code>partition()</code> method and see how it does what we've explained above:
<pre><code class="hljs">static int partition(int[] arr, int low, int high){
 int p = low, j;
 for(j=low+1; j &lt;= high; j++)
 if(arr[j] &lt; arr[low])
 swap(arr, ++p, j);

 swap(arr, low, p);
 return p;
}
</code></pre>
When the <code>for</code> loop is done executing, <code>j</code> has value of <code>high+1</code>, meaning the elements on <code>arr[p+1, high]</code> are higher or equal than the pivot. Because of this it's required we do one more swap of the elements on the position <code>low</code> and <code>p</code>, bringing the pivot at its correct position in the array (that is, position <code>p</code>).
The last thing we need to do is run our <code>quicksort()</code> method and sort an array. We'll be using the same array as we did in the example before, and calling <code>quicksort(arr, low, high)</code> will sort the <code>arr[low, high]</code> part of the array:
<pre><code class="hljs">public static void main(String[] args) {
 int[] arr = {4, 8, 1, 10, 13, 5, 2, 7};
 // Sorting the whole array
 quicksort(arr, 0, arr.length - 1); 
}
</code></pre>
This results in:
<pre><code class="hljs">1, 2, 3, 4, 5, 7, 8, 10, 13
</code></pre>
<h2 id="complexityofquicksort">Complexity of Quicksort</h2>
Quicksort, as well as other algorithms that apply the divide-and-conquer tactic, has a time complexity of <code>O(n log n)</code>. However, compared to something like <a target="_blank" href="https://stackabuse.com/merge-sort-in-java/">Merge Sort</a>, which has the worst-case time complexity of <code>O(n log n)</code>, Quicksort can theoretically have the worst-case of <code>O(n^2)</code>.
The complexity depends on how much time we take to efficiently choose a pivot, which can sometimes be as difficult as sorting the array itself, and since we expect the choosing of a pivot to be <code>O(1)</code> we usually can't guarantee that in every step of the way we'll be choosing the best pivot possible.
Even though the worst-case of Quicksort can be <code>O(n^2)</code>, most of the pivot-choosing strategies are implemented such so they don't deter the complexity too much, which is why the average complexity of Quicksort is <code>O(n log n)</code>. It's widely implemented and used, and the name itself is an homage to its performance capabilities.
On the other hand, where Quicksort hands-down beats Merge Sort is the space complexity - Merge Sort requires <code>O(n)</code> space because it uses a separate array for merging, while Quicksort sorts in-place and has the space complexity of <code>O(1)</code>.
<h2 id="conclusion">Conclusion</h2>
In this article we've covered how the Quicksort algorithm works, how it's implemented and discussed its complexity. Even though the choice of the pivot can &quot;make or break&quot; this algorithm, it's usually considered as one of the most efficient sorting algorithms and is widely used whenever we have a need for sorting arrays with huge amounts of elements.

In this guide we'll take a look at the theory and how to implement a single-pivot Quicksort in Java with a time and space complexity analysis.

Quicksort in JAVA

The Portable Document Format (PDF) is not a WYSIWYG (What You See is What You Get) format. It was developed to be platform-agnostic, independent of the underlying operating system and rendering engines.
To achieve this, PDF was constructed to be interacted with via something more like a programming language, and relies on a series of instructions and operations to achieve a result. In fact, PDF is based on a scripting language - <a rel="noreferrer nofollow nopener" target="_blank" href="https://www.adobe.com/products/postscript.html">PostScript</a>, which was the first device-independent Page Description Language.
In this guide, we'll be using <a rel="nofollow noopener noreferrer" target="_blank" href="https://borbpdf.com/">borb</a> - a Python library dedicated to reading, manipulating and generating PDF documents. It offers both a low-level model (allowing you access to the exact coordinates and layout if you choose to use those) and a high-level model (where you can delegate the precise calculations of margins, positions, etc to a layout manager).
<blockquote>
In this guide, we'll take a look at how to generate a PDF with a fillable form.
</blockquote>
<h2 id="installingborb">Installing borb</h2>
borb can be downloaded from source on <a rel="noreferrer nofollow noopener" target="_blank" href="https://github.com/jorisschellekens/borb">GitHub</a>, or installed via <code>pip</code>:
<pre><code class="hljs">$ pip install borb
</code></pre>
<h2 id="generatingapdfdocumentwithborb">Generating a PDF Document with borb</h2>
Now that <code>borb</code> is installed, we can import the building blocks and construct a simple PDF page:
<pre><code class="hljs">from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF
from borb.pdf.canvas.layout.page_layout.multi_column_layout import SingleColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout
</code></pre>
The following code represents the basic steps on creating a PDF document using <code>borb</code>:
<ul>
<li>Creating an empty Document</li>
<li>Creating an empty Page</li>
<li>Appending the Page to the Document</li>
<li>Creating a PageLayout that is responsible for handling the flow of content (here we'll use SingleColumnLayout)</li>
<li>Adding content to the PageLayout</li>
<li>Persisting the Document to disk</li>
</ul>
With that being said, let's go ahead and create a <code>Document</code>:
<pre><code class="hljs"># Create empty Document
pdf = Document()

# Create empty Page
page = Page()

# Add Page to Document
pdf.append_page(page)

# Create PageLayout
layout: PageLayout = SingleColumnLayout(page)
</code></pre>
With the initial steps out of the way - we can add the content in. In this instance, it'll be a fillable form. We're going to create a form with some basic user-information questions, such as a name, surname, etc:
<ul>
<li>Name</li>
<li>Surname</li>
<li>Gender</li>
<li>Place of residence</li>
<li>Nationality</li>
</ul>
To ensure everything is laid out just right, we're going to add this content to a <code>Table</code>. The left column will contain the field name (e.g. &quot;name&quot;, &quot;surname&quot;), the right column will contain the fields to be filled in.
We'll additionally add another <code>Paragraph</code> right above the form to annotate it:
<pre><code class="hljs"># New import(s)
from borb.pdf.canvas.layout.table.fixed_column_width_table import FixedColumnWidthTable
from borb.pdf.canvas.layout.text.paragraph import Paragraph
from borb.pdf.canvas.layout.forms.text_field import TextField
from borb.pdf.canvas.color.color import HexColor
from decimal import Decimal
from borb.pdf.canvas.layout.layout_element import Alignment
from borb.pdf.canvas.layout.forms.drop_down_list import DropDownList

# Let&#x27;s start by adding a heading
layout.add(Paragraph(&quot;Patient Information:&quot;, font=&quot;Helvetica-Bold&quot;))

# Use a table to lay out the form
table: FixedColumnWidthTable = FixedColumnWidthTable(number_of_rows=5, number_of_columns=2)

# Name
table.add(Paragraph(&quot;Name : &quot;, horizontal_alignment=Alignment.RIGHT, font_color=HexColor(&quot;56cbf9&quot;)))
table.add(TextField(value=&quot;Doe&quot;, font_color=HexColor(&quot;56cbf9&quot;), font_size=Decimal(20)))

# Surname
table.add(Paragraph(&quot;Surname : &quot;, horizontal_alignment=Alignment.RIGHT, font_color=HexColor(&quot;56cbf9&quot;)))
table.add(TextField(value=&quot;John&quot;, font_color=HexColor(&quot;56cbf9&quot;), font_size=Decimal(20)))
</code></pre>
These input fields are <code>TextField</code>s, which accept a string passed into them. We're going to model the gender field as a dropdown list, from which the reader can choose one of four options:
<ul>
<li>Female</li>
<li>Male</li>
<li>Other</li>
<li>Prefer not to disclose</li>
</ul>
Let's see how that translates to <code>borb</code>:
<pre><code class="hljs"># Gender
table.add(Paragraph(&quot;Gender : &quot;, horizontal_alignment=Alignment.RIGHT))
table.add(DropDownList(
 possible_values=[
 &quot;Female&quot;,
 &quot;Male&quot;,
 &quot;Other&quot;,
 &quot;Prefer not to disclose&quot;,
 ]
))
</code></pre>
We could do a similar thing for country of residence and nationality, but it would involve having to find a list of all countries in the world and passing it to the constructor of the <code>DropDownList</code>.
This stands for any sufficiently long list.
Because this particular field (a list of all countries) is such a common requirement, <code>borb</code> comes preloaded with the class <code>CountryDropDownList</code>:
<pre><code class="hljs"># New import(s)
from borb.pdf.canvas.layout.forms.country_drop_down_list import CountryDropDownList

# Country of Residence
table.add(Paragraph(&quot;Country of Residence : &quot;, horizontal_alignment=Alignment.RIGHT))
table.add(CountryDropDownList(value=&quot;Belgium&quot;))

# Nationality
table.add(Paragraph(&quot;Nationality : &quot;, horizontal_alignment=Alignment.RIGHT))
table.add(CountryDropDownList(value=&quot;Belgium&quot;))
</code></pre>
Now we can finally add the <code>Table</code> to our <code>PageLayout</code>:
<pre><code class="hljs"># Set some properties on the table to make the layout prettier
table.set_padding_on_all_cells(Decimal(5), Decimal(5), Decimal(5), Decimal(5))
table.no_borders()

# Adding Table to PageLayout
layout.add(table)
</code></pre>
Now let's add a (nonsense) data protection policy:
<pre><code class="hljs"># Data protection policy
layout.add(Paragraph(&quot;Data Protection Policy&quot;, 
 font=&quot;Helvetica-Bold&quot;))

# Dummy text
layout.add(Paragraph(
 &quot;&quot;&quot;
 ** Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
 Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. 
 Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. 
 Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
 &quot;&quot;&quot;,
 font=&quot;Helvetica-Oblique&quot;
))
</code></pre>
Let's wrap things up by adding a footer. For now, we'll just add a rectangle filled in the accent color, at the bottom of the page. Nothing too fancy.
<pre><code class="hljs"># New import(s)
import typing
from borb.pdf.canvas.geometry.rectangle import Rectangle
from borb.pdf.page.page_size import PageSize
from borb.pdf.canvas.line_art.line_art_factory import LineArtFactory
from borb.pdf.canvas.layout.image.shape import Shape

ps: typing.Tuple[Decimal, Decimal] = PageSize.A4_PORTRAIT.value
r: Rectangle = Rectangle(Decimal(0), Decimal(32), ps[0], Decimal(8))
Shape(points=LineArtFactory.rectangle(r), stroke_color=HexColor(&quot;56cbf9&quot;), fill_color=HexColor(&quot;56cbf9&quot;)).layout(page, r)
</code></pre>
Lastly, we can store the <code>Document</code> we created using the <code>PDF</code> class:
<pre><code class="hljs"># New import(s)
from borb.pdf.pdf import PDF

# Store
with open(&quot;output.pdf&quot;, &quot;wb&quot;) as out_file_handle:
 PDF.dumps(out_file_handle, pdf)
</code></pre>
What does this look like in the end? When we run the code and produce the PDF file - it'll have a few empty fields:
<img src="https://s3.stackabuse.com/media/articles/creating-a-form-in-a-pdf-document-in-python-with-borb-1.png" alt="Fillable form in pdf created in python with borb">
By selecting these fields, you can use your keyboard to enter the details in:
<img src="https://s3.stackabuse.com/media/articles/creating-a-form-in-a-pdf-document-in-python-with-borb-2.png" alt="filled pdf form python borb">
<h2 id="conclusion">Conclusion</h2>
In this guide you've learned how to include form-elements in your PDF, allowing the reader to interact with the PDF.

In this guide, we'll take a look at how to add a fillable, interactive form in a PDF document using Python and borb, with dropdown menus and input text fields.