`bw2data.backends.peewee`#

Submodules#

Package Contents#

Classes#

`Activity`	A MutableMapping is a generic container for associating
`ActivityDataset`
`Exchange`	A MutableMapping is a generic container for associating
`ExchangeDataset`
`PickleField`
`SQLiteBackend`	A base class for LCI backends.
`SubstitutableDatabase`

Attributes#

`projects`
`sqlite3_lci_db`

class bw2data.backends.peewee.Activity(document=None, **kwargs)[source]#

Bases: bw2data.proxies.ActivityProxyBase

Inheritance diagram of bw2data.backends.peewee.Activity

A MutableMapping is a generic container for associating key/value pairs.

This class provides concrete generic implementations of all methods except for __getitem__, __setitem__, __delitem__, __iter__, and __len__.

Create an Activity proxy object.

If this is a new activity, can pass kwargs.

If the activity exists in the database, document should be an ActivityDataset.

property key#

_change_code(new_code)#

_change_database(new_database)#

biosphere()#

copy(code=None, **kwargs)#

Copy the activity. Returns a new Activity.

code is the new activity code; if not given, a UUID is used.

kwargs are additional new fields and field values, e.g. name=’foo’

delete()#

exchanges()#

new_exchange(**kwargs)#: Create a new exchange linked to this activity

production()#

rp_exchange()#

Return an Exchange object corresponding to the reference production. Uses the following in order:

The production exchange, if only one is present
The production exchange with the same name as the activity reference product.

Raises ValueError if no suitable exchange is found.

save()#

substitution()#

technosphere(include_substitution=True)#

upstream(kinds=('technosphere',))#

class bw2data.backends.peewee.ActivityDataset[source]#

Bases: peewee.Model

Inheritance diagram of bw2data.backends.peewee.ActivityDataset

code#

data#

database#

location#

name#

product#

type#

class bw2data.backends.peewee.Exchange(document=None, **kwargs)[source]#

Bases: bw2data.proxies.ExchangeProxyBase

Inheritance diagram of bw2data.backends.peewee.Exchange

A MutableMapping is a generic container for associating key/value pairs.

This class provides concrete generic implementations of all methods except for __getitem__, __setitem__, __delitem__, __iter__, and __len__.

Create an Exchange proxy object.

If this is a new exchange, can pass kwargs.

If the exchange exists in the database, document should be an ExchangeDataset.

delete()#

save()#

class bw2data.backends.peewee.ExchangeDataset[source]#

Bases: peewee.Model

Inheritance diagram of bw2data.backends.peewee.ExchangeDataset

data#

input_code#

input_database#

output_code#

output_database#

type#

class bw2data.backends.peewee.PickleField[source]#

Bases: peewee.BlobField

Inheritance diagram of bw2data.backends.peewee.PickleField

db_value(value)#

python_value(value)#

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

Bases: bw2data.backends.base.LCIBackend

Inheritance diagram of bw2data.backends.peewee.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,
        }
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.

class bw2data.backends.peewee.SubstitutableDatabase(filepath, tables)[source]#

Bases: object

property db#

_create_database()#

atomic()#

change_path(filepath)#

execute_sql(*args, **kwargs)#

transaction()#

vacuum()#

bw2data.backends.peewee.projects[source]#

bw2data.backends.peewee.sqlite3_lci_db[source]#

bw2data.backends.peewee#

Submodules#

Package Contents#

Classes#

Attributes#

`bw2data.backends.peewee`#