Python Clean Code – Declaring Constants: One File or Separate?

clean codepython

I currently have a small list (< 20) of constants that can be segmented into the following three parts:

- main script (tokens, log file location)
- database setup (username, passwords)
- API (API key, various external IDs)

I felt that it cluttered the top of the files during declaration, so I transferred them into a constants file. However, when importing them back to the three files, for instance say the database setup, it would become

import constants

...

db = connect(constants.RDS_HOSTNAME, constants.RDS_PASSWORD)

compared to if I had declared them in the file

RDS_HOSTNAME = 'xxx'
RDS_PASSWORD = 'yyy'

...

db = connect(RDS_HOSTNAME, RDS_PASSWORD)

which I feel is a bit more readable when using the constants.

If I combine the both, I would have

from constants import *

...

db = connect(RDS_HOSTNAME, RDS_PASSWORD)

but all posts I've read suggest very heavily against this as it would increase confusion due to not knowing where the constants come from.

My question is this: given that I have only one constants file with no functions, and all constants are upper case, would using from constants import * nonetheless be poor practice? Due to the uppercase notation, I would know immediately it's a constant and comes from the constants file, thus reducing confusion.

Best Answer

All the “constants” you listed have nothing to do in your code. They belong to the configuration.

Think it this way. Your code contains the logic. Whenever you change the logic, you change your code. Whenever you change information about the world, you don't change your code.

If this is still unclear, think about somebody taking your code and running it in a very different context. For instance you created a bulletin board system and you run it on your local server, connecting to the specific PostgreSQL database and using Amazon S3 to store uploaded files. You published the source code on GitHub, which allows me to grab the code and run it on my own infrastructure, using my own PostgreSQL database and my own S3 bucket (you won't enjoy paying Amazon to let me store this data in your bucket, do you?) Therefore, GitHub will contain the logic; configuration files, on the other hand, would be kept private on your servers, and should never reach GitHub (unless you really want people to use your S3 bucket for free).

API keys, passwords and log file locations should therefore be in configuration files, and constants should be kept for things which are constant within the scope of your logic. If, say, your logic forces you to have specific types of users, for instance administrators—designed as Administrator in your code, ordinary users—Contributor, and finally anonymous users—Guest, then Administrator, Contributor and Guest are the constants, because they are part of your business logic. In this case, you'll put them in the file in which they belong, possibly in or near the class which represents the user or more specifically the type of the user.

Related Solutions

Interoperability – How to Have Two Programs in Different Languages Interact

Code written in different languages can interact in a number of ways.

At the source level, cross-compilation from one language into the other can be done for some combinations of languages (for example, Google's GWT includes a java-to-javascript compiler; the Glasgow Haskell compiler can compile to C; early versions of C++ compiled to C). Most of the time, however this is not really feasible.

Languages that share a virtual platform, such as the JVM or the .NET runtime, can usually interact through mechanisms exposed by the platform - for example all JVM languages can access Java libraries and use them to communicate among each other, and they can call methods and use classes created in any other JVM language.

Many programming languages, including Python, offer a mechanism to interface with native libraries, typically written in C. Using such a mechanism, it is possible to call native functions from another, more high-level, language. Popular libraries often have bindings readily available. This technique is usually referred to as a "Foreign Function Interface". The Python-into-C interface is the CFFI.

Another option is to build two completely separate programs and have them interact at runtime. There are various mechanisms to achieve this; the easiest is through a pipe (look into the subprocess module for python): basically, one program calls the other, sending input to its stdin and reading the result back from its stdout. This makes one program a subprocess of the other; if you need both to be long-lived and started independently, data can be passed back and forth through named pipes, (local) network sockets, shared files, and (depending on the platform) other means. Which one is best depends.

Python Database – How to Manage Database Connections in a Python Library Module

It really depends on the library you're using. Some of them could be closing the connection on their own (Note: I checked the builtin sqlite3 library, and it does not). Python will call a destructor when an object goes out of scope, and these libraries might implement a destructor that closes the connections gracefully.

However, that might not be the case! I would recommend, as others have in the comments, to wrap it in an object.

class MyDB(object):

    def __init__(self):
        self._db_connection = db_module.connect('host', 'user', 'password', 'db')
        self._db_cur = self._db_connection.cursor()

    def query(self, query, params):
        return self._db_cur.execute(query, params)

    def __del__(self):
        self._db_connection.close()

This will instantiate your database connection at the start, and close it when the place your object was instantiated falls out of scope. Note: If you instantiate this object at the module level, it will persist for your entire application. Unless this is intended, I would suggest separating your database functions from the non-database functions.

Luckily, python has standardized the Database API, so this will work with all of the compliant DBs for you :)

Best Answer

Related Solutions

Interoperability – How to Have Two Programs in Different Languages Interact

Python Database – How to Manage Database Connections in a Python Library Module

Related Topic