Module Contents#



A base class for LCI backends.



class bw2data.backends.peewee.database.SQLiteBackend(*args, **kwargs)[source]#

Bases: bw2data.backends.base.LCIBackend

Inheritance diagram of bw2data.backends.peewee.database.SQLiteBackend

A base class for LCI backends.

Subclasses must support at least the following calls:

  • load()

  • write(data)

In addition, they should specify their backend with the backend attribute (a unicode string).

LCIBackend provides the following, which should not need to be modified:

  • rename

  • copy

  • find_dependents

  • random

  • process

For new classes to be recognized by the DatabaseChooser, they need to be registered with the config object, e.g.:

config.backends['backend type string'] = BackendClass

Instantiation does not load any data. If this database is not yet registered in the metadata store, a warning is written to stdout.

The data schema for databases in voluptuous is:

exchange = {
        Required("input"): valid_tuple,
        Required("type"): basestring,
lci_dataset = {
    Optional("categories"): Any(list, tuple),
    Optional("location"): object,
    Optional("unit"): basestring,
    Optional("name"): basestring,
    Optional("type"): basestring,
    Optional("exchanges"): [exchange]
db_validator = Schema({valid_tuple: lci_dataset}, extra=True)
  • valid_tuple is a dataset identifier, like ("ecoinvent", "super strong steel")

  • uncertainty_fields are fields from an uncertainty dictionary.

Processing a Database actually produces two parameter arrays: one for the exchanges, which make up the technosphere and biosphere matrices, and a geomapping array which links activities to locations.


*name* (unicode string) – Name of the database to manage.

property _searchable[source]#
backend = 'sqlite'[source]#
_efficient_write_dataset(index, key, ds, exchanges, activities)[source]#
_efficient_write_many_data(data, indices=True)[source]#
_get_queryset(random=False, filters=True)[source]#
delete(keep_params=False, warn=True)[source]#

Delete all data from SQLite database and Whoosh index

graph_technosphere(filename=None, **kwargs)[source]#
load(*args, **kwargs)[source]#

Load the intermediate data for this database.

If load() does not return a dictionary, then the returned object must have at least the following dictionary-like methods:

  • __iter__

  • __contains__

  • __getitem__

  • __setitem__

  • __delitem__

  • __len__

  • keys()

  • values()

  • items()

  • items()

However, this method must support the keyword argument as_dict, and .load(as_dict=True) must return a normal dictionary with all Database data. This is necessary for JSON serialization.

It is recommended to subclass collections.{abc.}MutableMapping (see SynchronousJSONDict for an example of data loaded on demand).

new_activity(code, **kwargs)[source]#

Process inventory documents to NumPy structured arrays.

Use a raw SQLite3 cursor instead of Peewee for a ~2 times speed advantage.

random(filters=True, true_random=False)[source]#

True random requires loading and sorting data in SQLite, and can be resource-intensive.

search(string, **kwargs)[source]#

Search this database for string.

The searcher include the following fields:

  • name

  • comment

  • categories

  • location

  • reference product

string can include wild cards, e.g. "trans*".

By default, the name field is given the most weight. The full weighting set is called the boost dictionary, and the default weights are:

    "name": 5,
    "comment": 1,
    "product": 3,
    "categories": 2,
    "location": 3

Optional keyword arguments:

  • limit: Number of results to return.

  • boosts: Dictionary of field names and numeric boosts - see default boost values above. New values must be in the same format, but with different weights.

  • filter: Dictionary of criteria that search results must meet, e.g. {'categories': 'air'}. Keys must be one of the above fields.

  • mask: Dictionary of criteria that exclude search results. Same format as filter.

  • facet: Field to facet results. Must be one of name, product, categories, location, or database.

  • proxy: Return Activity proxies instead of raw Whoosh documents. Default is True.

Returns a list of Activity datasets.

write(data, process=True)[source]#

Write data to database.

data must be a dictionary of the form:

    ('database name', 'dataset code'): {dataset}

Writing a database will first deletes all existing data.