<h2 id="introduction">Introduction</h2>
Web applications typically receive user input in some form - and with any input, validation is important. Making sure that form fields contain valid data, or that they contain any data at all is one of the first checks you can do.
When a user uploads files - you'll want to check whether these files are empty, not just if they exist or not. Additionally, since Node supports server-side development and can work with the file system, you'll find yourself working with files and directories all the time, especially if you're creating a CLI application.
In this guide, we'll take a look at how to check if a file or directory is empty, using Node.js.

 <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 task can be observed through two lenses - receiving a file from the front-end and validating it, or working with the file system regardless of potentially non-existent front-end. We'll be taking a look at both.

 </div>
 </div>
 </div>
 <h2 id="checkifafileisselectedwithjavascript">Check if a File is Selected With JavaScript</h2>
Vanilla JavaScript isn't up for the task of checking whether a file is empty or not, since it can check whether a form has a file attached to it, but can't process the file itself.
We'll start from there - checking if the file is selected from the file system and attached to the form. Let's create a simple form on the front-end
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
 &lt;!-- Meta tags --&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;form enctype=&quot;multipart/form-data&quot;&gt;
 &lt;input type=&quot;file&quot; name=&quot;file&quot; id=&quot;file&quot;&gt;
 &lt;button type=&quot;submit&quot; onclick=&quot;checkFile()&quot;&gt;Submit&lt;/button&gt; 
 &lt;/form&gt;
 
 &lt;script src=&quot;script.js&quot;&gt;&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
The page contains a <code>&lt;form&gt;</code> that accepts a <code>multipart</code> file, through an <code>&lt;input type=&quot;file&quot;&gt;</code>. Once the button is pressed, the <code>checkFile()</code> function is triggered, from the imported <code>script.js</code>:
<pre><code class="hljs">function checkFile() {
 let fileInputField = document.getElementById(&quot;file&quot;);
 if (fileInputField.files.length == 0) {
 alert(&quot;Please select a file!&quot;)
 }
}
</code></pre>
We get our <code>input</code> element with <code>document.getElementById()</code> and check the length of the <code>files</code> property, which an <code>input</code> of type <code>file</code> has. If it's empty, we alert the user that no file has been selected.
Once we're sure that the user has supplied a file, we can check whether they've supplied a non-empty file.
<h2 id="thefsmodule">The fs Module</h2>
<a rel="nofollow noopener" target="_blank" href="https://nodejs.org">Node.js</a> is a JavaScript runtime environment that executes JavaScript code outside of the browser. This gives us the ability to interface with the underlying operating system and file system as well. The built-in <code>fs</code> (File System) module works wonders for us in this case.
We'll be relying on the <code>fs.readFile()</code> and <code>fs.readdir()</code> methods.
<h2 id="checkifafileisemptywithnodejs">Check if a File is Empty with Node.js</h2>
Once the user sends a file through a form to your back-end, say, to the <code>/upload</code> endpoint, it's time to check whether the file is empty.
The easiest way to check is to stream the data within the file and check its length. If there are 0 bytes in the file, or rather, if the <code>length</code> of the data is equal to <code>0</code>, the file is empty:
<pre><code class="hljs">router.post(&#x27;/upload&#x27;, function(req, res) {
 const fs = require(&#x27;fs&#x27;);
 const multiparty = require(&#x27;multiparty&#x27;);
 let form = new multiparty.Form();
 form.parse(req, function(err, fields, files) {
 let file = files.keySelect[0];
 fs.readFile(file, function(err, data) {
 if (data.length == 0) {
 return res.status(422).json({message : &quot;File is empty! Unprocessable Entity.&quot;});
 }
 })
 });
 return res.status(200).json({message: &quot;Success&quot;});
});
</code></pre>
We've used the <a target="_blank" rel="nofollow noopener" href="https://www.npmjs.com/package/multiparty"><code>multiparty</code> module</a> to obtain the file from the form, though, this step can be done with various other libraries as well, such as <a target="_blank" href="https://stackabuse.com/handling-file-uploads-in-node-js-with-expres-and-multer">Multer</a> or <a target="_blank" href="https://www.npmjs.com/package/formidable">Formidable</a>.
With <code>multiparty</code>, we can create an instance of a form and parse it, passing the <code>req</code> to it, which is our <code>formData</code> sent from the front end. The <code>keySelect()</code> method returns all files sent via the form, but since our form only accepts one and we're only expecting one - we're accessing it via <code>[0]</code>. Using the <code>fs.readFile()</code> method, we're reading the file and unpacking its <code>data</code>. If this <code>data</code> has a <code>length</code> of <code>0</code> - the file is empty, and we return a “422 Unprocessable Entity” status code.
If you're not dealing with a form-provided file, and already have the name in mind, you can skip this process entirely and read the file directly:
<pre><code class="hljs">fs.readFile(&quot;myFile.txt&quot;, function(err, data) {
 if (data.length == 0) {
 console.log(&quot;File is empty!&quot;);
 } else {
 console.log(&quot;File is not empty!&quot;);
 }
})
</code></pre>
<h2 id="checkifadirectoryisemptywithnodejs">Check if a Directory is Empty with Node.js</h2>
When checking if a directory is empty, we can use the <code>readDir()</code> method:
<pre><code class="hljs">fs.readdir(directoryName, function(err, data) {
 if (data.length == 0) {
 console.log(&quot;Directory is empty!&quot;);
 } else {
 console.log(&quot;Directory is not empty!&quot;);
 }
})
</code></pre>
These two methods are completely equivalent in syntax (except for the name of the method), so everything that applies to one, applies to the other. If the <code>data</code> of the directory is equal to <code>0</code>, it's empty.
This is typically coupled with <a target="_blank" href="https://stackabuse.com/node-list-files-in-a-directory">listing files in a directory</a>.
<h2 id="conclusion">Conclusion</h2>
Working with files is commonplace for Node projects, as it's meant to be used on the server-side. One of the basic checks you can perform to validate files is to check whether they're empty or not.
In this guide, we've taken a look at how to check if a file or directory is empty with Node.js.

David Landup

Lazar Ristic

In this guide, we'll be taking a look at how to check if a file or directory is empty or not in Node.js, both when provided from a form, as well as for back-end work.

Node: Check if File or Directory is Empty

Guest Contributor

In this guide, we'll take a look at how to return HTTP status codes in Spring Boot applications with @ResponseStatus, ResponseEntity and ResponseStatusException.

How to Return HTTP Status Codes in a Spring Boot Application

<h2 id="introduction">Introduction</h2>
String manipulation in Python is achieved through a set of built-in methods, which return new strings since they're immutable. In this guide, we will look at methods to strip whitespace (in other languages it's also known as trimming) from strings in Python.
<h2 id="trimmethodsstrip">Trim Methods - strip()</h2>
In Python, the stripping methods are capable of removing leading and trailing spaces and specific characters. The leading and trailing spaces, include blanks, tabs (<code>\t</code>), carriage returns (<code>\r</code>, <code>\n</code>) and the other lesser-known whitespace characters that can be found <a href="https://en.wikipedia.org/wiki/Whitespace_character" target="_blank" rel="nofollow noopener">here</a>.
There are three ways in which the spaces or specific characters can be stripped from strings:
<ul>
<li><code>strip(chars)</code> - The vanilla strip method strips both the left and right sides of the string of the white spaces or characters mentioned.</li>
<li><code>lstrip(chars)</code> - The 'l' in the method's name corresponds to left, and this method strips white spaces or characters mentioned to the left of the input string.</li>
<li><code>rstrip(chars)</code> - The 'r' in the method's name correspond to right, and you guessed it right - it strips the characters to the right of the input string</li>
</ul>
If characters are to be stripped from the string, they need to be passed as an argument to the method, say <code>input.rstrip(&quot;abc&quot;)</code>. This is an optional argument, by default the functions strip whitespace as that's the most common usage.
<h2 id="trimmingstrippingwhitespacefromstrings">Trimming/Stripping Whitespace from Strings</h2>
Now that we are clear of what these methods are capable of, let's dive into some examples. We have an <code>input</code> and <code>output</code> string. The <code>input</code> variable denotes a string with both trailing and leading spaces, while the <code>output</code> string is a template that we can use to highlight these spaces:
<pre><code class="hljs"># trim.py
input = &quot; Stack Abuse &quot;
output = &quot;|{}|&quot;
# Remove leading spaces or spaces to the left
print(&quot;lstrip() Output:&quot;, output.format(input.lstrip()))
# Remove trailing spaces or spaces to the right
print(&quot;rstrip() Output:&quot;, output.format(input.rstrip()))
# Remove both trailing and leading spaces
print(&quot; strip() Output:&quot;, output.format(input.strip()))
</code></pre>
Once we <code>strip()</code> the <code>input</code> and add that result in-between the pipes (<code>|</code>), any whitespaces left will be very noticeable.
Running this code results in:
<pre><code class="hljs">$ python trim.py
lstrip() Output: |Stack Abuse |
rstrip() Output: | Stack Abuse|
 strip() Output: |Stack Abuse|
</code></pre>
<h2 id="trimmingstrippingspecialcharactersfromstrings">Trimming/Stripping Special Characters from Strings</h2>
Instead of removing only empty characters, it's not uncommon to remove a certain trailing and leading special character. Let's pass in a character argument to the <code>strip()</code> method:
<pre><code class="hljs"># trim_chars.py
input = &quot; ~~ Stack Abuse ~~ &quot;
output = &quot;|{}|&quot;
# Remove leading spaces or spaces to the left
print(&quot;lstrip() Output:&quot;, output.format(input.lstrip(&quot;~ &quot;)))
# Remove trailing spaces or spaces to the right
print(&quot;rstrip() Output:&quot;, output.format(input.rstrip(&quot;~ &quot;)))
# Remove both trailing and leading spaces
print(&quot; strip() Output:&quot;, output.format(input.strip(&quot;~ &quot;)))
</code></pre>
We've passed in the tilde as well as a whitespace (&quot;<code>~ </code>&quot;) as the argument of the <code>strip()</code> methods, removing any occurrence of either of them from the left, right and both sides of the string. It's worth noting that the order of these doesn't matter and that the <code>strip()</code> method doesn't perform pattern matching to remove these. It's conceptually similar to calling the <code>strip()</code> method twice, for each character.
Running this code results in:
<pre><code class="hljs">$ python trim_chars.py
lstrip() Output: |Stack Abuse ~~ |
rstrip() Output: | ~~ Stack Abuse|
 strip() Output: |Stack Abuse|
</code></pre>
<h2 id="usingstriponapandasseries">Using strip() on a Pandas Series</h2>
We can also perform the <code>strip()</code> methods for the a Pandas <code>Series</code>. The trailing spaces and characters for individual cells of the series can be stripped off. One thing to note is that the series needs to be converted to a string series before one performs the <code>strip()</code> operation.

 <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 are new to Pandas, read our <a href="/beginners-tutorial-on-the-pandas-python-library#installingpandas" target="_blank">Beginner's Guide to Pandas</a> to learn more about the library and how to set it up. Once Pandas is installed in your system, you can follow along with this code example!

 </div>
 </div>
 </div>
 Consider the following script:
<pre><code class="hljs"># strip_series.py
import pandas as pd

s = pd.Series([&#x27;1. Cell1. ~&#x27;, &#x27;2. Cell2!\n&#x27;])
print(&quot;Before strip():\n&quot;, s)
print(&quot;\nAfter strip():\n&quot;, s.str.strip(&#x27;.\n!~ &#x27;))
</code></pre>
Here, we're creating a series with cells containing special characters and trailing spaces. Via <code>series.str</code>, we can perform a method on each element of the Series. Considering the fact that these are strings, we can run any string method.
That being said, we can easily perform a <code>strip()</code> on each element of the sequence:
<pre><code class="hljs">$ python strip_series.py
Before strip()
 0 1. Cell1. ~
1 2. Cell2!\n
dtype: object
 
After strip()
 0 1. Cell1
1 2. Cell2
dtype: object
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Stripping (or trimming) characters from a string can be quite helpful when cleaning datasets, text files with multiple lines, or even the API responses. The basic but powerful Python methods can even work on Pandas series as well.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

In this tutorial, we'll take a look at Python's strip() method and how we can use it to trim strings, through practical examples.

Guide to Python's strip() Method

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.

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.