Python - Best Place for Generic Functions

Question

I am writing a flask application, and I have found I have have ton of generic utility functions.

Here are the examples of the type of functions that I consider generic utility functions:

def make_hash():
  return defaultdict(make_hash)

def file_read(filename):
  with open(file_name_, 'r') as f:
    return f.read()

def file_write(filename, data):
  with open(filename, 'w') as f:
    f.write(data)

I was thinking of tossing these functions into a separate module all together. However, I am curious if I have the following concerns:

• There are two few unique functions to warrant a separate module all together. i.e. the file_read, and file_write functions above could go into a file.py module, however since its two functions, I feel like this might be overkill.
• In my application I use these functions 2-3 times per function so I am moving under the guise they creating these utility functions should help me save some lines of code, and hopefully is making me more efficient.

Question: - What would be the pythonic way of grouping generic utility functions? Should I create a separate module? Curious what others are doing for organizing this type of code.

Answer 1

I don't think it has much relation to Python, it's more a design decision.

For only these lines I would not make a separate module; however, if you use it 2 to 3 times I would not copy the code. If you later want to change something only one change is needed, keeping functionality consistent.

Also the methods seem to be very generic, so you could easily use them in other projects later.

And I assume you want to make them static (@static_method).

What I mostly do is group generic utility classes by type, i.e. in your case one file for dictionaries (having 1 method) and one for file (having 2 methods). Later possibly more methods will be added but the functionality is grouped by type/usage.

Answer 2

There is something you can do to reduce the number of module files while retaining sub-categorisation of your modules.. Create multi-level module functions: myModule.Hash.<> myModule.FileIO.<>

This way you can import individual components as per your liking.

Answer 3

In python we have something called Package (a usual folder with an empty file called __init__.py) this is used to contain all of your modules this way we create somesort of name spacing.

your application can access to its own name space using .

for example have the following files

MyPackage/__init__.py (empty)
MyPackage/webapp.py (your web application)
MyPackage/utils.py (generic utilities)

and in webapp.py you can have something like this

from .utils import *

or list them one by one

from .utils import file_read, file_write

pay attention to the dot prefix before utils