bw2data.backends.iotable

Package Contents

Classes

ActivityDataset
ExchangeDataset
IOTableBackend	IO tables have too much data to store each value in a database; instead, we only store the processed data in NumPy arrays.
SQLiteBackend	A base class for LCI backends.

Functions

dict_as_activitydataset(ds)

Attributes

MAX_INT_32
TYPE_DICTIONARY

exception bw2data.backends.iotable.UnknownObject

Bases: BW2Exception

Base class for exceptions in Brightway2

Initialize self. See help(type(self)) for accurate signature.

class bw2data.backends.iotable.ActivityDataset

Bases: peewee.Model

code

data

database

location

name

product

type

class bw2data.backends.iotable.ExchangeDataset

Bases: peewee.Model

data

input_code

input_database

output_code

output_database

type

class bw2data.backends.iotable.IOTableBackend(*args, **kwargs)

Bases: bw2data.backends.peewee.SQLiteBackend

IO tables have too much data to store each value in a database; instead, we only store the processed data in NumPy arrays.

Activities will not seem to have any activities.

backend = 'iotable'

process()

No-op; no intermediate data to process

write(products, exchanges, includes_production=False, **kwargs)

Write IO data to disk in two different formats.

Product data is stored in SQLite as normal activities. Exchange data is written directly to NumPy structured arrays.

products is a dictionary of product datasets in the normal format.

exchanges is a list of exchanges with the format (input code, output code, type, value).

class bw2data.backends.iotable.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.iotable.dict_as_activitydataset(ds)

bw2data.backends.iotable.MAX_INT_32 = 4294967295

bw2data.backends.iotable.TYPE_DICTIONARY