The modular design of calibre is expressed via Plugins. There is a tutorial on writing calibre plugins.
For example, adding support for a new device to calibre typically involves writing less than a 100 lines of code in the form of
a device driver plugin. You can browse the
built-in drivers. Similarly, adding support
for new conversion formats involves writing input/output format plugins. Another example of the modular design is the recipe system for
fetching news. For more examples of plugins designed to add features to calibre, see the Index of plugins.

All the calibre python code is in the calibre package. This package contains the following main sub-packages

devices - All the device drivers. Just look through some of the built-in drivers to get an idea for how they work.

For details, see: devices.interface which defines the interface supported by device drivers and devices.usbms which
defines a generic driver that connects to a USBMS device. All USBMS based drivers in calibre inherit from it.

e-books - All the e-book conversion/metadata code. A good starting point is calibre.ebooks.conversion.cli which is the
module powering the ebook-convert command. The conversion process is controlled via conversion.plumber.
The format independent code is all in ebooks.oeb and the format dependent code is in ebooks.format_name.

Metadata reading, writing, and downloading is all in ebooks.metadata

Conversion happens in a pipeline, for the structure of the pipeline,
see Inleiding. The pipeline consists of an input
plugin, various transforms and an output plugin. The code that constructs
and drives the pipeline is in plumber.py. The pipeline works on a
representation of an e-book that is like an unzipped epub, with
manifest, spine, toc, guide, html content, etc. The
class that manages this representation is OEBBook in ebooks.oeb.base. The
various transformations that are applied to the book during
conversions live in oeb/transforms/*.py. And the input and output
plugins live in conversion/plugins/*.py.

If you only plan to make a few small changes, you can make your changes and
create a “merge directive” which you can then attach to a ticket in the calibre
bug tracker. To do this, make your
changes, then run:

This will create a my-changes file in the current directory,
simply attach that to a ticket on the calibre bug tracker.
Note that this will include all the commits you have made. If you only want
to send some commits, you have to change origin/master above. To send only
the last commit, use:

gitformat-patchHEAD~1--stdout>my-changes

To send the last n commits, replace 1 with n, for example, for the last 3
commits:

gitformat-patchHEAD~3--stdout>my-changes

Be careful to not include merges when using HEAD~n.

If you plan to do a lot of development on calibre, then the best method is to create a
GitHub account. Below is a basic guide to setting up
your own fork of calibre in a way that will allow you to submit pull requests
for inclusion into the main calibre repository:

You can update your local copy with code from the main repo at any time by doing:

gitpullupstream

You should also keep an eye on the calibre development forum. Before making
major changes, you should discuss them in the forum or contact Kovid directly
(his email address is all over the source code).

You must also get the calibre source code separately as described above.

Install calibre normally, using the Windows installer. Then open a Command Prompt and change to
the previously checked out calibre code directory. For example:

cdC:\Users\kovid\work\calibre

calibre is the directory that contains the src and resources sub-directories.

The next step is to set the environment variable CALIBRE_DEVELOP_FROM to the absolute path of the src directory.
So, following the example above, it would be C:\Users\kovid\work\calibre\src. Here is a short
guide to setting environment
variables on Windows.

Once you have set the environment variable, open a new command prompt and check that it was correctly set by using
the command:

echo%CALIBRE_DEVELOP_FROM%

Setting this environment variable means that calibre will now load all its Python code from the specified location.

That’s it! You are now ready to start hacking on the calibre code. For example, open the file src\calibre\__init__.py
in your favorite editor and add the line:

print("Hello, world!")

near the top of the file. Now run the command calibredb. The very first line of output should be Hello,world!.

You can also setup a calibre development environment inside the free Microsoft
Visual Studio, if you like, following the instructions here.

Save this file as /usr/bin/calibre-develop, then set its permissions so that it can be executed:

chmod+x/usr/bin/calibre-develop

Als u dit heeft gedaan, voer uit:

calibre-develop

You should see some diagnostic information in the Terminal window as calibre
starts up, and you should see an asterisk after the version number in the GUI
window, indicating that you are running from source.

You must also get the calibre source code separately as described above.

calibre is primarily developed on Linux. You have two choices in setting up the development environment. You can install the
calibre binary as normal and use that as a runtime environment to do your development. This approach is similar to that
used in Windows and macOS. Alternatively, you can install calibre from source. Instructions for setting up a development
environment from source are in the INSTALL file in the source tree. Here we will address using the binary as a runtime, which is the
recommended method.

Install calibre using the binary installer. Then open a terminal and change to the previously checked out calibre code directory, for example:

cd/home/kovid/work/calibre

calibre is the directory that contains the src and resources sub-directories.

The next step is to set the environment variable CALIBRE_DEVELOP_FROM to the absolute path of the src directory.
So, following the example above, it would be /home/kovid/work/calibre/src. How to set environment variables depends on
your Linux distribution and what shell you are using.

Once you have set the environment variable, open a new terminal and check that it was correctly set by using
the command:

echo $CALIBRE_DEVELOP_FROM

Setting this environment variable means that calibre will now load all its Python code from the specified location.

That’s it! You are now ready to start hacking on the calibre code. For example, open the file src/calibre/__init__.py
in your favorite editor and add the line:

print("Hello, world!")

near the top of the file. Now run the command calibredb. The very first line of output should be Hello,world!.

The calibre source tree is very stable and rarely breaks, but if you feel the need to run from source on a separate
test library and run the released calibre version with your everyday library, you can achieve this easily using
.bat files or shell scripts to launch calibre. The example below shows how to do this on Windows using .bat files (the
instructions for other platforms are the same, just use a shell script instead of a .bat file)

You can insert the following two lines of code to start an interactive Python session at that point:

fromcalibreimportipythonipython(locals())

When running from the command line, this will start an interactive Python interpreter with access to all
locally defined variables (variables in the local scope). The interactive prompt even has TAB completion
for object properties and you can use the various Python facilities for introspection, such as
dir(), type(), repr(), etc.

You can use the builtin Python debugger (pdb) as a remote debugger from the
command line. First, start the remote debugger at the point in the calibre code
you are interested in, like this:

fromcalibre.rpdbimportset_traceset_trace()

Then run calibre, either as normal, or using one of the calibre-debug commands
described in the previous section. Once the above point in the code is reached,
calibre will freeze, waiting for the debugger to connect.

Now open a terminal or command prompt and use the following command to start
the debugging session:

By default, the remote debugger will try to connect on port 4444. You can
change it, by passing the port parameter to both the set_trace() and the
cli() functions above, like this: set_trace(port=1234) and
cli(port=1234).

Notitie

The Python debugger cannot handle multiple threads, so you have to
call set_trace once per thread, each time with a different port number.

It is possible to use the builtin debugger in your favorite Python IDE, if it
supports remote debugging. The first step is to add the calibre src checkout to
the PYTHONPATH in your IDE. In other words, the directory you set as
CALIBRE_DEVELOP_FROM above, must also be in the PYTHONPATH of your IDE.

Then place the IDE’s remote debugger module into the src subdirectory
of the calibre source code checkout. Add whatever code is needed to launch the
remote debugger to calibre at the point of interest, for example in the main
function. Then run calibre as normal. Your IDE should now be able to connect to
the remote debugger running inside calibre.

The calibre-debug command provides a couple of handy switches to execute your own
code, with access to the calibre modules:

calibre-debug-c"some Python code"

is great for testing a little snippet of code on the command line. It works in the same way as the -c switch to the Python interpreter:

calibre-debugmyscript.py

can be used to execute your own Python script. It works in the same way as passing the script to the Python interpreter, except
that the calibre environment is fully initialized, so you can use all the calibre code in your script. To use command line arguments with your script, use the form: