
_Photo by [Nicolas Picard](https://unsplash.com/@artnok) on
[unsplash.com](https://unsplash.com/photos/selective-focus-photography-of-spiderweb--lp8sTmF9HA)_

This project is a small collection of Python3 web server implementations, built
to run simple, uncomplicated applications in the browser without reaching for a
full framework.

`web.py` uses the standard library's `http.server` module together with
`socketserver.TCPServer` to serve a static `index.html` file — the same approach
Python3 uses to replace the old Python2 `SimpleHTTPServer`. It handles requests
synchronously, one at a time, which is enough for local development, quick file
sharing on a network, or serving static assets during offline work.

`async-server.py` takes the same basic goal — serve a page over HTTP — and
implements it with `asyncio` instead, using `asyncio.start_server` and a
coroutine-based request handler. It's considerably more code than the
`socketserver` version for the same result, which is part of the point: it shows
what asyncio buys you (non-blocking, concurrent request handling) and what it
costs in complexity versus the synchronous approach.

For the full breakdown, see the companion post,
[Creating a basic Python web server in Linux](https://www.mariadcampbell.com/blog/creating-a-basic-python-web-server-in-linux).
It covers the difference between `ForkingMixIn` and `ThreadingMixIn`, and how
`socketserver`'s server classes divide responsibility with request handler
classes. Finally, it provides a line-by-line look at the asyncio implementation.


A Python3 project exploring how to build simple synchronous and asynchronous HTTP servers using http.server, socketserver, and asyncio.

Basic Python Web Server


_Photo by [David Clode](https://unsplash.com/@davidclode) on
[unsplash.com](https://unsplash.com/photos/a-close-up-of-a-snake-on-a-rock-J_5xvghAvmc)_

This project takes the Official Django Polls App a step further, turning it into
a standalone Python package that can be installed into any Django project with
pip. It follows Django's advanced tutorial on writing reusable apps, working
through the packaging process end to end rather than just building the app
itself.

That process meant pulling the polls app out of its original project,
restructuring it as an independent package, and adding the files Python
packaging expects: a README, a BSD 3-Clause LICENSE, a pyproject.toml describing
the build, and a MANIFEST.in to include templates and static files in the
distribution. From there the package builds into both source and wheel formats
with Python's build tool, and installs cleanly into a virtual environment the
same way any third-party Django app would.

The result is a self-contained, pip-installable polls app, ready to drop into a
new Django project without copying files by hand.

## Related Resources

- [Django official advanced tutorial on writing reusable apps](/blog/django-official-advanced-tutorial-on-writing-reusable-apps):
  the companion post walking through this package's build process
- [Official Django Polls App](/projects/official-django-polls-app): the original
  project this package is built from


The Official Django Polls App repackaged as a standalone, installable Python package, following the Django project's advanced tutorial on writing reusable apps, complete with a pyproject.toml build config, MANIFEST.in, and BSD-licensed distribution.

Django Polls Package


_[Photo](https://www.pexels.com/photo/woman-standing-near-old-stone-wall-with-carved-images-4577718/)
by [Rachel Claire](https://www.pexels.com/@rachel-claire/) on
[pexels.com](https://www.pexels.com/)_

## Overview

A comparison of two approaches to encrypting and decrypting data: a modularized
Python application using the Fernet symmetric encryption method, and the GnuPG
(`gpg`) command-line tool. The project covers both file encryption and string
encryption, with each task split into its own single-purpose file.

## Task Modularization

The Python approach splits encryption and decryption into individual files by
responsibility:

- `create_key.py` — generates a 128-bit AES encryption key
- `get_key.py` — loads the generated key for use in the other scripts
- `encrypt_file.py` / `decrypt_file.py` — encrypt and decrypt a file
- `encrypt_string.py` / `decrypt_string.py` — encrypt and decrypt a string

The string-based functions required a bit more care: the encrypted message
generated in `encrypt_string.py` has to be imported into `decrypt_string.py` so
the correct token gets passed to `message_decrypt`, avoiding an `InvalidToken`
error from the `cryptography` package.

## Command Line Alternative

The same encrypt/decrypt tasks are also carried out using GnuPG, comparing the
tradeoffs of a programmatic approach against a quicker, less structured
command-line workflow using AES256 symmetric encryption.

## Related Resources

- [Encrypting and Decrypting Files and Strings](/blog/encrypting-and-decrypting-files-and-strings):
  companion post covering both approaches in full detail


A Python encryption/decryption toolkit comparing Fernet symmetric encryption in Python against GnuPG on the Command Line, for encrypting and decrypting both files and strings.

Encrypting/Decrypting Files and Strings


_[Photo by](https://www.pexels.com/photo/a-person-looking-through-a-cardboard-file-organizer-8473782/)
[Cup of Couple](https://www.pexels.com/@cup-of-couple/) on
[pexels.com](https://www.pexels.com/)_

This is a small `Python3` command-line script that organizes files into folders
based on their extension. Point it at a directory, and it sorts everything
inside into extension-named folders: `.py` files go into `python-files`, `.jpg`
files go into `jpg-files`, and so on, for a few dozen extensions covering text,
code, media, and archive formats.

The project is intentionally modularized. The extension-to-folder mapping lives
in its own `extensions.py` file as a dictionary, separate from the
`file_organizer.py` script that does the actual work. `file_organizer.py`
imports that dictionary, loops over each extension, creates the destination
folder if it doesn't already exist, and uses the `shutil` and `glob` modules to
find and move matching files.

Keeping the extension mapping separate from the logic that acts on it makes the
dictionary easy to extend or reuse without touching the core script.

## Running the application

Clone the repository and `cd` into it:

```shell
git clone https://github.com/interglobalmedia/file-organization-app.git
cd file-organization-app
```

Open `file_organizer.py` and set the `path` variable to the directory you want
organized:

```shell
path = r'/home/maria/Desktop'
```

Then run the script with:

```shell
python3 file_organizer.py
```

The script will create extension-named folders inside that directory as needed,
and move each file into its matching folder. Set `verbose = 0` in
`file_organizer.py` if you'd rather not see each file move printed to the
terminal.

## Related Resources

- [Creating a file organizer based on file extension using Python3](/blog/creating-a-file-organizer-based-on-file-extension-using-python3)
  — a full line-by-line walkthrough of the script, including the `for` loops,
  the `if` statements, and a bug I ran into (and fixed) along the way.


A Python3 script that sorts files into folders automatically based on their file extension.

File Organizer App


_Photo by [David Clode](https://unsplash.com/@davidclode) on
[unsplash.com](https://unsplash.com/photos/a-close-up-of-a-snake-on-a-rock-J_5xvghAvmc)_

This project is a Django Polls application built by following Django's official
tutorial from the ground up, after refactoring an earlier version of the same
app that had been sitting untouched for seven years. It's structured as a set of
reusable apps rather than a single monolithic project.

Along the way it covers setting up a virtual environment and starting a Django
project, defining and activating the polls models, working the interactive
Django shell, registering the app in the admin interface, writing views and
namespaced URLconfs, building out templates, adding a voting form, and
introducing automated tests. The project also wires up static files for local
development and the Django Debug Toolbar for inspecting requests in the browser.
Code quality is enforced with flake8, Black, and djLint, run automatically
through pre-commit hooks.

## Related Resources

- [Creating the official Django Polls app table of contents](/blog/creating-the-official-django-polls-app-table-of-contents):
  the eight-part series documenting this build
- [Django Polls Package](/projects/django-polls-package): this app repackaged as
  a standalone, installable Python package


A Django project following the official Django Polls tutorial from scratch, covering models, the admin interface, views and templates, forms, automated testing, static files, and the Django Debug Toolbar.

projects tag: python3

Basic Python Web Server

Django Polls Package

Encrypting/Decrypting Files and Strings

File Organizer App

Official Django Polls App