David Landup

Arpendu Kumar Garai

In this guide, we'll take a look at how to monitor Node.js applications using Prometheus and Grafana, with practical code and examples.

Node.js Application Monitoring with Prometheus and Grafana

Accidentally forgot to add a file to the <code>.gitignore</code> file and started tracking it with other files? Or perhaps a remote repository already has a file tracked that you've cloned, but would like to stop tracking?
<blockquote>
Just as important as tracking changes is not tracking them in certain cases, lest they change the scale of what you're keeping an eye on. Once a file is tracked, even if you add it to <code>.gitignore</code>, it will still be tracked.
</blockquote>
In this tutorial, we'll take a look at two ways on how to stop tracking a file on Git, after adding it to <code>.gitignore</code>.
Choosing between these two depends on whether you want the file to be kept in the repository or not.
<h2 id="stoptrackingfileandremoveitfromtherepository">Stop Tracking File and Remove it from the Repository</h2>
First, let's go ahead and create a couple of files, add them to the index and commit them to the repository:
<pre><code class="hljs">$ touch file.txt
$ touch file2.txt
$ git add .
$ git commit -m &quot;Initial commit&quot;
</code></pre>
These two files are now tracked, and all changes made to them are relevant in Git's eyes. Though... we've forgotten to add a <code>.gitignore</code> file, and <code>file.txt</code> we don't want to track is already in the repository.
Let's quickly create a <code>.gitignore</code> and add the matcher for <code>file.txt</code> in it:
<pre><code class="hljs">$ touch .gitignore
$ echo &quot;file.txt&quot; &gt;&gt; .gitignore
$ git add .gitignore
$ git commit -m &quot;Adding .gitignore&quot;
</code></pre>
When we make a new change to the file:
<pre><code class="hljs">$ echo &quot;new line&quot; &gt;&gt; file.txt
$ git status
</code></pre>
Even though it's now present in the <code>.gitignore</code> file - the file is still being tracked:
<pre><code class="hljs">Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git restore &lt;file&gt;...&quot; to discard changes in working directory)
 modified: file.txt
</code></pre>
We'd like to keep <code>file.txt</code> present on our local system (it &quot;includes important configurations&quot; but since the configurations are machine-specific, it's only applicable to us). To make Git stop tracking a file, while removing it from the Git repository, we'll run the <code>git rm</code> command:
<pre><code class="hljs">$ git rm --cached file.txt
rm &#x27;file.txt&#x27;
</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: The <code>--cached</code> flag removes only the files from the index - the working directory isn't affected at all.

 </div>
 </div>
 </div>
 Let's verify that the Git repository no longer lists this file, while it is still present in the working tree:
<pre><code class="hljs">$ git ls-files 
file2.txt 
.gitignore

$ ls -a
.		.git		file.txt
..		.gitignore	file2.txt
</code></pre>
<h2 id="stoptrackingfilewithoutremovingitfromtherepository">Stop Tracking File Without Removing it from the Repository</h2>
Alternatively, you might want to have the file still present in the repository, for other team members to be able to download - but it's a hassle for you personally to keep tracking changes to it, you can stop tracking it while keeping it in the repository via the <code>git update-index</code> command:
<pre><code class="hljs">$ git update-index --skip-worktree file.txt
$ git status
On branch main
nothing to commit, working tree clean
</code></pre>
This command updates the index and skips over all the files specified. In our case, it updates the index to skip over <code>file.txt</code> and turn tracking off. In that sense - this command can be used individually, separately of the <code>.gitignore</code> file.

 <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: An alternative is the <code>git update-index --assume-unchanged</code> command, in which you tell Git to trust you on your word that the file is unchanged. This is done for huge files that are not supposed to be changed, and are expensive to check for changes constantly. If you use this approach - don't change the file, lest you'll break the feature's intended use and Git will encounter errors while merging. Using <code>--skip-worktree</code> is preferred.

 </div>
 </div>
 </div>
 Let's verify that the file is present both in the repository and our local file system:
<pre><code class="hljs">$ git ls-files
.gitignore
file.txt
file2.txt

$ ls -a
.		.git		file.txt
..		.gitignore	file2.txt
</code></pre>

In this tutorial, we'll take a look at how to stop tracking a file after adding it to .gitignore post-festum, with and without removing it from the repository.

Git: Stop Tracking File After Adding to .gitignore

<h2 id="introduction">Introduction</h2>
In this guide, we'll take a look at how to style a PyQt application.
<blockquote>
If you're unfamiliar with PyQt, read our <a target="_blank" href="https://stackabuse.com/working-with-pythons-pyqt-framework/">Guide to Working with Python's PyQT Framework</a>
</blockquote>
We'll start with PyQt's default themes and how to change these, before moving forward to using different types of custom styling.
<h2 id="defaultpyqtthemes">Default PyQt Themes</h2>
PyQt works with default OS-based themes. This means that not specifying a theme will give the application a different look on different systems.
Your application will look different on a Windows 10 machine as opposed to a Linux machine.
There are many styles or themes that ship with PyQt, other than the default themes.
To keep a uniform look and feel to our application while distributing to multiple operating systems we'll want to change the default theme with either a pre-built one or build our own. Alternatively, you can keep a native look depending on the operating system.
<h3 id="checkallavailablesystemstyles">Check All Available System-Styles</h3>
Since the default system styles differ from system to system, not every system will have the same default styles available.
Luckily, PyQt has a built-in function to retrieve all the available styles, kept in a dictionary. Let's take a look at all the available system styles:
<pre><code class="hljs"># The QStyleFactory object holds all the default system styles.
from PyQt6.QtWidgets import QStyleFactory
print(QStyleFactory.keys())
</code></pre>
On a Windows machine, this will return the three following styles:
<pre><code class="hljs">[&#x27;windowsvista&#x27;, &#x27;Windows&#x27;, &#x27;Fusion&#x27;]
</code></pre>
On Linux, on the other hand, it'll return:
<pre><code class="hljs">[&#x27;Breeze&#x27;, &#x27;Oxygen&#x27;, &#x27;QtCurve&#x27;, &#x27;Windows&#x27;, &#x27;Fusion&#x27;]
</code></pre>
To find out which default style is applied to an existing application, you can access the <code>objectName()</code> via <code>app.style()</code>:
<pre><code class="hljs">import sys
from PyQt6.QtWidgets import QApplication

app = QApplication(sys.argv)
print(app.style().objectName())
</code></pre>
The result, again, depends on your operating system:
<pre><code class="hljs">windowsvista
</code></pre>
<h3 id="applyingsystemstylestopyqt6applications">Applying System Styles to PyQt6 Applications</h3>
To change the default system style to another style we can use the <code>setStyle()</code> method on the <code>QApplication</code> instance,, with another style as an argument.
Let's set the default style to <code>Fusion</code> in a small application:
<pre><code class="hljs">import sys
from PyQt6.QtWidgets import QApplication, QPushButton, QVBoxLayout, QWidget
app = QApplication(sys.argv)

# Set the &#x27;Fusion&#x27; system style
app.setStyle(&#x27;Fusion&#x27;)

# Create the parent Widget of the Widgets added to the layout
window = QWidget()

# Create the Vertical Box Layout Manager, setting the window as parent by passing it in the constructor.
layout = QVBoxLayout(window)

# Create the button Widgets we will add to the layout.
# Add the button Widgets to the VerticalBoxLayout
layout.addWidget(QPushButton(&#x27;One&#x27;))
layout.addWidget(QPushButton(&#x27;Two&#x27;))
layout.addWidget(QPushButton(&#x27;Three&#x27;))
layout.addWidget(QPushButton(&#x27;Four&#x27;))
layout.addWidget(QPushButton(&#x27;Five&#x27;))

# Show the parent Widget
window.show()

# Launch the application
sys.exit(app.exec())
</code></pre>
Now, this applies the <code>Fusion</code> stylesheet to our elements, changing their appearance:
<img src="https://s3.stackabuse.com/media/articles/styling-pyqt6-applications-default-and-custom-qss-stylesheets-1.PNG" alt="fusion stylesheet pyqt6">
<h2 id="custompyqt6styles">Custom PyQt6 Styles</h2>
Although these styles are really nice - you might have a different vision for your application. What if you'd like to change the buttons to be red, but keep the rest of the Fusion stylesheet applied?
Much the same way you can stylize HTML pages - you can also stylize PyQt applications - inline and through QSS Stylesheets.
<blockquote>
QSS Stylesheets take inspiration from CSS Stlyesheets and have a borrowed syntax with a tiny tweak.
</blockquote>
<h3 id="addinginlinestyletopyqt6applications">Adding Inline Style to PyQt6 Applications</h3>
When the amount of styling code doesn't warrant a separate, standalone QSS File, it's easiest to write some styling code inline - that is, within the Python file in which your application resides.
Similar to styling HTML pages inline, it's not considered the best practice, but it is fine for prototyping, testing or really small tweaks.
Each <code>QWidget</code> accepts a <code>setStyleSheet()</code> function, which accepts a CSS string:
<pre><code class="hljs">widget.setStyleSheet(
 &quot;&quot;&quot;
 CSS SYNTAX
 &quot;&quot;&quot;
)
</code></pre>
For example, if we want to apply a color to a widget, set its font family and size, we can simply use the all-too-familiar CSS syntax:
<pre><code class="hljs">...
button = QPushButton(&#x27;One&#x27;)
button.setStyleSheet(
 &quot;background-color: #262626; &quot;
 &quot;font-family: times; &quot;
 &quot;font-size: 20px;&quot;
)

layout.addWidget(button)
</code></pre>
If we replaced the original button addition code with this, the application would look like:
<img src="https://s3.stackabuse.com/media/articles/styling-pyqt6-applications-default-and-custom-qss-stylesheets-2.PNG" alt="stylized button">
Now, if we want to style another component, we apply the <code>setStyleSheet()</code> function to it. This quickly becomes a problem if you want to style multiple components...
Although you can apply the <code>setStyleSheet()</code> function to the <code>QApplication</code> instance and apply styling globally to the entire application. Though, if you're already there, might as well create a new custom stylesheet and use it instead of inline styling code.
<h3 id="creatingcustomstylesheets">Creating Custom Stylesheets</h3>
The operating system styles are just stylesheets present in different shipments of PyQt. There's nothing stopping you from defining your own QSS Stylesheet made specifically for your application.
Additionally, using stylesheets fixes a myriad of problems that can arise from styling your components inline, besides the fact that it makes sense to separate business logic from styling code.
QSS files are very similar to CSS files - the only difference is how you identify elements you'd like to style. You can't assign a unique ID to a certain widget to style it individually. You'll have to lump together apples with apples and style widget types the same.
Optionally, you can also style objects within widgets individually from the widget itself:
<pre><code class="hljs">QPushButton {
 background-color: blue;
}

QLabel#title {
 font-size: 15px;
}
</code></pre>
The first style will define our background-color for all the <code>QPushButton</code> objects in the application.
The second style will only style the title object of a <code>QLabel</code>.
To include a QSS file to your application, you can apply it by reading the file and using the <code>QApplication.setStyleSheet(str)</code> function:
<pre><code class="hljs"># Open the qss styles file and read in the CSS-like styling code
with open(&#x27;styles.qss&#x27;, &#x27;r&#x27;) as f:
 style = f.read()

 # Set the stylesheet of the application
 app.setStyleSheet(style)
</code></pre>
Really, these files are just the container for our style strings.
<h3 id="stylingademonstrationapplication">Styling a Demonstration Application</h3>
With all of this in mind, let's create a simple QSS stylesheet and apply it to a simple demo application:
<pre><code class="hljs">import sys
from PyQt6.QtWidgets import (QApplication, QTableWidget, QTableWidgetItem)
from PyQt6.QtGui import QColor

# Declare our table values
nordic_countries = [(&#x27;Norway&#x27;, &#x27;Oslo&#x27;, &#x27;Yes&#x27;),
 (&#x27;Iceland&#x27;, &#x27;Reykjavik&#x27;, &#x27;Yes&#x27;),
 (&#x27;Denmark&#x27;, &#x27;Copenhagen&#x27;, &#x27;Yes&#x27;),
 (&#x27;Belgium&#x27;, &#x27;Brussels&#x27;,&#x27;No&#x27;)]
 
# Create the Qt Application
app = QApplication(sys.argv)

# Create the QTableWidget Widget
table = QTableWidget()

# Set the row count of the table to the length of the &#x27;nordic_countries&#x27; variable
table.setRowCount(len(nordic_countries))

# Since every country in our &#x27;nordic_countries&#x27; variable has the same amount of attributes
# we take the amount (3) of the first country and use this as the number of columns
table.setColumnCount(len(nordic_countries[0]))

# Set the Horizontal headers using setHorizontalHeaderLabels()
table.setHorizontalHeaderLabels([&#x27;Country&#x27;, &#x27;Capital&#x27;, &#x27;Scandinavian?&#x27;])

# Loop through every country in our &#x27;nordic_countries&#x27; variable
for i, (country, capital, scandinavian_bool) in enumerate(nordic_countries):

 # Make a QTableWidgetItem --&gt; acts as an item in a table
 item_country = QTableWidgetItem(country)
 item_capital = QTableWidgetItem(capital)
 item_scandinavian_bool = QTableWidgetItem(scandinavian_bool)

 # Set the value of the items
 table.setItem(i, 0, item_country)
 table.setItem(i, 1, item_capital)
 table.setItem(i, 2, item_scandinavian_bool)

# Finally show the table
table.show()

# Open the sqq styles file and read in the CSS-alike styling code
with open(&#x27;styles.qss&#x27;, &#x27;r&#x27;) as f:
 style = f.read()
 # Set the stylesheet of the application
 app.setStyleSheet(style)

# Launch the application
sys.exit(app.exec())
</code></pre>
And within the <code>styles.qss</code> file:
<pre><code class="hljs">QTableWidget {
 font-family: Titillium;
 font-size: 20px;
}

QTableWidget::item {
 background-color: #D3D3D3;

}

QTableWidget::item:hover {
 background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #e7effd, stop: 1 #cbdaf1);
 border: 1px solid #bfcde4;
}
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/styling-pyqt6-applications-default-and-custom-qss-stylesheets-3.PNG" alt="stylized pyqt6 application with custom qss stylesheet">
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to style PyQt6 Applications in Python. We've explored standard operating system styles, how to style them using inline code as well as how to create custom QSS Stylesheets.

Marko Kosmajac

In this guide we'll take a look at how to style a PyQt application using the default and custom QSS stylesheets.

Styling PyQt6 Applications - Default and Custom QSS Stylesheets

In this guide, we'll be taking a deep dive into how to invalidate JWT tokens when a user logs out of a Spring-based application, using Spring Security.

Spring Security: In-Memory Invalidation of JWT Tokens During User Logout

<h2 id="introduction">Introduction</h2>
Thymeleaf is a templating (server-side rendering) engine used by many Java software engineers within Spring-based web applications. An important feature of any web application is the support for dynamic URLs and path variables within those URLs.
Most REST APIs extensively use path variables to specify the IDs of elements they're performing operations on. For instance, a typical example would be:
<pre><code class="hljs">https://www.somewebsite.com/viewPost/path-variables-with-spring-boot
# OR
https://www.somewebsite.com/viewProduct/5
</code></pre>
In both of these cases, we're trying to find a resource denoted by a certain identifier. In the first case, we're identifying a resource by its title - <code>path-variables-with-spring-boot</code>, while in the second, we're identifying it through an incremental ID counter - <code>5</code>.

 <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 using predictable path variables, such as an incremental counter, beware of security concerns. First of all - these are easily scrapeable, but most important than anything, without proper validation - someone might figure out that <code>/deleteProduct/5</code> deletes entries from the database, and decide to drop most of the entities stored within it.

 </div>
 </div>
 </div>
 In this guide - we'll take a look at how to leverage Thymeleaf to retrieve path variables, and how to use Spring Boot controllers to process them.
Throughout the guide, we'll be using a <code>Post</code> model, which represents a blog post - which just has an ID and some <code>content</code>:
<pre><code class="hljs">public class Post {

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = &quot;post_sequence&quot;)
 private Long id;
 private String content;

 // Constructors, Getters, Setters, and toString 
}
</code></pre>
Since we're using Spring Boot - let's also bootstrap a <code>PostRepository</code> based on the <code>JpaRepository</code>, which allows us to perform CRUD operations out of the box:
<pre><code class="hljs">@Repository
public interface PostRepository extends JpaRepository&lt;Post, Long&gt; {}
</code></pre>
<h2 id="thymeleafpathvariableswithspringboot">Thymeleaf Path Variables with Spring Boot</h2>
Some URLs are dynamic - namely, given the fact that we can create, read, update and delete our <code>Post</code> entities, we'll want to have dynamic URLs for the <code>GET</code>, <code>UPDATE</code> and <code>DELETE</code> requests.
Let's initialize our project with a few artificial posts:
<pre><code class="hljs">@GetMapping(&quot;/initialize&quot;)
public ResponseEntity&lt;String&gt; initialize() {
 Post post1 = new Post(&quot;Content of post 1&quot;);
 Post post2 = new Post(&quot;Content of post 2&quot;);
 Post post3 = new Post(&quot;Content of post 3&quot;);
 postRepository.saveAll(List.of(post1, post2, post3));
 
 return ResponseEntity.ok(&quot;Initialized posts&quot;);
}
</code></pre>
Once we hit our <code>/initialize</code> endpoint, three posts will be generated and saved into the database. Now, let's define a static URL for the user to retrieve all posts:
<pre><code class="hljs">@GetMapping(&quot;/viewPosts&quot;)
public String viewAllPostsAndComments(Model model){
 List&lt;Post&gt; postList = postRepository.findAll();
 model.addAttribute(&quot;postList&quot;, postList);
 
 return &quot;all-posts&quot;;
}
</code></pre>
This is a static URL and handler - there aren't any path variables or parameters that can let the user influence which posts are being retrieved. This is typically what you want if you'd like to let the user choose where they'd like to navigate. Once chosen, they can view the detailed listing for any post, just by clicking on it and navigating to its page.
Since it'd be impractical (and unfeasible) to create a request handler for each post, we can make a dynamic handler that accepts any post ID, finds the post in the database and returns it:
<pre><code class="hljs">@GetMapping(&quot;/viewPost/{postId}&quot;)
public String viewPost(@PathVariable(&quot;postId&quot;) Long postId, Model model) {
 Post post = postRepository.findById(postId).get();
 model.addAttribute(&quot;post&quot;, post);
 
 return &quot;view-post&quot;;
}
</code></pre>
Here, we've defined a <code>@GetMapping</code> for the URL <code>/viewPost/{postId}</code>. The <code>postId</code> wrapped in curly brackets is a dynamic variable that can be set to any value and/or type. In our method's signature, we've used the <code>@PathVariable</code> annotation, setting the name of the path variable, and assigning it to a type that we can reference - <code>Long postId</code>.

 <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: The name of the path variable in the <code>@GetMapping</code> annotation has to match the name we've defined in the <code>@PathVariable</code> annotation. You can use as many path variables as you'd like in a URL, and match them via their names.

 </div>
 </div>
 </div>
 Once a <code>GET</code> request is fired on, say, the <code>/viewPost/5</code> endpoint - the <code>postId</code> is converted to a <code>Long</code> implicitly and we can use it to search for the post via its ID in the database. If we, however, pass in another type, such as a <code>String</code> - <code>/viewPost/some-post</code>, this controller will throw an exception:
<pre><code class="hljs">java.lang.NumberFormatException: For input string: &quot;some-post&quot;
</code></pre>
Since we've got the controllers to handle both a request to view all posts as well as to view a single one, let's quickly write up the Thymeleaf pages that allow us to navigate through to these request handlers. Let's first start off with a page that lists all of the posts and allows the user to navigate to the different controller request handlers:
<pre><code class="hljs">&lt;div th:each=&quot;post : ${postList}&quot;&gt;
 &lt;p th:text=&quot;${post.content}&quot;&gt;&lt;/p&gt;
 &lt;a class=&quot;btn btn-info&quot; th:href=&quot;@{/viewPost/{id}(id = ${post.id})}&quot;&gt;View Post&lt;/a&gt;
&lt;/div&gt;
</code></pre>
Here, we've iterated over each post in the <code>postList</code> (list of posts we've added to the <code>Model</code> instance) and for each one, added a button allowing the user to view the post. The <code>href</code> attribute of the link leads us to:
<pre><code class="hljs">th:href=&quot;@{/viewPost/{id}(id = ${post.id})}
</code></pre>
This is the <a rel="nofollow noopener" target="_blank" href="https://www.thymeleaf.org/doc/articles/standardurlsyntax.html">standard URL syntax</a> for adding parameters in Thymeleaf. The standard <code>@{}</code> expression used for links also accepts path variables. The <code>{id}</code> is a path variable, which we can externally set. Here, we've pointed it to the <code>post.id</code>. Once rendered on the server-side, this expression is evaluated as:
<pre><code class="hljs">&lt;a href=&quot;localhost:8080/viewPost/1&quot; class=&quot;btn btn-info&quot; &gt;View Post&lt;/a&gt;
</code></pre>
Clicking this button will trigger the <code>/viewPost/{postId}</code> endpoint, with the <code>postId</code> value being converted to <code>1</code> and the <code>postRepository</code> will fetch the post with the <code>id</code> of <code>1</code>, returning it to the <code>view-post</code> Thymeleaf view:
<pre><code class="hljs">&lt;div class=&quot;container&quot;&gt;
 &lt;div class=&quot;row&quot;&gt;
 &lt;div class=&quot;col-md-12 bg-light&quot;&gt;
 &lt;p th:text=&quot;${post.content}&quot;&gt;&lt;/p&gt;
 &lt;/div&gt;
 &lt;/div&gt;
&lt;/div&gt;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Path variables are a common and key-feature of REST APIs. In this guide, we've taken a look at how to use path variables in Spring Boot with Thymeleaf.

Guest Contributor

In this guide, we'll be taking a look at how to use path variables in Spring Boot controllers, as well as how to generate links with path variables with Thymeleaf.

Thymeleaf Path Variables with Spring Boot

Accidentally committed something to the wrong branch? Perhaps, you just committed the new shining feature, and to your dismay, there's a typo in the user interface you haven't seen before, and you'd like to take the commit back to fix that as well?
In some cases, you can fix it, do another commit and then <a target="_blank" href="/git-squash-multiple-commits-in-to-one-commit">squash them together</a> before pushing to the remote repository, but only if you'll be pushing the change anyway.
Alternatively, you can undo the latest local commit, make additional changes, and then push that commit to the remote repository, if you wish so.
<h2 id="undolastlocalcommit">Undo Last Local Commit</h2>
Let's create a file we'd like to add to our repository, add it and finally commit:
<pre><code class="hljs">$ echo &quot;Hello World!&quot; &gt;&gt; file.txt
$ git add file.txt
$ git commit -m &quot;Added file.txt&quot;
$ echo &quot;It&#x27;s a great day today :(&quot; &gt;&gt; file.txt
$ git add file.txt
$ git commit -m &quot;Modified file.txt&quot;
</code></pre>
Yikes, we've accidentally left in a horrible typo in the content. We've put in the parentheses in the wrong way! And we've just committed that mistake:
<pre><code class="hljs">$ git log --pretty=oneline
df9fc1b773ecf3ba14c990615831f1087817611f (HEAD -&gt; main) Modified file.txt
55db4f399d1ad64e0a40e1858d23fef0ffe31fb0 Added file.txt
</code></pre>
To remove a local commit, assuming it hasn't been pushed to the remote repository yet, we can use the <code>git reset</code> command, which is effectively the opposite of <code>git add</code>:
<pre><code class="hljs">$ git reset HEAD~
Unstaged changes after reset:
M file.txt
</code></pre>
We've reset the <code>HEAD</code> (pointer to the last commit), pointing it back (<code>~</code>) to the previous commit. By including a number after the tilde, we could've gone back multiple commits instead of just one.

 <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: On certain operating systems, you might have to use different notation. <code>HEAD~</code>, <code>HEAD^</code> and <code>HEAD@{1}</code> all refer to the previous commit, but certain terminals and operating systems might not work with all of these notations.

 </div>
 </div>
 </div>
 Once reset, the change we've made to the <code>file.txt</code>, i.e. the erroneous modification is unstaged. Let's take a look at the log again:
<pre><code class="hljs">$ git log --pretty=oneline
55db4f399d1ad64e0a40e1858d23fef0ffe31fb0 (HEAD -&gt; main) Added file.txt
</code></pre>
And the status is:
<pre><code class="hljs">$ git status
On branch main
Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git restore &lt;file&gt;...&quot; to discard changes in working directory)
 modified: file.txt

no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
</code></pre>
However, what are the contents of the file now?
<pre><code class="hljs">$ nano file.txt

Hello World
It&#x27;s a great day today :(
</code></pre>
By default, the <code>reset</code> command is <code>--soft</code>. The <code>--soft</code> flag doesn't reset the changes done to the file, just removes the commit that was made. Let's go ahead and re-commit this mistake again, so we can take a look at what happens when we run the <code>--hard</code> option.
<h2 id="hardreset">Hard Reset</h2>
Instead of the <code>--soft reset</code>, which we can use to simply undo the commit, while leaving the files intact (and the changes still present, which is why the <code>git status</code> command prompted us with staging the changes) - we can also do a <code>--hard reset</code>:
<pre><code class="hljs">$ git reset --hard HEAD~
HEAD is now at 55db4f3 Added file.txt
</code></pre>
This time around, the changes aren't unstaged, like before. They're removed. If we check the <code>log</code>, it'll look much like last time:
<pre><code class="hljs">$ git log --pretty=oneline
55db4f399d1ad64e0a40e1858d23fef0ffe31fb0 (HEAD -&gt; main) Added file.txt
</code></pre>
Though, if we check the <code>status</code>:
<pre><code class="hljs">$ git status
On branch main
nothing to commit, working tree clean
</code></pre>
There's nothing to commit, because the change that was made to the file in the previous commit was also removed, setting the <code>HEAD</code> back to the first commit:
<pre><code class="hljs">$ nano file.txt
Hello World!
</code></pre>

In this short tutorial, we'll take a look at how to reset the HEAD in a Git repository - thereby undoing the latest local commit, and it's flavors.

Git: Undo Latest Local Commit

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to turn off a Matplotlib plot's axis. That is to say - how to turn off individual elements, such as tick labels, grid, ticks and individual spines, but also how to turn them all off as a group, collectively referred to as the axis.
Most of the approaches we'll be covering work the same for 2D and 3D plots - both the regular <code>Axes</code> and <code>Axes3D</code> classes have the same methods for this. For some, since 3D plots have more than two spines, they won't be the same.

 <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: For the remainder of this guide, we'll be using a 3D plot, as this is a more common case where you might want to turn off the spines and ticks - and let the data speak for itself, as well as a 2D plot on the same dataset.

 </div>
 </div>
 </div>
 We'll specifically be using a recreation of the CP1919 pulsar data, as discovered by <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Jocelyn_Bell_Burnell">Jocelyn Bell Burnell</a> in 1967, visualized by by Harold D. Craft, Jr. in his <a rel="nofollow noopener" target="_blank" href="https://www.worldcat.org/title/radio-observations-of-the-pulse-profiles-and-dispersion-measures-of-twelve-pulsars-by-harold-d-craft-jr/oclc/657635342">PhD Thesis in 1970</a> and popularized by <a rel="nofolllow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Peter_Saville_(graphic_designer)">Peter Saville</a> in 1979, when the English band Joy Division was on the lookout to release a new album - &quot;Unknown Pleasures&quot;:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

df = pd.read_csv(r&quot;https://raw.githubusercontent.com/StackAbuse/CP1919/master/data-raw/clean.csv&quot;)
groups = df.groupby([&#x27;line&#x27;])

plt.style.use(&#x27;dark_background&#x27;)

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111, projection=&#x27;3d&#x27;)
ax.set_xlabel(&#x27;Line Number&#x27;)
ax.set_ylabel(&#x27;Time&#x27;)
ax.set_zlabel(&#x27;Intensity&#x27;)

for group in groups:
 line = ax.plot(group[1][&#x27;line&#x27;], group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
Which results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-1.png" alt="3D Ridge Plot in Matplotlib - CP1919">
<blockquote>
If you'd like to learn more about Ridge Plots (shown above), build a foundation in Matplotlib and explore advanced usage of the library, make sure to check out our <a href="https://gumroad.com/l/data-visualization-in-python-book-bundle" target="_blank">Data Visualization in Python eBoook Bundle</a>. This specific visualization is taken straight out of the book, from a longer section dedicated to this dataset and the history of the plot.
</blockquote>
Now, let's take a look at how to remove the spines, tick labels, ticks, grid and axis labels.
<h2 id="turningofftheaxiswithaxaxisoff">Turning off the Axis with ax.axis('off')</h2>
The easiest way to turn off everything axis-related is via a convenience function - <code>axis('off')</code> on your <code>Axes</code> or <code>Axes3D</code> instance:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Load dataset in and set style...

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111, projection=&#x27;3d&#x27;)
ax.set_xlabel(&#x27;Line Number&#x27;)
ax.set_ylabel(&#x27;Time&#x27;)
ax.set_zlabel(&#x27;Intensity&#x27;)
ax.axis(&#x27;off&#x27;)

for group in groups:
 line = ax.plot(group[1][&#x27;line&#x27;], group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</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: You can also use the <code>axis('off')</code> function on the <code>plt</code> instance if you're plotting using the MATLAB-style API. Though, this approach is discouraged if you're plotting using the OOP API like we are currently.

 </div>
 </div>
 </div>
 This change to the code results in a plot without the spines, axis lines, ticks, tick labels, axis labels and grid:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-2.png" alt="Turn axis off with axis('off')">
The <code>axis()</code> function is a convenience function to access various properties.
<h2 id="turningofftheaxiswithaxset_axis_off">Turning off the Axis with ax.set_axis_off()</h2>
Alternatively, you can use the <code>ax.set_axis_off()</code> function, in conjecture with the <code>ax.set_axis_on()</code> function, which reverses the former's effects.
This is a very useful set of functions to use when updating plots, such as when animating them, or whenever you might want to turn the axis off and on, rather than just disabling it:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Load dataset in and set style...

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111, projection=&#x27;3d&#x27;)
ax.set_xlabel(&#x27;Line Number&#x27;)
ax.set_ylabel(&#x27;Time&#x27;)
ax.set_zlabel(&#x27;Intensity&#x27;)
ax.set_axis_off()

for group in groups:
 line = ax.plot(group[1][&#x27;line&#x27;], group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
This results in the exact same plot:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-3.png" alt="Turn axis off with set_axis_off()">
<h2 id="turningoffticksandticklabelsonaxes">Turning off Ticks and Tick Labels on Axes</h2>
Instead of turning all of these elements off, and making them invisible, you can also turn them off individually if you'd like to keep some.
This is where we'll be switching back to a 2D plot, since some of these functions don't work with 3D plots, given the fact that they've got more than just the X-axis and Y-axis.
For example, you can turn off individual axes (ticks and tick labels). You can use the <code>get_yaxis()</code> or <code>get_xaxis()</code> to get the respective axes and turn them off by using <code>set_visible(False)</code>:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv(r&quot;https://raw.githubusercontent.com/StackAbuse/CP1919/master/data-raw/clean.csv&quot;)
groups = df.groupby([&#x27;line&#x27;])

plt.style.use(&#x27;dark_background&#x27;)
fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111)
ax.set_xlabel(&#x27;Time&#x27;)
ax.set_ylabel(&#x27;Intensity&#x27;)

ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)

for group in groups:
 line = ax.plot(group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
This turns off the tick labels and ticks themselves, but leaves the frame (spines) on:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-4.png" alt="Turn ticks and tick labels off matplotlib">
<h2 id="turningoffindividualspinesonanaxes">Turning off Individual Spines on an Axes</h2>
To turn the spines off - you can access them via the <code>ax.spines</code> dictionary. Using their keys, <code>top</code>, <code>bottom</code>, <code>left</code>, and <code>right</code>, you can select each one, and using the <code>set_visible()</code> function, turn them off.
Let's turn of the top and right spine:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

# Load data and stylize

fig = plt.figure(figsize=(6, 8))

ax = fig.add_subplot(111)
ax.set_xlabel(&#x27;Time&#x27;)
ax.set_ylabel(&#x27;Intensity&#x27;)

ax.spines[&#x27;right&#x27;].set_visible(False)
ax.spines[&#x27;top&#x27;].set_visible(False)
# To turn off the bottom or left
#ax.spines[&#x27;bottom&#x27;].set_visible(False)
#ax.spines[&#x27;left&#x27;].set_visible(False)

for group in groups:
 line = ax.plot(group[1][&#x27;x&#x27;], group[1][&#x27;y&#x27;], color=&#x27;white&#x27;)

plt.show()
</code></pre>
This turns off the top and right spine, but leaves the bottom and left intact - as well as the ticks and their labels:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-5.png" alt="turn individual spines off in matplotlib">
You can also iterate through them, and turn them all off:
<pre><code class="hljs">for key, spine in ax.spines.items():
 spine.set_visible(False)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/matplotlib-turn-off-axis-spines-ticklabels-axislabels-grid-6.png" alt="turn all spines off in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to turn off the axis, as well as individual axis components in Matplotlib.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this guide, we'll take a look at how to turn off the axis, as well as its constituent elements individually in Matplotlib.

Matplotlib: Turn Off Axis (Spines, Tick Labels, Axis Labels and Grid)

Aleksandar Bursac

In this guide, we'll introduce you to Cypress - an end-to-end JavaScript testing framework, and explore its pros and cons, creating a demonstration testing workflow.

End-to-End Testing in JavaScript with Cypress

<h2 id="introduction">Introduction</h2>
The in-memory data store - Redis is extensively used by developers as a database, cache layer, to manage job queues, and more.
It comes in handy when you are building APIs with a job queue mechanism to handle tasks like running memory-intensive jobs in the background, counting page visits, or sending bulk email campaigns.
If you are building an API in Python, the Redis Queue (RQ) module gives you functions to queue, schedule, and process these jobs by deploying workers.
In this article, you will be exploring the RQ module to set up job queues and workers, as well as the RQ-Dashboard module to visualize them.
<h2 id="settingupredis">Setting Up Redis</h2>
If you don't have an API already, or any code you can apply Redis RQ to - you can clone our <a target="_blank" href="https://github.com/StackAbuse/redis-queues-redis-queue-dashboards">GitHub repository</a> with sample code.
Let's clone the repo and install its dependencies:
<pre><code class="hljs">$ git clone git@github.com:StackAbuse/redis-queues-redis-queue-dashboards.git
$ cd redis-queues-redis-queue-dashboards
$ python -m venv env
$ . env/bin/activate
$ pip install -r requirements.txt
</code></pre>
We also have to install Redis, which can actually be a bit tricky if you're not using a Linux-based OS. The easiest way to install it on non-Linux operating systems is via <a href="https://docs.docker.com/compose/" target="_blank" rel="nofollow noopener">Docker Compose</a>:
<pre><code class="hljs">$ docker-compose up -d
</code></pre>
Our <code>docker-compose</code> file is configured to download a Redis image, and that command will run it in the background. Alternatively, you can install Redis locally.
For Ubuntu, that installation looks like this:
<pre><code class="hljs">$ sudo apt-get install redis
$ sudo service redis-server start
Starting redis-server: redis-server.
$ redis-cli -v 
redis-cli 4.0.9
</code></pre>
Now that our environment is created, let's take a look at Redis Queues.
<h2 id="redisqueuerq">Redis Queue (RQ)</h2>
The Redis Queue (RQ) is a queuing module that runs on top of Redis. It acts as the producer to submit the jobs to the queue. The module also comes with workers which act as consumers to process the submitted jobs from the queue asynchronously. But, what is a job anyway?
<blockquote>
Jobs are references to Python functions that are pushed to the queue.
</blockquote>
Multiple queues to process jobs can exist, and these queues can be named in any way you'd like. The jobs submitted to the queues can be monitored using their job IDs.
Let's write a simple script to enqueue a job in a Redis Queue, in say, <code>test.py</code>:
<pre><code class="hljs"># Imported to assign redis as the backend to rq
from redis import Redis
# Imported to initialize the queue object
from rq import Queue
# Functions from the __main__ module can&#x27;t be processed by workers
# Hence, we have a separate Python file containing the function
from test_job import i_am_a_job

# Create the queue object by passing in the redis object
q = Queue(connection=Redis())
 
# Run the job asynchronously
job = q.enqueue(i_am_a_job, 1)
# Return the function output
</code></pre>
The function which you want to enqueue has to be imported from a separate Python file. We've imported it from <code>test_job.py</code>:
<pre><code class="hljs"># A Function (or) a job
def i_am_a_job(arg1):
 # Perform some function
 return arg1
</code></pre>
Now that the Redis Queue and the function is set, let's execute the Python script:
<pre><code class="hljs">$ python test.py
</code></pre>
Running this command should create a job but return no output. If you get an error, review the setup steps again before continuing.
If everything worked, let's use RQ-Dashboard to manage our job.
<h2 id="managingredisqueuejobswithrqdashboard">Managing Redis Queue Jobs with RQ-Dashboard</h2>
You can inspect the state of your jobs in a Redis Queue by using RQ-Dashboard, a lightweight Flask app used to monitor Redis Queues. Let's run RQ-Dashboard to monitor the job we've just created.
In a separate Terminal, navigate to the folder where you cloned the repo. There, we'll spin up RQ-Dashboard:
<pre><code class="hljs">$ . env/bin/activate
$ rq-dashboard
RQ Dashboard version 0.5.2
 * Serving Flask app &#x27;rq_dashboard.cli&#x27; (lazy loading)
 * Environment: production
 WARNING: This is a development server. Do not use it in a production deployment.
 Use a production WSGI server instead.
 * Debug mode: off
 * Running on all addresses.
 WARNING: This is a development server. Do not use it in a production deployment.
 * Running on http://192.168.1.10:9181/ (Press CTRL+C to quit)
192.168.1.10 - - [11/Jun/2021 15:30:12] &quot;GET / HTTP/1.1&quot; 200 -
</code></pre>
You can access RQ-Dashboard at <a href="http://localhost:9181" target="_blank">http://localhost:9181</a>. When you open the link, you'll notice that your job is still in the queue and there aren't any workers assigned yet:
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-01.jpg" alt="Screenshot of RQ-Dashboard running for the first time, it has not workers and one job">
<h2 id="redisqueueworkers">Redis Queue Workers</h2>
Workers pick a job from the queue to execute them. In another Terminal (you can use the first as well), let's create a worker:
<pre><code class="hljs">$ . env/bin/activate # For new Terminals when you don&#x27;t install the dependencies locally
$ rq worker --with-scheduler
15:42:38 Worker rq:worker:a33eb6277eda4969921cc8e3f1e857c0: started, version 1.8.1
15:42:38 Subscribing to channel rq:pubsub:a33eb6277eda4969921cc8e3f1e857c0
15:42:38 *** Listening on default...
15:42:38 Trying to acquire locks for default
15:42:38 Cleaning registries for queue: default
15:42:38 Scheduler for default started with PID 1093
15:42:38 default: test_job.i_am_a_job(1) (b92bf928-48dd-4fb9-a551-427866c46a38)
15:42:38 default: Job OK (b92bf928-48dd-4fb9-a551-427866c46a38)
15:42:38 Result is kept for 500 seconds
</code></pre>
The job that you submitted has been executed and the result is kept in Redis for 500 seconds. In addition to the immediate job executions, jobs can also be scheduled to be run at a future time, similar to a <a href="/how-to-use-the-crontab-command-in-unix" target="_blank">CRON job</a>. The enqueue statement can be written as a scheduled one by:
<pre><code class="hljs">job = queue.enqueue_at(datetime(2021, 7, 7, 13, 15), i_am_a_job, 1)
</code></pre>
These operations are the basis of using Redis Queues, monitoring them and assigning workers. Now, let's write up a small, practical application that counts the number of page visits.
<h2 id="redisqueuedemoapplicationcountingsitevisits">Redis Queue Demo Application - Counting Site Visits</h2>
The code in the repository that you downloaded earlier includes a Flask application:
<pre><code class="hljs">from flask import Flask
from redis import Redis
from rq import Queue
from counter import visit

app = Flask(__name__)
q = Queue(connection=Redis())


@app.route(&#x27;/visit&#x27;)
def count_visit():
 count = q.enqueue(visit)
 return &quot;Visit has been registered&quot;


@app.route(&#x27;/&#x27;)
def return_visit_count():
 count = Redis().get(&#x27;count&#x27;).decode(&#x27;utf-8&#x27;) if Redis().get(&#x27;count&#x27;) else &#x27;0&#x27;
 return (f&#x27;&lt;h1&gt; Congrats! Your are the visitor no.: {count} &lt;/h1&gt;&#x27;)
</code></pre>
In your Terminal, let's run this Flask app:
<pre><code class="hljs">$ . env/bin/activate # Unless it&#x27;s already running
$ flask run
</code></pre>
This launches the Flask app in <code>app.py</code>. This app contains two routes: <code>/</code> and <code>/visit</code>.
Every time the <a href="http://localhost:5000/visit" target="_blank">http://localhost:5000/visit</a> endpoint is hit, the <code>count</code> key in Redis is incremented by 1 and the following webpage is returned.
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-02.jpg" alt="Screenshot of initial website visitor acknowledgement page">
The incrementing function is queued as a job. The number of visits is visible in the endpoint: <a href="http://localhost:5000" target="_blank">http://localhost:5000</a> as:
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-03.jpg" alt="Screenshot of website displaying the visitor count">
Let's try visiting the endpoint <a href="http://localhost:5000/visit" target="_blank">http://localhost:5000/visit</a> three times. This will submit our job thrice. Let's then check the status of our jobs on RQ-Dashboard. Visit <a href="http://localhost:9181" target="_blank">http://localhost:9181</a> and you can observe the following webpage where our jobs are successfully submitted but no workers are processing them:
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-04.jpg" alt="Screenshot of RQ-Dashboard showing new jobs being run">
To start the Redis Queue worker and scheduler, open another Terminal, and key in the command to start a worker. Observe that the submitted jobs are getting executed one after the other:
<pre><code class="hljs">$ . env/bin/activate # For new Terminals when you don&#x27;t install the dependencies locally
$ rq worker --with-scheduler
23:40:06 Worker rq:worker:f5a178b0931b42859699ce57696ed402: started, version 1.8.1
23:40:06 Subscribing to channel rq:pubsub:f5a178b0931b42859699ce57696ed402
23:40:06 *** Listening on default...
23:40:06 Trying to acquire locks for default
23:40:06 Cleaning registries for queue: default
23:40:06 Scheduler for default started with PID 2889
23:40:06 default: counter.visit() (d23c4df8-d638-476b-b70a-dbb4b6f091f2)
23:40:06 default: Job OK (d23c4df8-d638-476b-b70a-dbb4b6f091f2)
23:40:06 Result is kept for 500 seconds
23:40:06 default: counter.visit() (f4ca10c4-16f2-4578-b1b7-67dfce3cee5a)
23:40:06 default: Job OK (f4ca10c4-16f2-4578-b1b7-67dfce3cee5a)
23:40:06 Result is kept for 500 seconds
23:40:06 default: counter.visit() (956b7b39-0b82-4ac6-b29e-fe3f0706431e)
23:40:06 default: Job OK (956b7b39-0b82-4ac6-b29e-fe3f0706431e)
23:40:06 Result is kept for 500 seconds
</code></pre>
You can check the dashboard again and you may find that the jobs have been executed. This can be checked by pointing to the URL on your browser to <a href="http://localhost:9181" target="_blank">http://localhost:9181</a>. Notice that the worker is now up and running and the jobs have been processed successfully.
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-05.jpg" alt="Screenshot of RQ-Dashboard showing new working that's registered">
Let's check the number of visits by opening or refreshing the app on <a href="http://localhost:5000" target="_blank">http://localhost:5000</a>. Voilà! The page visit counter has been incremented by 3.
<img src="https://stackabuse.s3.amazonaws.com/media/redis-queues-redis-queue-dashboards-06.jpg" alt="Screenshot of visitor count website, the count was incremented by 3 since the last screenshot">
Think of a website with high traffic and one wishes to monitor the site visits and page visits. In this case, multiple instances of this API are served under a load balancer and the count is done based on the jobs submitted in the queue asynchronously.
<h2 id="conclusion">Conclusion</h2>
In this article, we have explored the importance of job queues and how RQ and RQ-Dashboards can serve as a minimalistic job queue stack to your web apps. The practical example can be expanded to other real-world applications where the possibilities are endless.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

In this article, you will be exploring the RQ module to set up job queues and workers, as well as the RQ-Dashboard module to visualize them.