Files changed (17)
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-Neither the name of ETH Zürich nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-Brightway2 is a framework for advanced life cycle assessment calculations. It consists of several components which each accomplish specific tasks. This package is a container for all the separate components, for ease of documentation and installation.
-Brightway2 is inspired by the Brightway software, which was developed during Chris Mutel's PhD work at ETH Zurich, but is a complete rewrite focusing on simplicity, power, and ease of use. Brightway2 can run on all major operating systems.
+Brightway2 is a framework for advanced life cycle assessment calculations. It consists of several components which each accomplish specific tasks. This package is a container for all the separate components, for ease of documentation and installation.
+Brightway2 is inspired by the Brightway software, which was developed during Chris Mutel's PhD work at ETH Zurich, but is a complete rewrite focusing on simplicity, power, and ease of use. Brightway2 can run on all major operating systems.
+Brightway2 is designed to be easy to use and develop for. The modular structure of Brightway2 means that you don't have to learn everything at once - pick the subject that best suits your interests and skills, download the code, and start hacking!
+Learning to program is hard - luckily, Python is a great language for beginners. Here are some good beginning resources:
+* `How to think like a computer scientist - Think Python <http://www.greenteapress.com/thinkpython/>`_
+Mercurial is a distributed version control system, which records changes made in your source code over time, and allows changes from multiple people to merged to a single code base. `hginit <http://hginit.com/>`_ is a good guide to get started with Mercurial.
+The preferred way to submit changes is with a pull request on Bitbucket. See the `pull request docs <http://blog.bitbucket.org/2011/06/17/pull-request-revamp/>`_ for an illustrated examples. Pull requests which add code would ideally also include documentation and tests.
+One easy way of helping out that doesn't require any knowledge of Python, matrices, or even actually life cycle assessment at all, is to help make the existing graphics better or introduce new ones. Each graphic in the LCA report is also available in a online:
+The code here is editable, and the changes you make will be immediately reflected in the display. Feel free to make some tweaks, or even major changes, to make the visualizations nicer, easier to understand, and simpler. If you have for other graphics that would be useful in interpreting LCA results, or in exploring inventory datasets or impact assessment methods, feel free to :ref:`contact-developers` to get a smaple dataset.
+There are plenty of big and small things that can be done to improve all aspects of the Brightway2 calculation routines and and data management.
+ * Follow the Zen of Python - if you don't know what this is, try typing ``import this`` in a python shell.
+ * Follow style guides like `PEP 8 <http://www.python.org/dev/peps/pep-0008/>`_. Tools like `pylint <http://pypi.python.org/pypi/pylint>`_ can help.
+There are a number of parameters in the `Force-directed graph`_, such as link distance and circle radius, which can be tuned to make the graph easier to understand. Go ahead and try to change them a bit and see what happens!
+Here are some possibilities we could include in either LCA reports, or in exploring or analyzing inventory databases:
+ * `Collapsible force-directed <http://mbostock.github.com/d3/talk/20111116/force-collapsible.html>`_
+Those who know a bit about design, or at least think that they do, are welcome to make the report page better. Here is an `example report page <http://reports.brightwaylca.org/report/fb20439529cb414784e25acb8b3ef426>`_.
+Each of the three calculational packages has an `online report available <http://coverage.brightwaylca.org/>`_. Many of the test coverage failures can be easily resolved with simple tests, and writing simple tests is a great way to get started with Python and Brightway2.
+Tests always have edge cases that weren't anticipated by the developers, and coverage doesn't test for exceptions. Finding these edge cases or exceptions is a thankless but extremely important part of making robust software.
+The current LCA class uses ``self`` attributes extensively to store data during the calculation. A move to a more functional style, where inputs are explicitly passed, and outputs returned, would make the tests more robust and independent. It would also make it easier to write LCA subclasses. So, for example, move from this code:
+LCA inequality tests are a measure of how much an individual LCA score is determined by just a few LCI datasets, and as such is important for measuring data quality and result robustness. The `concentration index <http://en.wikipedia.org/wiki/Concentration_ratio>`_ and the `Herfindahl index <http://en.wikipedia.org/wiki/Herfindahl_index>`_ are already included in ``bw2analyzer.contribution.ContributionAnalysis``, but the `Gini coefficient <http://en.wikipedia.org/wiki/Gini_coefficient>`_, which is more widely known would be nice to have as well.
+The base Brightway2 data format doesn't include fields for all of the Ecospold data format, but we can still export that data that is available in the Ecospold format. This would help in making Brightway2 data more tranportable. It is not necessarily a dificult task, but writing a lot of XML processing code is never very much fun.
+Because the actual data stored in a Brightway2 inventory dataset is relatively simple, it should be possible to create a couple of simple forms for adding and editing new datasets. The only difficulty is in making a usable user interface; so, for example, it should be easy to link new technosphere or biosphere inputs, with some autcompletion or other easy searching.
+The standard way to explore inventory databases is with a category tree, and it would be helpful to have somethng like that, but one can also think of exploring a database by mass type, name, location, or other types of faceting. It would probably be advisable to include some nice visualizations with D3, as this is relatively simply done, and can add a great deal of usability for end users.
+Similarly, we would also like to be able to browse and edit impact assessment methods, looking at names, types of emissions and resource consumptions, and categories.
+Sankey diagrams are helpful for showing the flows of raw material inputs or environmental impact through the supply chain. There are some `initial ideas <http://blog.bitjuice.com.au/2013/02/using-d3-js-to-visualise-hierarchical-classification/>`_ , see also `a simpler example <http://bost.ocks.org/mike/sankey/>`_ on how to do this in D3, but the problem here is actually twofold:
+ #. Disaggregating the supply chain graph in a reasonable fashion without having it either collapse or retain too many deep links
+Brightway2 has a mailing list: email@example.com. You can register at the `Google groups site <https://groups.google.com/forum/?fromgroups#!forum/brightway2>`_.
-Brightway2 is a simple framework for life cycle assessment (LCA). Its focus is on efficient calculation and visualization. Brightway2 is a complete rewrite of the original Brightway, which was a previous LCA framework developed during the PhD thesis of Chris Mutel.
+Brightway2 is a new framework for life cycle assessment (LCA). Its focus is on efficient calculation and visualization.
-.. warning:: Brightway2 is in heavy development, and while it is used by mutiple people every day, it is probably not ready for people who don't like digging into source code and filing bug reports.
-Because existing LCA software is not very good at calculations. Brightway2 is not trying to replace software such as OpenLCA or SimaPro; rather, it is designed for individual analysts to be able to do cutting edge calculations on their computers, their servers, or in the cloud.
-The life cycle assessment calculators are the most advanced part of Brightway2. For those that are interested, a full technical guide is available. For the rest of you, suffice it to say that LCA calculations are powerful and efficient (working with LCI databases of hundreds of thousands of processes has been done successfully), and the Monte Carlo implementation allows for effective use of modern computers. On a semi-modern laptop, around 100 Monte Carlo iterations per core are possible, and each core can be used in parallel.
-Treemaps and Hinton matrices are already part of the standard LCA report, and new visualizations using the D3 library are planned.
-Brightway2 uses a very simple data structure. Instead of a database, which is powerful but difficult to install or upgrade, Brightway2 uses a data directory, and saves data as Python datastructures serialized to normal files. The location of the data directory can be configured; default is in your home directory. Although this approach loses some of the benefits of relational databases, it has several advantages:
-* You can easily share your work with someone else by copying the data directory and sending it to your colleagues. Syncing services like dropbox can also be easily used.
-This is the easiest way to get started using Brightway2 on **Windows**. If you are interested in using the full power of the Brightway2 framework, or are using **Mac OS X** or **Linux**, see other installation options:
-First, download the latest version of `Python (x,y) <https://code.google.com/p/pythonxy/wiki/Downloads>`_, and install it. This is the easiest way to get the `NumPy <http://numpy.scipy.org/>`_ and `SciPy <http://scipy.org/>`_ libraries.
-Second, download and install the XML processing library `lxml <http://pythonxy.googlecode.com/files/lxml-3.0.1-1_py27.exe>`_.
-This should start the program, and open a new web browser tab to the correct address. Brightway2 will recognize that you are starting Brightway2 for the first time, and give you instructions on how to download basic data, import your projects, and start working.
+ Brightway2 is currently only compatible with python 2.7, not python 3. Brightway2 will remain 2.7 only until `flask <http://pypi.python.org/pypi/Flask>`_ and its dependencies are ported to Python 3.
Although Brightway2 is relatively simple, installation of the numerical and scientific libraries can be difficult as there is no default compilers installed on most Windows machines. The only sensible way is to use a precompiled set of packages, such as `Python (x,y) <https://code.google.com/p/pythonxy/wiki/Downloads>`_. Using `Anaconda Community Edition <http://continuum.io/anacondace.html>`_, or the `Enthought Python Distribution <http://www.enthought.com/products/epd.php>`_ is also possible, but not tested (they have custom package management commands). If using Python (x,y), be sure to install `lxml <http://pythonxy.googlecode.com/files/lxml-3.0.1-1_py27.exe>`_ separately.
After the basic installation, you can install all additional Brightway2 packages and dependencies in one command in the command shell:
If you want to develop with Brightway2, then don't install the metapackage. Instead, first install `virtualenv <http://www.virtualenv.org/>`_ and `virtualenv for Powershell <https://bitbucket.org/guillermooo/virtualenvwrapper-powershell>`_:
If you want to develop with Brightway, then don't install the metapackage. Instead, we will create a `virtualenv <http://www.virtualenv.org/>`_ for the Brightway2 dependencies and framework. First, read what ``virtualenv`` does; then, run the following in a Terminal:
sudo port install virtualenv virtualenvwrapper py27-cython py27-nose py27-sphinx py27-flask py27-requests
If you want to develop with Brightway, then don't install the metapackage. Instead, we will create a `virtualenv <http://www.virtualenv.org/>`_ for the Brightway2 dependencies and framework. First, read what ``virtualenv`` does; then, run the following in a Terminal:
If you want to install packages manually, or not install everything, Brightway2 uses the following Python packages:
+All Brightway2 data is stored in a data directory, but the location of the directory can be chosen by the user. The data directory is just a bunch of subdirectories and files, so it is safe for backup programs or sync services like Dropbox.
+ You can ignore all these technical details if you create a file called ``brightway2`` in your home directory, and don't want to do anything fancy.
+The user can specify the ``data directory`` location in any of three different ways. In all cases, the directory should already exist. The first thing that Brightway will look for is the `environment variable <http://foo.bar>`_ ``BRIGHTWAY2_DIR``. If this is found, then it is the location of the ``data directory``. An environment variable is especially convenient if you have multiple copies of Brightway2 installed on one machine, or if you want to keep separate workspaces for different projects.
+ * Unix/Mac: ``export BRIGHTWAY2_DIR=/path/to/brightway2/directory``. Add this to your ``.profile`` or similar file to have this set each time you open a terminal window.
+ * Windows 7: Use ``setx BRIGHTWAY2_DIR=\path\to\brightway2\directory`` to set an environment variable permanently.
+The second thing that Brightway2 will try is a file called ``.brightway2path`` in your home directory. If this file is present, it should have one line, which is the directory location. No quoting or special characters are needed.
+Because it can be difficult to work with so-called "dot-files", whose name starts with a ``.``, Brightway2 will also try to read a file call ``brightway2path.txt`` in your home directory. This works the same as the ``.brightway2path`` file.
+Finally, Brightway2 will try to see if there is a writeable directory in your home directory called ``brightway2``.
+If none of these attempts succeed, Brightway2 will work in a temporary directory, but will complain about it, as these directories can be deleted by the operating system.
+In Brightway2, a ``database`` is the term used to organize a set of activity datasets. Databases can be big, like ecoinvent, or as small as one dataset. You can have as many databases as you like, and databases can link into other databases. You can also have two databases that each depend on each other.
+When Brightway2 is set up, it downloads and installs a special ``biosphere`` database. This database has all the resource and emission flows from the ecoinvent database, and is the database that imported life cycle impact assessment methods will link to.
+You can define biosphere flows - resources and emissions - in any database you like, but it is probably best to use the pre-defined flows in the ``biosphere`` database whenever you can. If you need to add some custom flows, feel free to create a separate new database.
+An activity dataset is a document - just some text, with a minial amount of formatting. For example, here is a Brightway2 activity dataset from the US LCI:
+There are some elements which might seem mysterious, and some elements which just make sense. I hope that things like ``name`` and ``unit`` don't need any explanation. The list of ``exchanges`` might be a bit more difficult to understand at first, because there are some weird fields like ``code`` and ``group`` which are left over from the import process. Actually, the list of required fields is quite small.
+ * They are a section of human-readable data that you can manipulate manually in a text editor, or change en masse programmatically.
+ * Because they can be exported as text, and in a format that is accessible to almost every computer language (`JSON <http://www.json.org/>`_), activity datasets can be easily exported and used by other programs without spending hour messing around with XML which is constructed slightly differently by each LCA program.
+ * Activity datasets have a small number of required fields, but allow any additional information you would like to add, so that it is easy to add whatever custom data you need for your application. #TODO: Examples
+Linking activity datasets within and between databases requires a way to uniquely identify each dataset. Brightway uses the idea that each dataset has a unique code. A code can be a number, like ``1``, or a string of numbers and letters, like ``swiss ch33se``. When you create datasets manually, you will need to assign each dataset a code. When you import a database, the codes will be automatically generated for you.
+When you import an *ecospold* dataset, the codes that are generated automatically look like a bunch of nonsense, like this: ``6d336c64e3a0ff08dee166a1dfdf0946``. Although the *ecospold* format does include numbers, and some producers of ecoinvent use those numbers in a meaningful way, every other program that produces *ecospold* messes the numbers up, and so we can't believe them.
+We want to have a way of identifying datasets which is consistent from machine to machine, so that it is easier to share and work with datasets without have to relink activities. The way Brightways identifies an activity or flow is with the `MD5 <http://en.wikipedia.org/wiki/MD5>`_ hash of a few attributes: the ``name``, ``location``, ``unit``, and ``categories``. The function is ``bw2data.utils.activity_hash``, but the procedure is simple: concatenate the name, each category, the unit and the location, all as lower-case strings. If an attribute doesn't have a value, ignore it. Then take the `MD5 <http://en.wikipedia.org/wiki/MD5>`_ hash of the resulting string.
+Exchanges are a list of the inputs and outputs of an activity. For example an activity might consume some resources, emit some emissions, and have other technoligcal goods as emissions. Each activity also has at least one technological output.
+Each exchange has a ``type``, which indicates where the exchange goes to or comes from. The predefined types are as follows:
+ * ``production``: How much of the main output is produced by this dataset. A ``production`` exchange is not required, and when absent, a default value of 1 is used.
+ * ``biosphere``: A consumption of a resource, or an emission to the environment. These flows are normally from the :ref:`biosphere-database`.
+Brightway2 cannot, by itself, directly handle multi-output activities. However, you can include multi-output activites with substitution (see #TODO), and the **ecospold** importer will allocate multi-output datasets. This lack of support for multi-output datasets is due to Brightway2 being centered on matrix-calculations, which require a square technosphere matrix. If each dataset did not have precisely one output, the technosphere matrix would be rectangular, and therefore not generally solvable.
+In Brightway2, each impact assessment method is a set of characterization factors for a set of biosphere flows. Each impact category and subcategory is a separate method, and each method is stored and calculated separately.
+which is probably most applicable for those who are particularly concerned with ice cream resource depletion; a more typical example is:
+Impact assessment method names can have any length and number of qualifiers, but must always be a list of strings.
+ For technical reasons, impact assessment names must be stored as a `tuple <http://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences>`_, not a `list <http://docs.python.org/2/tutorial/introduction.html#lists>`_, i.e. they must have ``()`` at the beginning and end, and not ````.
+Why is the Python standard library module `pickle <http://docs.python.org/2/library/pickle.html>`_ as the local data storage format?
+The ``pickle`` module is fast, portable, and built-in. While using compression (such as gzip and bzip2) would reduce the size of the saved files, it also dramatically increases loading and saving times, by a factor of 3 - 30, depending on the test. Overall, the speed of ``pickle`` `seems to be fine <http://kbyanc.blogspot.ch/2007/07/python-serializer-benchmarks.html>`_.
+The ``marshal`` module is faster - 40% faster writing, 25% faster reading - but produces files twice as big, and can change from computer to computer or even when Python is upgraded. The costs and potential risks of ``marshal`` overwhelm its speed gains.
+Unlike ``JSON``, ``pickle`` can save all Python objects, and is consistently faster when considering all target operating systems. Moreover, ``pickle`` is part of the standard library, so no additional installation is necessary. There does not appear to be one standard ``JSON`` library, see e.g. `anyjson <http://pypi.python.org/pypi/anyjson/>`_, `yajl <http://pypi.python.org/pypi/yajl>`_, and `ujson <http://pypi.python.org/pypi/ujson/>`_, in addition to the builtin.
+`JSON <http://www.json.org/>`_ is a great format for data interchange, and for humans to edit. Some metadata, such as the LCI databases and LCIA methods installed, and user preferences, are stored in JSON. These are files that humans might want to change manually, so it makes sense for them to be easy to edit. These files are also relatively small, and could be accessed by other programming languages.
+There is a very basic set of metadata stored about each inventory database, stored in the file ``databases.json``. To get the metadata about a database, do something like the following:
+ See also the `databases manager documentation <http://bw2data.readthedocs.org/en/latest/technical.html#bw2data.meta.Databases>`_
+ * *version*: The integer version number of this database. Each time a database is saved this number is automatically incremented.
+A database consists of inventory datasets, and inventory datasets have a required form and a number of required fields. However, these requirements form a minimum needed for LCA calculations - you can always add extra fields as needed by your application.
+ * *categories* (list of strings, optional): A list of categories and subcategories. Can have any length.
+ * *uncertainty type* (integer): Integer code for uncertainty distribution of this exchange, see :ref:`uncertainty-type` for more information.
+ * ``production`` is an exchange that describes how much this activity produces. A ``production`` exchange is not required - the default value is 1.
+ * *input* (database name, database code): The technological activity that is linked to, e.g. ``("my new database", "production of ice cream")`` or ``('biosphere', '51447e58e03a40a2bbd9abf45214b7d3')``. See also :ref:`dataset-codes`.
+ * *comment* (string, optional): A comment on this exchange. Used to store pedigree matrix data in ecoinvent v2.
+ * *maximum* (float, optional): A statistical parameter whose meaning depends on the :ref:`uncertainty-type`.
+ * *miniumum* (float, optional): A statistical parameter whose meaning depends on the :ref:`uncertainty-type`.
+ * *sigma* (float, optional): A statistical parameter whose meaning depends on the :ref:`uncertainty-type`.
+ * *type* (string): One of ``process``, ``emission``, or ``resource``, but you can add custom types. Not needed for calculations; intended for data processing.
+ Database documents can be validated with ``bw2data.validate.db_validator(my_data)``, or ``Database("my database name").validate(my_data)``.
+ All distributions (where it is applicable) can be bounded, i.e. you can specify and minimum and maximum value in addition to other parameters. This can be helpful in ensuring, for example, that distributions are always postive.
+The integer *uncertainty type* fields are defined in a separate software package called `bw-stats-toolkit <https://bitbucket.org/cmutel/bw-stats-toolkit>`_. The uncertainty types are:
+ * ``2``: Lognormal distribution. This is **purposely** handled in an inconsistent fashion, unfortunately. The ``amount`` field is the median of the data, and the ``sigma`` field is the standard deviation of the data **when it is log-transformed**, i.e. the σ from the formula for the log-normal PDF.
+ * ``5``: Triangular distribution. Picks values between ``minimum`` and ``maximum``, with a mode of ``amount``.
+ * ``6``: Bernoulli distribution. ``amount`` is the cutoff between yes and no. ``maximum`` and ``minimum`` can rescale the interval away from (0, 1).
+ * ``7``: `Discrete uniform <http://en.wikipedia.org/wiki/Uniform_distribution_(discrete)>`_ distribution picks integer values between ``minimum`` and ``maximum``.
+ * ``10``: Beta distribution. ``amount`` is α, and ``sigma`` is β. ``maximum`` is a scaling parameter.
+There is a very basic set of metadata stored about each model, stored in the file ``methods.json``. To get the metadata about a method, do something like the following:
+ See also the `methods manager documentation <http://bw2data.readthedocs.org/en/latest/technical.html#bw2data.meta.Methods>`_
+ * *abbreviation*: Becuase LCIA methods have long and complicated names, Brightway2 abbreviates them to get a safe filename to save the data.
+The impact assessment method documents are quite simple - indeed, it is a bit of a stretch to call them documents at all. Instead, they are a list of biosphere flow references, characterization factors, and locations. All LCIA methods in Brightway2 are regionalized, though the default installed methods only provide global characterization factors. Here is a simple example:
+ #. A location, which is used because Brightway2 will soon gain the ability to do regionalized LCA.
+The current format does not include fields for characterizing the uncertainty of the characterization factors, but the processed characterization matrices do, and it is anticipated that this functionality will be added relatively soon.
+ LCIA method documents can be validated with ``bw2data.validate.ia_validator(my_data)``, or ``Method(("my", "method", "name")).validate(my_data)``.
+Both inventory datasets and impact assessment methods are stored as structured text files, but these files are not efficient when constructing the technosphere, biosphere, and characterization matrices. These text documents are stored in the ``intermediate`` folder. Brightway2 also has a ``processed`` folder, which stores only the data needed to construct the various computational matrices. These data are stored as `numpy structured arrays <http://docs.scipy.org/doc/numpy/user/basics.rec.html>`_.
+For both databases and LCIA methods, the method ``.write(some_data)`` will write an *intermediate* data file, while the subsequent method ``.process()`` will transform the intermediate data file to an array. These two functions are intentionally separate, as it is sometimes desirable to do one and not the other.
+ Every time you save a new version of an inventory database or an impact assessment method, e.g. with ``my_database.write(my_data)``, be sure to also call ``my_database.process()``, or your changes will not be used in LCA calculations.
+LCA reports calculated with ``bw2analyzer.report.SerializedLCAReport`` are written as a JSON file to disk. It has the following data format:
+Brightway2 has a format for transferring inventory data between computers. This format is called ``bw2package``, and is an inventory database written to JSON, and then compressed with bzip2. ``bw2package`` is compressed JSON because ``pickle`` is `not a safe data transfer format <http://docs.python.org/2/library/pickle.html>`_, and because JSON is readable by other programs and programming languages. The JSON dataformat is:
+There is a separate format for impact assessment methods, which are stored in a ``bw2iapackage`` file. This is also compressed JSON, and has a similar format:
+This package provides facilities for managing LCI databases and LCIA methods, as well as input and output scripts.
+This package provides classes for LCA calculations, both static and uncertain, and basic regionalized LCA.
+This package provides functions for interpreting and analyzing LCI databases, LCIA methods, and LCA results.
+This is the easiest way to get started using Brightway2 on **Windows**. If you are interested in using the full power of the Brightway2 framework, or are using **Mac OS X** or **Linux**, see other installation options:
+First, download the latest version of `Python (x,y) <https://code.google.com/p/pythonxy/wiki/Downloads>`_, and install it. This is the easiest way to get the `NumPy <http://numpy.scipy.org/>`_ and `SciPy <http://scipy.org/>`_ libraries.
+Second, download and install the XML processing library `lxml <http://pythonxy.googlecode.com/files/lxml-3.0.1-1_py27.exe>`_.
+ * ``bw2-controller.py details <name>``: Give details on inventory database ``<name>``. If the database name has spaces in it, it should be quoted, like this: ``"name with spaces"``.
+ * ``bw2-controller.py copy <name> <newname>``: Copy inventory database ``<name>`` to new name ``<newname>``.
+ * ``bw2-controller.py versions <name>``: List the versions available of inventory database ``<name>``.
+ * ``bw2-controller.py revert <name> <revision>``: Revert inventory database ``<name>`` to version number ``<revision>``.
+ * ``bw2-controller.py remove <name>``: Deregister inventory database ``<name>``. Does not delete data, only removes it from the Brightway2 register.
+ * ``bw2-controller.py import <path> <name>``: Import a set of inventory data in the Ecospold data format from location ``<path>`` to inventory database ``<name>``.
+ * ``bw2-controller.py export <name> [--include-dependencies]``: Export inventory database ``<name>`` to a bw2package format. If ``--include-dependencies`` is part of the command, the bw2package will include the dependent databases as well.
-Brightway2 is now installed, and there are three ways to access the various parts of the framework.