bw2data.backends.peewee.database

Module Contents

Classes

SQLiteBackend

A base class for LCI backends.

Attributes

_VALID_KEYS

class bw2data.backends.peewee.database.SQLiteBackend(*args, **kwargs)

Bases: bw2data.backends.base.LCIBackend

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,
        }
exchange.update(uncertainty_dict)
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)

where:

• 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.

Parameters

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

property _searchable

backend = 'sqlite'

filters

order_by

_add_indices()

_drop_indices()

_efficient_write_dataset(index, key, ds, exchanges, activities)

_efficient_write_many_data(data, indices=True)

_get_filters()

_get_order_by()

_get_queryset(random=False, filters=True)

_set_filters(filters)

_set_order_by(field)

delete(keep_params=False, warn=True)

Delete all data from SQLite database and Whoosh index

get(code)

graph_technosphere(filename=None, **kwargs)

load(*args, **kwargs)

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).

make_searchable(reset=False)

make_unsearchable()

new_activity(code, **kwargs)

process()

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)

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

search(string, **kwargs)

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)

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.

bw2data.backends.peewee.database._VALID_KEYS