calibre Plugin Development

https://manual.calibre-ebook.com/creating_plugins.html
Admin
This documentation provides a comprehensive guide for developers to create custom plugins that...
Tokens:4,440,886
Snippets:24,276
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start Calibre Content Server with URL Prefix

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt_BR/server

Command to start the Calibre Content server, configuring it to serve content under a specified URL prefix and port. For reverse proxy setups, it's recommended to also use --listen-on 127.0.0.1 and --auth-mode=basic for faster basic authentication if SSL is enabled on the main server.

```Shell
calibre-server --url-prefix /calibre --port 8080
```

--------------------------------

### Add test print statement to Calibre source (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/develop

Example Python code to add near the top of `src\calibre\__init__.py` to verify the development setup is working. Running `calibredb` should output 'Hello, world!' as the first line.

```Python
print("Hello, world!")
```

--------------------------------

### Start Calibre Content Server with URL Prefix

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt/server

This command starts the Calibre Content server, configuring it to serve all URLs prefixed by `/calibre`. This is useful when you don't want to dedicate a full virtual host to Calibre, allowing it to run alongside other services on the same port.

```bash
calibre-server --url-prefix /calibre --port 8080
```

--------------------------------

### Systemd Unit File for Calibre Content Server

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt/server

This systemd unit file (`/etc/systemd/system/calibre-server.service`) defines how the Calibre Content server runs as a system service. It specifies the service description, dependencies, execution type, user/group, and the command to start the server, allowing it to be managed by systemd and started automatically at boot.

```ini
[Unit]
Description=calibre Content server
After=network.target

[Service]
Type=simple
User=mylinuxuser
Group=mylinuxgroup
ExecStart=/opt/calibre/calibre-server "/path/to/calibre library folder"

[Install]
WantedBy=multi-user.target
```

--------------------------------

### Start Calibre Content Server with URL Prefix

Source: https://manual.calibre-ebook.com/creating_plugins.html/tr/server

This command starts the Calibre Content server, configuring it to serve all URLs under the `/calibre` prefix on port 8080. This is essential when running the server behind a reverse proxy that maps a sub-path.

```Bash
calibre-server --url-prefix /calibre --port 8080
```

--------------------------------

### ebook-convert Command-Line Interface Options

Source: https://manual.calibre-ebook.com/creating_plugins.html/generated/en/ebook-convert

Detailed documentation for key command-line options available with the `ebook-convert` utility, including their purpose, accepted values, and usage examples where applicable. This section covers options like `--help`, `--input-profile`, `--list-recipes`, and `--output-profile`.

```APIDOC
ebook-convert Command-Line Options:
  --help, -h:
    Description: Show this help message and exit.
  --input-profile:
    Description: Specify the input profile. The input profile gives the conversion system information on how to interpret various information in the input document. For example resolution dependent lengths (i.e. lengths in pixels).
    Choices: cybookg3, cybook_opus, default, hanlinv3, hanlinv5, illiad, irexdr1000, irexdr800, kindle, msreader, mobipocket, nook, sony, sony300, sony900
  --list-recipes:
    Description: List builtin recipe names. You can create an e-book from a builtin recipe like this: ebook-convert "Recipe Name.recipe" output.epub
  --output-profile:
    Description: (Description truncated in source)
```

--------------------------------

### Call GUI Configuration Widget (for_output=False)

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt_BR/_modules/calibre/customize/conversion

An example of calling the `gui_configuration_widget` function, likely for initial setup or a specific context where `for_output` is explicitly set to False, indicating it's not for output-specific configuration.

```Python
return gui_configuration_widget(name, parent, get_option_by_name,
                get_option_help, db, book_id, for_output=False)
```

--------------------------------

### Example: Load Image Resource with load_resources

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt_BR/_modules/calibre/gui2/actions

Demonstrates how to use the `load_resources` method to load an image file (e.g., 'images/icon.png') from the plugin's ZIP file, convert its binary data into a `QPixmap`, and then create a `QIcon` from it for use in the GUI.

```Python
pixmap = QPixmap()
pixmap.loadFromData(tuple(self.load_resources(['images/icon.png']).values())[0])
icon = QIcon(pixmap)
```

--------------------------------

### Start Calibre Content Server with URL Prefix

Source: https://manual.calibre-ebook.com/creating_plugins.html/de/server

Demonstrates how to start the Calibre content server using a specific URL prefix and port, allowing it to run under a sub-path on a web server.

```Shell
calibre-server --url-prefix /calibre --port 8080
```

--------------------------------

### start_plugin method

Source: https://manual.calibre-ebook.com/creating_plugins.html/es/_modules/calibre/devices/interface

This method is called to initiate the plugin, allowing it to begin accepting device connections. If the plugin is already active, no action is taken. It can be invoked on the GUI thread and requires thread safety.

```Python
def start_plugin(self):
    '''
    This method is called to start the plugin. The plugin should begin
    to accept device connections however it does that. If the plugin is
    already accepting connections, then do nothing.

    This method can be called on the GUI thread. A driver that implements
    this method must be thread safe.
    '''
    pass
```

```APIDOC
Method: start_plugin
Parameters:
  self: (implicit)
Returns:
  None
Description: Starts the plugin, enabling device connections. Does nothing if already running. Must be thread safe.
```

--------------------------------

### Calibre PDF Footer Template with JavaScript for Page Number Offset

Source: https://manual.calibre-ebook.com/creating_plugins.html/zh_CN/conversion

Demonstrates using JavaScript within a footer template to modify the displayed page number. This example causes page numbers to start at 4 instead of 1 by adding 3 to `_PAGENUM_`.

```HTML
<footer>
    <div></div>
    <script>document.currentScript.parentNode.querySelector("div").innerHTML = "" + (_PAGENUM_ + 3)</script>
</footer>
```

--------------------------------

### API Method: startup

Source: https://manual.calibre-ebook.com/creating_plugins.html/es/_modules/calibre/devices/interface

Called when Calibre starts the device. This method should perform any necessary initialization. Note that `__init__` can be called multiple times, but `startup` is called only once per device instance and runs on the device thread, not the GUI thread.

```APIDOC
startup()
  Returns: (Not specified)
```

--------------------------------

### Get Guide Type to Canonical Name Mapping

Source: https://manual.calibre-ebook.com/creating_plugins.html/pl/_modules/calibre/ebooks/oeb/polish/container

A property that provides a mapping of guide types to their canonical names, extracted from the OPF guide section. This allows easy lookup of guide references.

```Python
@property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### Example Backend Format Addition

Source: https://manual.calibre-ebook.com/creating_plugins.html/cs/_modules/calibre/db/cache

A brief example demonstrating the return values of the `add_format` method when called on a backend object, showing how size and filename are captured.

```Python
size, fname = self.backend.add_format(book_id, fmt, stream, title, author, path, name, mtime=mtime)
return size, fname
```

--------------------------------

### Calibre Server: Run for Reverse Proxy Setup

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt/server

This command starts the Calibre content server in its default mode, typically listening on port 8080. It is intended to be run as a backend service when integrating with a front-end web server via a reverse proxy.

```bash
calibre-server
```

--------------------------------

### Get Guide Type Mapping (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/_modules/calibre/ebooks/oeb/polish/container

A property that returns a mapping of guide types to their canonical names, based on the 'href' and 'type' attributes in the OPF guide references.

```Python
@property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

```APIDOC
guide_type_map: dict[str, str]
  Mapping of guide type to canonical name.
  Returns:
    dict: A dictionary where keys are guide types and values are canonical names.
```

--------------------------------

### Run Calibre Content Server on Linux

Source: https://manual.calibre-ebook.com/creating_plugins.html/pl/faq

This command starts the Calibre content server, making your specified library accessible over the network. Replace `/path/to/the/library/you/want/to/share` with the actual path to your Calibre library.

```Shell
/opt/calibre/calibre-server /path/to/the/library/you/want/to/share

```

--------------------------------

### Get or Create EPUB Guide Element (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/sv/_modules/calibre/ebooks/oeb/polish/cover

Retrieves the `<guide>` element from the OPF file. If no guide element exists, it creates and inserts one into the OPF XML structure, ensuring the guide element is present for further operations.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Launch Normal Calibre Installation (Windows Batch)

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt/develop

This batch command launches the standard, released version of Calibre, specifying the path to the user's everyday library. This is useful for maintaining separate development and production environments.

```Batch
calibre.exe "--with-library=C:\path\to\everyday\library folder"
```

--------------------------------

### Initial Module Setup and Imports for calibre.gui2.preferences

Source: https://manual.calibre-ebook.com/creating_plugins.html/pl/_modules/calibre/gui2/preferences

This snippet shows the initial setup for the `calibre.gui2.preferences` module, including license information, copyright, and essential imports from PyQt and Calibre's internal libraries. It also defines custom exception classes `AbortCommit` and `AbortInitialize` used for flow control during configuration saving.

```Python
#!/usr/bin/env python

__license__   = 'GPL v3'
__copyright__ = '2010, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'

import textwrap

from qt.core import (
    QAbstractSpinBox,
    QApplication,
    QCheckBox,
    QComboBox,
    QDialog,
    QDialogButtonBox,
    QEvent,
    QIcon,
    QLineEdit,
    QListView,
    QListWidget,
    Qt,
    QTableWidget,
    QVBoxLayout,
    QWidget,
    pyqtSignal,
)

from calibre.customize.ui import preferences_plugins
from calibre.gui2.complete2 import EditWithComplete
from calibre.gui2.widgets import HistoryLineEdit
from calibre.utils.config import ConfigProxy
from polyglot.builtins import string_or_bytes

class AbortCommit(Exception):
    pass

class AbortInitialize(Exception):
    pass
```

--------------------------------

### Python: Get or Create EPUB Guide Section

Source: https://manual.calibre-ebook.com/creating_plugins.html/uk/_modules/calibre/ebooks/oeb/polish/cover

Retrieves the `<guide>` section from the OPF file. If this section does not exist in the OPF XML, it creates an empty `<guide>` element and inserts it, ensuring that a guide section is always available for adding references.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Calibre Recipe: __init__ Method Initialization and Configuration

Source: https://manual.calibre-ebook.com/creating_plugins.html/it/_modules/calibre/web/feeds/news

This method initializes a Calibre news recipe instance, configuring logging, handling command-line options, setting up output directories, and preparing `web2disk` options for content downloading. It manages various recipe-specific settings, including subscription requirements, browser setup, and image scaling.

```APIDOC
__init__(self, options, log, progress_reporter)
  description: Initialize the recipe.
  parameters:
    options: Parsed commandline options.
    log: Logging object.
    progress_reporter: A Callable that takes two arguments: progress (a number between 0 and 1) and a string message. The message should be optional.
```

```Python
self.log = ThreadSafeWrapper(log)
if not isinstance(self.title, str):
    self.title = str(self.title, 'utf-8', 'replace')

self.debug = options.verbose > 1
self.output_dir = os.path.abspath(os.getcwd())
self.verbose = options.verbose
self.test = options.test
if self.test and not isinstance(self.test, tuple):
    self.test = (2, 2)
self.username = options.username
self.password = options.password
self.lrf = options.lrf
self.output_profile = options.output_profile
self.touchscreen = getattr(self.output_profile, 'touchscreen', False)
if self.touchscreen:
    self.template_css += self.output_profile.touchscreen_news_css

if self.test:
    self.max_articles_per_feed = self.test[1]
    self.simultaneous_downloads = min(4, self.simultaneous_downloads)

if self.debug:
    self.verbose = True
self.report_progress = progress_reporter

if self.needs_subscription and (
        self.username is None or self.password is None or (
            not self.username and not self.password)):
    if self.needs_subscription != 'optional':
        raise ValueError(_('The "%s" recipe needs a username and password.')%self.title)

self.browser = self.get_browser()
self.image_map, self.image_counter = {}, 1
self.css_map = {}

web2disk_cmdline = ['web2disk',
    '--timeout', str(self.timeout),
    '--max-recursions', str(self.recursions),
    '--delay', str(self.delay),
    ]

if self.verbose:
    web2disk_cmdline.append('--verbose')

if self.no_stylesheets:
    web2disk_cmdline.append('--dont-download-stylesheets')

for reg in self.match_regexps:
    web2disk_cmdline.extend(['--match-regexp', reg])

for reg in self.filter_regexps:
    web2disk_cmdline.extend(['--filter-regexp', reg])

if options.output_profile.short_name in ('default', 'tablet'):
    self.scale_news_images_to_device = False
elif self.scale_news_images_to_device:
    self.scale_news_images = options.output_profile.screen_size

self.web2disk_options = web2disk_option_parser().parse_args(web2disk_cmdline)[0]
for extra in ('keep_only_tags', 'remove_tags', 'preprocess_regexps',
              'skip_ad_pages', 'preprocess_html', 'remove_tags_after',
              'remove_tags_before', 'is_link_wanted',
              'compress_news_images', 'compress_news_images_max_size',
              'compress_news_images_auto_size', 'scale_news_images'):
    setattr(self.web2disk_options, extra, getattr(self, extra))

self.web2disk_options.postprocess_html = self._postprocess_html
self.web2disk_options.preprocess_image = self.preprocess_image
self.web2disk_options.encoding = self.encoding
self.web2disk_options.preprocess_raw_html = self.preprocess_raw_html_
self.web2disk_options.get_delay = self.get_url_specific_delay

if self.delay > 0:
    self.simultaneous_downloads = 1

self.navbar = templates.TouchscreenNavBarTemplate() if self.touchscreen else \
              templates.NavBarTemplate()
self.failed_downloads = []
self.partial_failures = []
self.aborted_articles = []
self.recipe_specific_options_metadata = rso = self.recipe_specific_options or {}
self.recipe_specific_options = {k: rso[k]['default'] for k in rso if 'default' in rso[k]}
```

--------------------------------

### Get Guide Type to Canonical Name Mapping

Source: https://manual.calibre-ebook.com/creating_plugins.html/uk/_modules/calibre/ebooks/oeb/polish/container

A read-only property that provides a dictionary mapping guide types to their canonical names, extracted from the OPF guide references. Useful for quickly looking up items by their guide type.

```Python
@property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### Get or Create EPUB Guide Element (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt_BR/_modules/calibre/ebooks/oeb/polish/cover

Retrieves the `<guide>` element from the OPF file. If no guide element is found, it creates a new one and inserts it into the OPF XML, then returns the newly created or existing guide element.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Initialize and Configure Browser Instance

Source: https://manual.calibre-ebook.com/creating_plugins.html/es/_modules/calibre/web/feeds/news

This code snippet demonstrates how to initialize a browser instance based on a specified type ('qt' or 'webengine') and configure it with a user agent, SSL verification, and additional headers. It also shows how to enable gzip handling for the browser.

```Python
return {'qt': Browser, 'webengine': WebEngineBrowser}[self.browser_type](
                user_agent=kwargs['user_agent'], verify_ssl_certificates=kwargs.get('verify_ssl_certificates', False))
        br = browser(*args, **kwargs)
        br.addheaders += [('Accept', '*/*')]
        if self.handle_gzip:
            br.set_handle_gzip(True)
        return br
```

--------------------------------

### Launch Normal Calibre Release Version (Windows)

Source: https://manual.calibre-ebook.com/creating_plugins.html/et/develop

This command, typically used in a `.bat` file on Windows, launches the standard Calibre release version. It specifies the path to the everyday library folder, allowing users to maintain a separate library for their production Calibre instance.

```batch
calibre.exe "--with-library=C:\path\to\everyday\library folder"
```

--------------------------------

### Get Guide Type to Canonical Name Mapping (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/zh_CN/_modules/calibre/ebooks/oeb/polish/container

A property that returns a dictionary mapping guide types to their canonical names, extracted from the OPF guide section.

```Python
@property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### Calibre InputFormatPlugin __call__ Method Example

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt/_modules/calibre/customize/conversion

Provides an example implementation of the `__call__` method for Calibre input plugins, demonstrating how it handles logging, cleans the output directory, and invokes the `convert` method.

```Python
def __call__(self, stream, options, file_ext, log,
                 accelerators, output_dir):
        try:
            log(f'InputFormatPlugin: {self.name} running')
            if hasattr(stream, 'name'):
                log('on', stream.name)
        except:
            # In case stdout is broken
            pass

        with CurrentDir(output_dir):
            for x in os.listdir('.'):
                shutil.rmtree(x) if os.path.isdir(x) else os.remove(x)

            ret = self.convert(stream, options, file_ext,
                               log, accelerators)

        return ret
```

--------------------------------

### Python: Get Guide Type to Canonical Name Mapping

Source: https://manual.calibre-ebook.com/creating_plugins.html/nl/_modules/calibre/ebooks/oeb/polish/container

A read-only property that returns a dictionary mapping guide types to their canonical names, extracted from the OPF guide references.

```Python
    @property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### Get Guide Type to Canonical Name Mapping (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/de/_modules/calibre/ebooks/oeb/polish/container

A property that provides a mapping from guide types to their canonical names. It iterates through guide references in the OPF to build this dictionary.

```Python
@property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### Calibre Plugin API: Start Plugin

Source: https://manual.calibre-ebook.com/creating_plugins.html/pl/_modules/calibre/devices/interface

Initiates the plugin, allowing it to begin accepting device connections. If the plugin is already running, no action is taken. This method requires thread safety.

```Python
def start_plugin(self):
        '''
        This method is called to start the plugin. The plugin should begin
        to accept device connections however it does that. If the plugin is
        already accepting connections, then do nothing.

        This method can be called on the GUI thread. A driver that implements
        this method must be thread safe.
        '''
        pass
```

```APIDOC
Method: start_plugin(self)
  Description: Starts the plugin, enabling it to accept device connections.
  Parameters:
    self: The instance of the plugin driver.
  Returns: None
  Notes:
    - If the plugin is already accepting connections, do nothing.
    - Can be called on the GUI thread.
    - Must be thread safe.
```

--------------------------------

### Get Guide Type to Canonical Name Mapping

Source: https://manual.calibre-ebook.com/creating_plugins.html/cs/_modules/calibre/ebooks/oeb/polish/container

A property that provides a dictionary mapping guide types to their canonical names, extracted from the OPF guide references within the ebook.

```Python
@property
def guide_type_map(self):
    ' Mapping of guide type to canonical name '
    return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
        for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### Browser Instantiation and Configuration

Source: https://manual.calibre-ebook.com/creating_plugins.html/it/_modules/calibre/web/feeds/news

Demonstrates how a browser instance is created based on `browser_type` (qt or webengine) and then configured with user agent, SSL verification, additional headers, and gzip handling. This code is likely part of a `get_browser` method.

```Python
            return {'qt': Browser, 'webengine': WebEngineBrowser}[self.browser_type](
                user_agent=kwargs['user_agent'], verify_ssl_certificates=kwargs.get('verify_ssl_certificates', False))
        br = browser(*args, **kwargs)
        br.addheaders += [('Accept', '*/*')]
        if self.handle_gzip:
            br.set_handle_gzip(True)
        return br
```

--------------------------------

### APIDOC: Calibre Device Plugin startup Method

Source: https://manual.calibre-ebook.com/creating_plugins.html/fr/_modules/calibre/devices/interface

Called when Calibre initializes the device. This method should perform any necessary setup or initialization for the device driver. It is called on the device thread, not the GUI thread, and only once per device instance.

```APIDOC
def startup(self)
  Description: Performs any required initialization when Calibre starts the device. Called on the device thread.
```

--------------------------------

### Python: Get or Create EPUB Guide Element

Source: https://manual.calibre-ebook.com/creating_plugins.html/zh_CN/_modules/calibre/ebooks/oeb/polish/cover

Retrieves the `<guide>` element from the EPUB's OPF file. If the `<guide>` element does not exist, it creates and inserts one into the OPF before returning it. This ensures the guide element is always available for modifications.

```python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Get EPUB2 Guide Landmarks

Source: https://manual.calibre-ebook.com/creating_plugins.html/ru/_modules/calibre/ebooks/oeb/polish/toc

Extracts guide landmarks from the OPF guide section for EPUB2 files. It yields dictionaries containing destination, fragment, title, and type for each reference.

```Python
def get_guide_landmarks(container):
    for ref in container.opf_xpath('./opf:guide/opf:reference'):
        href, title, rtype = ref.get('href'), ref.get('title'), ref.get('type')
        href, frag = href.partition('#')[::2]
        name = container.href_to_name(href, container.opf_name)
        if container.has_name(name):
            yield {'dest':name, 'frag':frag, 'title':title or '', 'type':rtype or ''}
```

--------------------------------

### Python: Get or Create EPUB OPF Guide Section

Source: https://manual.calibre-ebook.com/creating_plugins.html/it/_modules/calibre/ebooks/oeb/polish/cover

This function retrieves the `<guide>` section from the EPUB's OPF XML. If the `<guide>` section does not exist, it creates and inserts an empty one into the OPF before returning it. This ensures the guide section is available for modifications.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Python: Calibre Recipe Initialization (__init__)

Source: https://manual.calibre-ebook.com/creating_plugins.html/tr/_modules/calibre/web/feeds/news

This constructor initializes a Calibre recipe instance, configuring various attributes based on provided options, logging, and progress reporting. It handles command-line arguments, output directory setup, debugging flags, and subscription requirements, also preparing `web2disk` command-line options for content downloading.

```python
def __init__(self, options, log, progress_reporter):
        '''
        Initialize the recipe.
        :param options: Parsed commandline options
        :param log:  Logging object
        :param progress_reporter: A Callable that takes two arguments: progress (a number between 0 and 1) and a string message. The message should be optional.
        '''
        self.log = ThreadSafeWrapper(log)
        if not isinstance(self.title, str):
            self.title = str(self.title, 'utf-8', 'replace')

        self.debug = options.verbose > 1
        self.output_dir = os.path.abspath(os.getcwd())
        self.verbose = options.verbose
        self.test = options.test
        if self.test and not isinstance(self.test, tuple):
            self.test = (2, 2)
        self.username = options.username
        self.password = options.password
        self.lrf = options.lrf
        self.output_profile = options.output_profile
        self.touchscreen = getattr(self.output_profile, 'touchscreen', False)
        if self.touchscreen:
            self.template_css += self.output_profile.touchscreen_news_css

        if self.test:
            self.max_articles_per_feed = self.test[1]
            self.simultaneous_downloads = min(4, self.simultaneous_downloads)

        if self.debug:
            self.verbose = True
        self.report_progress = progress_reporter

        if self.needs_subscription and (
                self.username is None or self.password is None or (
                    not self.username and not self.password)):
            if self.needs_subscription != 'optional':
                raise ValueError(_('The "%s" recipe needs a username and password.')%self.title)

        self.browser = self.get_browser()
        self.image_map, self.image_counter = {}, 1
        self.css_map = {}

        web2disk_cmdline = ['web2disk',
            '--timeout', str(self.timeout),
            '--max-recursions', str(self.recursions),
            '--delay', str(self.delay),
            ]

        if self.verbose:
            web2disk_cmdline.append('--verbose')

        if self.no_stylesheets:
            web2disk_cmdline.append('--dont-download-stylesheets')

        for reg in self.match_regexps:
            web2disk_cmdline.extend(['--match-regexp', reg])

        for reg in self.filter_regexps:
            web2disk_cmdline.extend(['--filter-regexp', reg])

        if options.output_profile.short_name in ('default', 'tablet'):
            self.scale_news_images_to_device = False
        elif self.scale_news_images_to_device:
            self.scale_news_images = options.output_profile.screen_size

        self.web2disk_options = web2disk_option_parser().parse_args(web2disk_cmdline)[0]
        for extra in ('keep_only_tags', 'remove_tags', 'preprocess_regexps',
                      'skip_ad_pages', 'preprocess_html', 'remove_tags_after',
                      'remove_tags_before', 'is_link_wanted',
                      'compress_news_images', 'compress_news_images_max_size',
                      'compress_news_images_auto_size', 'scale_news_images'):
            setattr(self.web2disk_options, extra, getattr(self, extra))

        self.web2disk_options.postprocess_html = self._postprocess_html
        self.web2disk_options.preprocess_image = self.preprocess_image
        self.web2disk_options.encoding = self.encoding
        self.web2disk_options.preprocess_raw_html = self.preprocess_raw_html_
        self.web2disk_options.get_delay = self.get_url_specific_delay

        if self.delay > 0:
            self.simultaneous_downloads = 1

        self.navbar = templates.TouchscreenNavBarTemplate() if self.touchscreen else \
                      templates.NavBarTemplate()
        self.failed_downloads = []
        self.partial_failures = []
        self.aborted_articles = []
        self.recipe_specific_options_metadata = rso = self.recipe_specific_options or {}
        self.recipe_specific_options = {k: rso[k]['default'] for k in rso if 'default' in rso[k]}
```

--------------------------------

### Run Calibre Content Server on Linux

Source: https://manual.calibre-ebook.com/creating_plugins.html/tr/faq

This command starts the Calibre content server, allowing you to share your ebook library. Ensure your Linux server meets the GLIBC and libstdc++ requirements. Replace '/path/to/the/library/you/want/to/share' with the actual path to your Calibre library.

```bash
/opt/calibre/calibre-server /path/to/the/library/you/want/to/share
```

--------------------------------

### Get or Create EPUB Guide Element (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt/_modules/calibre/ebooks/oeb/polish/cover

This function retrieves the '<opf:guide>' element from the EPUB's OPF file. If the guide element does not exist, it creates and inserts a new one into the OPF XML, ensuring that subsequent operations can add guide references.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Start Calibre E-book Viewer in Debug Mode

Source: https://manual.calibre-ebook.com/creating_plugins.html/et/develop

This command launches the Calibre E-book viewer from the terminal, opening a specified file. It is used for debugging issues related to the viewer or the rendering of specific e-book files.

```bash
calibre-debug -w /path/to/file/to/be/viewed
```

--------------------------------

### Python: Get or Create EPUB OPF Guide Element

Source: https://manual.calibre-ebook.com/creating_plugins.html/tr/_modules/calibre/ebooks/oeb/polish/cover

This function retrieves the `<guide>` element from an EPUB's OPF file. If the `<guide>` element does not exist, it creates and inserts a new one into the OPF XML structure before returning it. This ensures that subsequent operations can safely add guide references.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Get or Create EPUB Guide Element (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/pl/_modules/calibre/ebooks/oeb/polish/cover

Retrieves the `<guide>` element from the EPUB OPF file. If the element does not exist, it creates and inserts a new one into the OPF XML, ensuring it's available for adding guide references.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Systemd Service Unit for Calibre Server

Source: https://manual.calibre-ebook.com/creating_plugins.html/et/server

This systemd unit file (`/etc/systemd/system/calibre-server.service`) defines how to run the Calibre Content server as a service. It specifies the description, dependencies, service type, user/group, and the `ExecStart` command, allowing the server to start automatically at boot.

```Systemd
[Unit]
Description=calibre Content server
After=network.target

[Service]
Type=simple
User=mylinuxuser
Group=mylinuxgroup
ExecStart=/opt/calibre/calibre-server "/path/to/calibre library folder"

[Install]
WantedBy=multi-user.target
```

--------------------------------

### Get or Create EPUB Guide Section (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/ru/_modules/calibre/ebooks/oeb/polish/cover

This function retrieves the `<guide>` section from the EPUB's OPF file. If the section does not exist, it creates and inserts an empty one to ensure its presence for further operations. It returns the guide XML element.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Get or Create EPUB Guide Section (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/es/_modules/calibre/ebooks/oeb/polish/cover

Retrieves the `<guide>` section from the EPUB's OPF file. If the guide section does not exist, this function creates and inserts an empty one into the OPF XML, ensuring its presence for subsequent operations.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Basic calibre Command-Line Usage

Source: https://manual.calibre-ebook.com/creating_plugins.html/generated/en/calibre

Shows the general syntax for launching the `calibre` GUI, optionally adding an e-book, or performing actions via `calibre` URLs. Arguments with spaces must be enclosed in quotation marks.

```Shell
calibre [options] [path_to_ebook or calibre url ...]
```

--------------------------------

### Get EPUB2 Guide Landmarks

Source: https://manual.calibre-ebook.com/creating_plugins.html/fr/_modules/calibre/ebooks/oeb/polish/toc

This function extracts guide landmarks from the EPUB2 OPF guide section. It parses `opf:reference` elements, resolves their hrefs to names, and yields dictionaries containing destination, fragment, title, and type information for valid landmarks.

```python
def get_guide_landmarks(container):
    for ref in container.opf_xpath('./opf:guide/opf:reference'):
        href, title, rtype = ref.get('href'), ref.get('title'), ref.get('type')
        href, frag = href.partition('#')[::2]
        name = container.href_to_name(href, container.opf_name)
        if container.has_name(name):
            yield {'dest':name, 'frag':frag, 'title':title or '', 'type':rtype or ''}
```

--------------------------------

### Calibre Plugin: Recipe Initialization Method

Source: https://manual.calibre-ebook.com/creating_plugins.html/sv/_modules/calibre/web/feeds/news

Initializes a Calibre recipe, handling command-line options, logging, progress reporting, and setting up various recipe properties. This includes managing subscription requirements, browser setup, image/CSS mapping, and constructing `web2disk` command-line options based on recipe and output profile settings.

```Python
def __init__(self, options, log, progress_reporter):
        '''
        Initialize the recipe.
        :param options: Parsed commandline options
        :param log:  Logging object
        :param progress_reporter: A Callable that takes two arguments: progress (a number between 0 and 1) and a string message. The message should be optional.
        '''
        self.log = ThreadSafeWrapper(log)
        if not isinstance(self.title, str):
            self.title = str(self.title, 'utf-8', 'replace')

        self.debug = options.verbose > 1
        self.output_dir = os.path.abspath(os.getcwd())
        self.verbose = options.verbose
        self.test = options.test
        if self.test and not isinstance(self.test, tuple):
            self.test = (2, 2)
        self.username = options.username
        self.password = options.password
        self.lrf = options.lrf
        self.output_profile = options.output_profile
        self.touchscreen = getattr(self.output_profile, 'touchscreen', False)
        if self.touchscreen:
            self.template_css += self.output_profile.touchscreen_news_css

        if self.test:
            self.max_articles_per_feed = self.test[1]
            self.simultaneous_downloads = min(4, self.simultaneous_downloads)

        if self.debug:
            self.verbose = True
        self.report_progress = progress_reporter

        if self.needs_subscription and (
                self.username is None or self.password is None or (
                    not self.username and not self.password)):
            if self.needs_subscription != 'optional':
                raise ValueError(_('The \"%s\" recipe needs a username and password.')%self.title)

        self.browser = self.get_browser()
        self.image_map, self.image_counter = {}, 1
        self.css_map = {}

        web2disk_cmdline = ['web2disk',
            '--timeout', str(self.timeout),
            '--max-recursions', str(self.recursions),
            '--delay', str(self.delay),
            ]

        if self.verbose:
            web2disk_cmdline.append('--verbose')

        if self.no_stylesheets:
            web2disk_cmdline.append('--dont-download-stylesheets')

        for reg in self.match_regexps:
            web2disk_cmdline.extend(['--match-regexp', reg])

        for reg in self.filter_regexps:
            web2disk_cmdline.extend(['--filter-regexp', reg])

        if options.output_profile.short_name in ('default', 'tablet'):
            self.scale_news_images_to_device = False
        elif self.scale_news_images_to_device:
            self.scale_news_images = options.output_profile.screen_size

        self.web2disk_options = web2disk_option_parser().parse_args(web2disk_cmdline)[0]
        for extra in ('keep_only_tags', 'remove_tags', 'preprocess_regexps',
                      'skip_ad_pages', 'preprocess_html', 'remove_tags_after',
                      'remove_tags_before', 'is_link_wanted',
                      'compress_news_images', 'compress_news_images_max_size',
                      'compress_news_images_auto_size', 'scale_news_images'):
            setattr(self.web2disk_options, extra, getattr(self, extra))

        self.web2disk_options.postprocess_html = self._postprocess_html
        self.web2disk_options.preprocess_image = self.preprocess_image
        self.web2disk_options.encoding = self.encoding
        self.web2disk_options.preprocess_raw_html = self.preprocess_raw_html_
        self.web2disk_options.get_delay = self.get_url_specific_delay

        if self.delay > 0:
            self.simultaneous_downloads = 1

        self.navbar = templates.TouchscreenNavBarTemplate() if self.touchscreen else \
                      templates.NavBarTemplate()
        self.failed_downloads = []
        self.partial_failures = []
        self.aborted_articles = []
        self.recipe_specific_options_metadata = rso = self.recipe_specific_options or {}
        self.recipe_specific_options = {k: rso[k]['default'] for k in rso if 'default' in rso[k]}
        for x in (options.recipe_specific_option or ()): 
            k, sep, v = x.partition(':')
            if not sep:
```

--------------------------------

### Get or Create EPUB OPF Guide Section (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/cs/_modules/calibre/ebooks/oeb/polish/cover

This function, `get_guides`, retrieves the `<guide>` element from the EPUB's OPF file. If the `<guide>` element does not exist, it is created and inserted into the OPF XML structure, ensuring that subsequent operations can add references to it.

```Python
def get_guides(container):
    guides = container.opf_xpath('//opf:guide')
    if not guides:
        container.insert_into_xml(container.opf, container.opf.makeelement(
            OPF('guide')))
        guides = container.opf_xpath('//opf:guide')
    return guides
```

--------------------------------

### Launch Release Calibre with Specific Library

Source: https://manual.calibre-ebook.com/creating_plugins.html/develop

Examples of scripts to launch the release version of Calibre, specifying a particular library folder for everyday use, applicable to both Windows batch files and Linux shell scripts.

```Batch
calibre.exe "--with-library=C:\path\to\everyday\library folder"
```

```Shell
calibre "--with-library=/path/to/everyday/library folder"
```

--------------------------------

### Python: Get Guide Type Mapping

Source: https://manual.calibre-ebook.com/creating_plugins.html/es/_modules/calibre/ebooks/oeb/polish/container

A property that returns a dictionary mapping guide types to their canonical names. It iterates through the 'opf:guide/opf:reference' elements to build this mapping.

```Python
    @property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### web2disk Command-Line Options Reference

Source: https://manual.calibre-ebook.com/creating_plugins.html/generated/en/web2disk

Comprehensive list of available command-line options for the `web2disk` utility, detailing their purpose, default values, and usage constraints.

```APIDOC
--base-dir, -d:
  Base folder into which URL is saved. Default is .
--delay:
  Minimum interval in seconds between consecutive fetches. Default is 0 s
--dont-download-stylesheets:
  Do not download CSS stylesheets.
--encoding:
  The character encoding for the websites you are trying to download. The default is to try and guess the encoding.
--filter-regexp:
  Any link that matches this regular expression will be ignored. This option can be specified multiple times, in which case as long as any regexp matches a link, it will be ignored. By default, no links are ignored. If both filter regexp and match regexp are specified, then filter regexp is applied first.
--help, -h:
  show this help message and exit
--match-regexp:
  Only links that match this regular expression will be followed. This option can be specified multiple times, in which case as long as a link matches any one regexp, it will be followed. By default all links are followed.
--max-files, -n:
  The maximum number of files to download. This only applies to files from <a> tags. Default is 9223372036854775807
--max-recursions, -r:
  Maximum number of levels to recurse i.e. depth of links to follow. Default 1
--timeout, -t:
  Timeout in seconds to wait for a response from the server. Default: 10.0 s
--verbose:
  Show detailed output information. Useful for debugging
--version:
  show program's version number and exit
```

--------------------------------

### Get OPF Guide Type to Canonical Name Mapping

Source: https://manual.calibre-ebook.com/creating_plugins.html/sv/_modules/calibre/ebooks/oeb/polish/container

This property provides a dictionary mapping guide types (e.g., 'cover', 'toc') to their corresponding canonical file names as defined in the OPF guide section. It iterates through opf:guide/opf:reference elements with both href and type attributes.

```Python
    @property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### APIDOC: DeviceInterface.startup Method

Source: https://manual.calibre-ebook.com/creating_plugins.html/pl/_modules/calibre/devices/interface

This method is called when Calibre is initiating the device. It should perform any necessary initialization. Note that while `__init__` might be called multiple times for different instances, only one instance will have this `startup` method invoked. This method executes on the device thread, not the GUI thread.

```APIDOC
def startup(self)
  Returns: None
```

--------------------------------

### Get Guide Landmarks from Calibre Container (EPUB2)

Source: https://manual.calibre-ebook.com/creating_plugins.html/_modules/calibre/ebooks/oeb/polish/toc

This function extracts landmark information from the EPUB2 'guide' section of the OPF file. It yields dictionaries containing destination, fragment, title, and type for each reference found.

```Python
def get_guide_landmarks(container):
    for ref in container.opf_xpath('./opf:guide/opf:reference'):
        href, title, rtype = ref.get('href'), ref.get('title'), ref.get('type')
        href, frag = href.partition('#')[::2]
        name = container.href_to_name(href, container.opf_name)
        if container.has_name(name):
            yield {'dest':name, 'frag':frag, 'title':title or '', 'type':rtype or ''}
```

--------------------------------

### Browser Initialization and Configuration

Source: https://manual.calibre-ebook.com/creating_plugins.html/ru/_modules/calibre/web/feeds/news

Initializes and configures a browser instance, dynamically selecting between Qt and WebEngine based on `browser_type`. It sets the user agent, handles SSL certificate verification, adds a generic 'Accept' header, and optionally enables gzip handling for responses.

```Python
return {'qt': Browser, 'webengine': WebEngineBrowser}[self.browser_type](
                user_agent=kwargs['user_agent'], verify_ssl_certificates=kwargs.get('verify_ssl_certificates', False))
        br = browser(*args, **kwargs)
        br.addheaders += [('Accept', '*/*')]
        if self.handle_gzip:
            br.set_handle_gzip(True)
        return br
```

--------------------------------

### Get EPUB2 Guide Landmarks

Source: https://manual.calibre-ebook.com/creating_plugins.html/cs/_modules/calibre/ebooks/oeb/polish/toc

This generator function extracts guide landmarks from an EPUB2 `container`'s OPF guide section. It parses `opf:reference` elements, resolves hrefs to names, and yields dictionaries containing destination, fragment, title, and type for each valid landmark.

```Python
def get_guide_landmarks(container):
    for ref in container.opf_xpath('./opf:guide/opf:reference'):
        href, title, rtype = ref.get('href'), ref.get('title'), ref.get('type')
        href, frag = href.partition('#')[::2]
        name = container.href_to_name(href, container.opf_name)
        if container.has_name(name):
            yield {'dest':name, 'frag':frag, 'title':title or '', 'type':rtype or ''}
```

--------------------------------

### Initialize and Configure Web Browser Instance (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/ru/_modules/calibre/ebooks/metadata/sources/base

This property initializes and returns a configured browser instance. It sets the user agent, handles SSL certificate verification based on `ignore_ssl_errors`, and enables GZIP transfer encoding if supported, returning a clone of the browser object.

```Python
@property
    def browser(self):
        if self._browser is None:
            self._browser = browser(user_agent=self.user_agent, verify_ssl_certificates=not self.ignore_ssl_errors)
            if self.supports_gzip_transfer_encoding:
                self._browser.set_handle_gzip(True)
        return self._browser.clone_browser()
```

--------------------------------

### Get Guide Type to Canonical Name Mapping in Calibre OPF

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt_BR/_modules/calibre/ebooks/oeb/polish/container

A property that returns a dictionary mapping guide types to their canonical names, extracted from the 'opf:guide/opf:reference' elements in the OPF document.

```Python
    @property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### Running Python Script with Calibre's Bundled Interpreter (Binary Install)

Source: https://manual.calibre-ebook.com/creating_plugins.html/it/develop

Execute a Python script using the Python interpreter that comes bundled with a binary installation of Calibre. This method allows your script to leverage Calibre's environment and libraries without a separate source installation.

```Shell
calibre-debug /path/to/your/python/script.py -- arguments to your script
```

--------------------------------

### Launch Development Calibre Installation (Windows Batch)

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt/develop

This batch command sets the `CALIBRE_DEVELOP_FROM` environment variable to point to the Calibre source directory and then launches Calibre, directing it to use a separate test library. This allows for isolated development.

```Batch
set CALIBRE_DEVELOP_FROM=C:\path\to\calibre\checkout\src
calibre.exe "--with-library=C:\path\to\test\library folder"
```

--------------------------------

### initialize Method for Plugin Resource Setup

Source: https://manual.calibre-ebook.com/creating_plugins.html/pt_BR/_modules/calibre/customize

Initializes the plugin by copying necessary `.ui` and `.py` files from the plugin's ZIP file to a temporary directory if the plugin is not built-in or disabled. This ensures resources are available for dynamic UI generation in the Calibre GUI.

```Python
def initialize(self):
    '''
    If plugin is not a built-in, copy the plugin's .ui and .py files from
    the ZIP file to $TMPDIR.
    Tab will be dynamically generated and added to the Catalog Options dialog in
    calibre.gui2.dialogs.catalog.py:Catalog
    '''
    from calibre.customize.builtins import plugins as builtin_plugins
    from calibre.customize.ui import config
    from calibre.ptempfile import PersistentTemporaryDirectory

    if type(self) not in builtin_plugins and self.name not in config['disabled_plugins']:
        files_to_copy = [f'{self.name.lower()}.{ext}' for ext in ['ui','py']]
        resources = zipfile.ZipFile(self.plugin_path,'r')

        if self.resources_path is None:
            self.resources_path = PersistentTemporaryDirectory('_plugin_resources', prefix='')

        for file in files_to_copy:
            try:
                resources.extract(file, self.resources_path)
            except:
                print(f' customize:__init__.initialize(): {file} not found in {os.path.basename(self.plugin_path)}')
                continue
        resources.close()
```

--------------------------------

### Get Guide Type to Canonical Name Map (Python)

Source: https://manual.calibre-ebook.com/creating_plugins.html/zh_TW/_modules/calibre/ebooks/oeb/polish/container

A property that returns a mapping of guide types to their canonical names. It iterates through 'opf:guide/opf:reference' elements to build this dictionary, using 'href' and 'type' attributes.

```Python
@property
    def guide_type_map(self):
        ' Mapping of guide type to canonical name '
        return {item.get('type', ''):self.href_to_name(item.get('href'), self.opf_name)
            for item in self.opf_xpath('//opf:guide/opf:reference[@href and @type]')}
```

--------------------------------

### API Method: start_plugin

Source: https://manual.calibre-ebook.com/creating_plugins.html/cs/_modules/calibre/devices/interface

Initiates the plugin, allowing it to accept device connections. If already running, it performs no action. This method must be thread-safe as it can be called on the GUI thread.

```APIDOC
def start_plugin(self):
    '''
    This method is called to start the plugin. The plugin should begin
    to accept device connections however it does that. If the plugin is
    already accepting connections, then do nothing.

    This method can be called on the GUI thread. A driver that implements
    this method must be thread safe.
    '''
    pass
```
Tokens:
Raw